diff --git a/Agda.cabal b/Agda.cabal --- a/Agda.cabal +++ b/Agda.cabal @@ -1,10 +1,10 @@ name: Agda -version: 2.6.0.1 +version: 2.6.1 cabal-version: >= 1.10 build-type: Custom license: OtherLicense license-file: LICENSE -author: Agda 2 was originally written by Ulf Norell, partially based on code from Agda 1 by Catarina Coquand and Makoto Takeyama, and from Agdalight by Ulf Norell and Andreas Abel. Agda 2 is currently actively developed mainly by Andreas Abel, Guillaume Allais, Jesper Cockx, Nils Anders Danielsson, Philipp Hausmann, Fredrik Nordvall Forsberg, Ulf Norell, Víctor López Juan, Andrés Sicard-Ramírez, and Andrea Vezzosi. Further, Agda 2 has received contributions by, amongst others, Stevan Andjelkovic, Marcin Benke, Jean-Philippe Bernardy, Guillaume Brunerie, James Chapman, Dominique Devriese, Péter Diviánszky, Olle Fredriksson, Adam Gundry, Daniel Gustafsson, Kuen-Bang Hou (favonia), Patrik Jansson, Alan Jeffrey, Wolfram Kahl, Wen Kokke, Fredrik Lindblad, Francesco Mazzoli, Stefan Monnier, Darin Morrison, Guilhem Moulin, Nicolas Pouillard, Nobuo Yamashita, Christian Sattler, and Makoto Takeyama and many more. +author: Agda 2 was originally written by Ulf Norell, partially based on code from Agda 1 by Catarina Coquand and Makoto Takeyama, and from Agdalight by Ulf Norell and Andreas Abel. Agda 2 is currently actively developed mainly by Andreas Abel, Guillaume Allais, Jesper Cockx, Nils Anders Danielsson, Philipp Hausmann, Fredrik Nordvall Forsberg, Ulf Norell, Víctor López Juan, Andrés Sicard-Ramírez, and Andrea Vezzosi. Further, Agda 2 has received contributions by, amongst others, Stevan Andjelkovic, Marcin Benke, Jean-Philippe Bernardy, Guillaume Brunerie, James Chapman, Liang-Ting Chen, Dominique Devriese, Péter Diviánszky, Olle Fredriksson, Adam Gundry, Daniel Gustafsson, Kuen-Bang Hou (favonia), Patrik Jansson, Alan Jeffrey, Wolfram Kahl, Wen Kokke, Fredrik Lindblad, Francesco Mazzoli, Stefan Monnier, Darin Morrison, Guilhem Moulin, Nicolas Pouillard, Nobuo Yamashita, Christian Sattler, and Makoto Takeyama and many more. maintainer: Ulf Norell homepage: http://wiki.portal.chalmers.se/agda/ bug-reports: https://github.com/agda/agda/issues @@ -33,21 +33,53 @@ policy, because it is not intended to be used by third-party packages. -tested-with: GHC == 7.10.3 - GHC == 8.0.2 +tested-with: GHC == 8.0.2 GHC == 8.2.2 GHC == 8.4.4 GHC == 8.6.5 + GHC == 8.8.3 extra-source-files: CHANGELOG.md README.md + doc/release-notes/2.6.0.1.md + doc/release-notes/2.6.0.md + doc/release-notes/2.5.4.2.md + doc/release-notes/2.5.4.1.md + doc/release-notes/2.5.4.md + doc/release-notes/2.5.3.md + doc/release-notes/2.5.2.md + doc/release-notes/2.5.1.2.md + doc/release-notes/2.5.1.1.md + doc/release-notes/2.5.1.md + doc/release-notes/2.4.2.5.md + doc/release-notes/2.4.2.4.md + doc/release-notes/2.4.2.3.md + doc/release-notes/2.4.2.2.md + doc/release-notes/2.4.2.1.md + doc/release-notes/2.4.2.md + doc/release-notes/2.4.0.2.md + doc/release-notes/2.4.0.1.md + doc/release-notes/2.4.0.md + doc/release-notes/2.3.2.2.md + doc/release-notes/2.3.2.1.md + doc/release-notes/2.3.2.md + doc/release-notes/2.3.0.md + doc/release-notes/2.2.10.md + doc/release-notes/2.2.8.md + doc/release-notes/2.2.6.md + doc/release-notes/2.2.2.md + doc/release-notes/2.2.4.md + doc/release-notes/2.2.0.md +-- Liang-Ting (2019-11-26): See Issues #4216 doc/user-manual.pdf - src/full/undefined.h - stack-7.10.3.yaml - stack-8.0.2.yaml - stack-8.2.2.yaml - stack-8.4.4.yaml + stack-8.8.3.yaml +-- ASR (2020-03-09). I'll keep the below file until a resolver for GHC8.8.3 +-- is available. + stack-8.8.2.yaml stack-8.6.5.yaml + stack-8.4.4.yaml + stack-8.2.2.yaml + stack-8.0.2.yaml data-dir: src/data data-files: Agda.css @@ -63,10 +95,12 @@ lib/prim/Agda/Builtin/Cubical/Id.agda lib/prim/Agda/Builtin/Cubical/Sub.agda lib/prim/Agda/Builtin/Cubical/Glue.agda + lib/prim/Agda/Builtin/Cubical/HCompU.agda lib/prim/Agda/Builtin/Equality.agda lib/prim/Agda/Builtin/Equality/Erase.agda lib/prim/Agda/Builtin/Equality/Rewrite.agda lib/prim/Agda/Builtin/Float.agda + lib/prim/Agda/Builtin/Float/Properties.agda lib/prim/Agda/Builtin/FromNat.agda lib/prim/Agda/Builtin/FromNeg.agda lib/prim/Agda/Builtin/FromString.agda @@ -75,6 +109,7 @@ lib/prim/Agda/Builtin/List.agda lib/prim/Agda/Builtin/Nat.agda lib/prim/Agda/Builtin/Reflection.agda + lib/prim/Agda/Builtin/Reflection/Properties.agda lib/prim/Agda/Builtin/Sigma.agda lib/prim/Agda/Builtin/Size.agda lib/prim/Agda/Builtin/Strict.agda @@ -96,7 +131,7 @@ source-repository this type: git location: https://github.com/agda/agda.git - tag: v2.6.0.1 + tag: v2.6.1 flag cpphs default: False @@ -115,26 +150,21 @@ Enable the --count-clusters flag. (If enable-cluster-counting is False, then the --count-clusters flag triggers an error message.) --- ASR (2018-09-14). Every new setup dependency should also be added --- as a library dependency. See Issue #3225. custom-setup - setup-depends: base >= 4.8.0.0 && < 4.13 - , Cabal >= 1.22.5.0 && < 2.5 - , filepath >= 1.4.0.0 && < 1.5 - , process >= 1.2.3.0 && < 1.7 - , directory >= 1.2.2.0 && < 1.4 + setup-depends: base >= 4.9.0.0 && < 4.15 + , Cabal >= 1.24.0.0 && < 3.3 + , directory >= 1.2.6.2 && < 1.4 + , filepath >= 1.4.1.0 && < 1.5 + , process >= 1.4.2.0 && < 1.7 library hs-source-dirs: src/full - include-dirs: src/full if flag(cpphs) -- We don't write an upper bound for cpphs because the -- `build-tools` field can not be modified in Hackage. - -- If your change the lower bound of cpphs also change it in the - -- `.travis.yml` file [Issue #2315]. - build-tools: cpphs >= 1.20.8 + build-tools: cpphs >= 1.20.9 ghc-options: -pgmP cpphs -optP --cpp if flag(debug) @@ -145,7 +175,7 @@ build-depends: text-icu == 0.7.* if os(windows) - build-depends: Win32 >= 2.3.1.0 && < 2.7 + build-depends: Win32 >= 2.3.1.1 && < 2.7 -- Agda cannot be built with GHC 8.6.1 due to a compiler bug, see -- Agda Issue #3344. @@ -157,64 +187,66 @@ if os(windows) && impl(ghc == 8.6.3) buildable: False - build-depends: aeson >= 0.11.3.0 && < 1.5 - , array >= 0.5.1.0 && < 0.6 + build-depends: aeson >= 1.1.2.0 && < 1.5 + , array >= 0.5.1.1 && < 0.6 , async >= 2.2 && < 2.3 - , base >= 4.8.0.0 && < 4.13 - , binary >= 0.7.3.0 && < 0.9 + , base >= 4.9.0.0 && < 4.15 + , binary >= 0.8.3.0 && < 0.9 , blaze-html >= 0.8 && < 0.10 , boxes >= 0.1.3 && < 0.2 - , bytestring >= 0.10.6.0 && < 0.11 - , containers >= 0.5.6.2 && < 0.7 + , bytestring >= 0.10.8.1 && < 0.11 + , containers >= 0.5.7.1 && < 0.7 , data-hash >= 0.2.0.0 && < 0.3 - , deepseq >= 1.4.1.1 && < 1.5 - , directory >= 1.2.2.0 && < 1.4 - -- EdisonCore 1.3.2 doesn't compile with GHC 7.10.*. - , EdisonCore == 1.3.1.1 || >= 1.3.2.1 && < 1.4 + , deepseq >= 1.4.2.0 && < 1.5 + , directory >= 1.2.6.2 && < 1.4 , edit-distance >= 0.2.1.2 && < 0.3 , equivalence >= 0.3.2 && < 0.4 -- exceptions-0.8 instead of 0.10 because of stack , exceptions >= 0.8 && < 0.11 - , filepath >= 1.4.0.0 && < 1.5 + , filepath >= 1.4.1.0 && < 1.5 , geniplate-mirror >= 0.6.0.6 && < 0.8 , gitrev >= 1.3.1 && < 2.0 -- hashable 1.2.0.10 makes library-test 10x -- slower. The issue was fixed in hashable 1.2.1.0. -- https://github.com/tibbe/hashable/issues/57. - , hashable >= 1.2.1.0 && < 1.3 + , hashable >= 1.2.1.0 && < 1.4 -- There is a "serious bug" -- (https://hackage.haskell.org/package/hashtables-1.2.0.2/changelog) -- in hashtables 1.2.0.0/1.2.0.1. This bug seems to -- have made Agda much slower (infinitely slower?) in -- some cases. , hashtables >= 1.2.0.2 && < 1.3 - , haskeline >= 0.7.2.1 && < 0.8 + , haskeline >= 0.7.2.3 && < 0.9 , ieee754 >= 0.7.8 && < 0.9 -- mtl-2.1 contains a severe bug. -- -- mtl >= 2.2 && < 2.2.1 doesn't export Control.Monad.Except. , mtl >= 2.2.1 && < 2.3 , murmur-hash >= 0.1 && < 0.2 - , pretty >= 1.1.2.0 && < 1.2 - , process >= 1.2.3.0 && < 1.7 - , regex-tdfa >= 1.2.2 && < 1.3 - , split >= 0.2.0.0 && < 0.2.3.4 + , pretty >= 1.1.3.3 && < 1.2 + , process >= 1.4.2.0 && < 1.7 + , regex-tdfa >= 1.3.1.0 && < 1.4 + , split >= 0.2.0.0 && < 0.2.4 , stm >= 2.4.4 && < 2.6 , strict >= 0.3.2 && < 0.4 - , template-haskell >= 2.10.0.0 && < 2.15 - , time >= 1.5.0.1 && < 1.9 + , template-haskell >= 2.11.0.0 && < 2.17 + , time >= 1.6.0.1 && < 1.10 , unordered-containers >= 0.2.5.0 && < 0.3 , uri-encode >= 1.5.0.4 && < 1.6 + , zlib == 0.6.* -- In hTags the mtl library must be compiled with the version of -- transformers shipped with GHC, so we use that version in Agda (see, -- for example, Issue #2983). - if impl(ghc >= 8.6.4) && impl(ghc < 8.6.6) + if impl(ghc >= 8.6.4) && impl(ghc < 8.10.2) build-depends: transformers == 0.5.6.2 if impl(ghc >= 8.4) && impl(ghc < 8.6.4) build-depends: transformers == 0.5.5.0 + if impl(ghc < 8.4) + build-depends: transformers == 0.5.2.0 + -- ASR (2018-10-16). Required for supporting GHC 8.4.1, 8.4.2 and -- 8.4.3. See Issue #3277. if impl(ghc >= 8.4.1) && impl(ghc <= 8.4.3) @@ -222,24 +254,8 @@ else build-depends: text >= 1.2.3.1 && < 1.3 - if impl(ghc >= 8.0) && impl(ghc < 8.4) - build-depends: transformers == 0.5.2.0 - - -- ASR (2018-09-14). We add the dependency on the filemanip library - -- due to Issue #3225. - if impl(ghc < 8.0) - build-depends: transformers == 0.4.2.0 - , filemanip >= 0.3.6.2 && < 0.4 - - -- zlib >= 0.6.1 is broken with GHC < 7.10.3. See Issue 1518. - if impl(ghc < 7.10.3) - build-depends: zlib >= 0.4.0.1 && < 0.6.1 - else - build-depends: zlib >= 0.4.0.1 && < 0.7 - - if impl(ghc < 8.0) - -- provide/emulate `Data.Semigroups` API for pre-GHC8 - build-depends: semigroups == 0.18.* + if impl(ghc >= 8.4) + build-depends: ghc-compact == 0.1.* -- We don't write upper bounds for Alex nor Happy because the -- `build-tools` field can not be modified in Hackage. Agda doesn't @@ -288,12 +304,14 @@ Agda.Compiler.Treeless.Unused Agda.ImpossibleTest Agda.Interaction.AgdaTop + Agda.Interaction.Base Agda.Interaction.BasicOps Agda.Interaction.SearchAbout Agda.Interaction.CommandLine Agda.Interaction.EmacsCommand Agda.Interaction.EmacsTop Agda.Interaction.JSONTop + Agda.Interaction.JSON Agda.Interaction.FindFile Agda.Interaction.Highlighting.Common Agda.Interaction.Highlighting.Dot @@ -319,7 +337,6 @@ Agda.Interaction.Options.Lenses Agda.Interaction.Options.Warnings Agda.Main - Agda.Syntax.Abstract.Copatterns Agda.Syntax.Abstract.Name Agda.Syntax.Abstract.Pattern Agda.Syntax.Abstract.PatternSynonyms @@ -346,6 +363,7 @@ Agda.Syntax.Internal Agda.Syntax.Internal.Defs Agda.Syntax.Internal.Generic + Agda.Syntax.Internal.MetaVars Agda.Syntax.Internal.Names Agda.Syntax.Internal.Pattern Agda.Syntax.Internal.SanityCheck @@ -375,7 +393,6 @@ Agda.Termination.CallGraph Agda.Termination.CallMatrix Agda.Termination.CutOff - Agda.Termination.Inlining Agda.Termination.Monad Agda.Termination.Order Agda.Termination.RecCheck @@ -391,6 +408,7 @@ Agda.TypeChecking.CompiledClause.Match Agda.TypeChecking.Constraints Agda.TypeChecking.Conversion + Agda.TypeChecking.Conversion.Pure Agda.TypeChecking.Coverage Agda.TypeChecking.Coverage.Match Agda.TypeChecking.Coverage.SplitTree @@ -404,7 +422,6 @@ Agda.TypeChecking.Errors Agda.TypeChecking.Free Agda.TypeChecking.Free.Lazy - Agda.TypeChecking.Free.Old Agda.TypeChecking.Free.Precompute Agda.TypeChecking.Free.Reduce Agda.TypeChecking.Forcing @@ -418,6 +435,7 @@ Agda.TypeChecking.Irrelevance Agda.TypeChecking.Level Agda.TypeChecking.LevelConstraints + Agda.TypeChecking.Level.Solve Agda.TypeChecking.MetaVars Agda.TypeChecking.MetaVars.Mention Agda.TypeChecking.MetaVars.Occurs @@ -449,7 +467,10 @@ Agda.TypeChecking.Positivity Agda.TypeChecking.Positivity.Occurrence Agda.TypeChecking.Pretty + Agda.TypeChecking.Pretty.Call + Agda.TypeChecking.Pretty.Warning Agda.TypeChecking.Primitive + Agda.TypeChecking.Primitive.Base Agda.TypeChecking.Primitive.Cubical Agda.TypeChecking.ProjectionLike Agda.TypeChecking.Quote @@ -460,7 +481,10 @@ Agda.TypeChecking.Reduce.Fast Agda.TypeChecking.Reduce.Monad Agda.TypeChecking.Rewriting + Agda.TypeChecking.Rewriting.Clause + Agda.TypeChecking.Rewriting.Confluence Agda.TypeChecking.Rewriting.NonLinMatch + Agda.TypeChecking.Rewriting.NonLinPattern Agda.TypeChecking.Rules.Application Agda.TypeChecking.Rules.Builtin Agda.TypeChecking.Rules.Builtin.Coinduction @@ -500,16 +524,17 @@ Agda.TypeChecking.Warnings Agda.TypeChecking.With Agda.Utils.AffineHole + Agda.Utils.Applicative Agda.Utils.AssocList Agda.Utils.Bag Agda.Utils.Benchmark Agda.Utils.BiMap - Agda.Utils.Char Agda.Utils.Cluster Agda.Utils.Empty Agda.Utils.Environment Agda.Utils.Except Agda.Utils.Either + Agda.Utils.Fail Agda.Utils.Favorites Agda.Utils.FileName Agda.Utils.Float @@ -519,7 +544,6 @@ Agda.Utils.Graph.AdjacencyMap.Unidirectional Agda.Utils.Graph.TopSort Agda.Utils.Hash - Agda.Utils.HashMap Agda.Utils.Haskell.Syntax Agda.Utils.Impossible Agda.Utils.IndexedList @@ -540,10 +564,8 @@ Agda.Utils.Memo Agda.Utils.Monad Agda.Utils.Monoid - Agda.Utils.NonemptyList Agda.Utils.Null Agda.Utils.Parser.MemoisedCPS - Agda.Utils.Parser.ReadP Agda.Utils.PartialOrd Agda.Utils.Permutation Agda.Utils.Pointer @@ -552,6 +574,7 @@ Agda.Utils.SemiRing Agda.Utils.Singleton Agda.Utils.Size + Agda.Utils.SmallSet Agda.Utils.String Agda.Utils.Suffix Agda.Utils.Three @@ -570,51 +593,43 @@ other-modules: Paths_Agda - -- Initially, we disable all the warnings. - ghc-options: -w - - -- This option must be the first one after disabling the warnings. See - -- Issue #2094. - if impl(ghc >= 8.0) - ghc-options: -Wunrecognised-warning-flags - - ghc-options: -fwarn-deprecated-flags - -fwarn-deriving-typeable - -fwarn-dodgy-exports - -fwarn-dodgy-foreign-imports - -fwarn-dodgy-imports - -fwarn-duplicate-exports - -fwarn-empty-enumerations - -fwarn-hi-shadowing - -fwarn-identities - -fwarn-incomplete-patterns - -fwarn-inline-rule-shadowing - -fwarn-missing-fields - -fwarn-missing-methods - -fwarn-missing-signatures - -fwarn-tabs - -fwarn-typed-holes - -fwarn-overflowed-literals - -fwarn-overlapping-patterns - -fwarn-unrecognised-pragmas - -fwarn-unticked-promoted-constructors - -fwarn-unused-do-bind - -fwarn-warnings-deprecations - -fwarn-wrong-do-bind - - -- These options will be removed in GHC 8.0.1. - if impl(ghc < 8.0) - ghc-options: -fwarn-context-quantification - -fwarn-duplicate-constraints - -fwarn-pointless-pragmas - - if impl(ghc >= 8.0) - ghc-options: -Wmissing-pattern-synonym-signatures - -Wnoncanonical-monad-instances - -Wnoncanonical-monoid-instances - -Wsemigroup - -Wunused-foralls + -- NOTE: If adding flags, also add to `.ghci800` + ghc-options: -fexpose-all-unfoldings + -fspecialise-aggressively + -- Initially, we disable all the warnings. + -w + -- This option must be the first one after disabling the + -- warnings. See Issue #2094. + -Wunrecognised-warning-flags + -Wdeprecated-flags + -Wderiving-typeable + -Wdodgy-exports + -Wdodgy-foreign-imports + -Wdodgy-imports + -Wduplicate-exports + -Wempty-enumerations + -Widentities + -Wincomplete-patterns + -Winline-rule-shadowing + -Wmissing-fields + -Wmissing-methods + -Wmissing-pattern-synonym-signatures + -Wmissing-signatures + -Wnoncanonical-monad-instances + -Wnoncanonical-monoid-instances + -Woverflowed-literals + -Woverlapping-patterns + -Wsemigroup + -Wtabs + -Wtyped-holes + -Wunrecognised-pragmas + -Wunticked-promoted-constructors + -Wunused-do-bind + -Wunused-foralls + -Wwarnings-deprecations + -Wwrong-do-bind + -- NOTE: If adding flags, also add to `.ghci820` if impl(ghc >= 8.2) ghc-options: -Wcpp-undef -- ASR TODO (2017-07-23): `make haddock` fails when @@ -623,13 +638,31 @@ -Wsimplifiable-class-constraints -Wunbanged-strict-patterns + -- NOTE: If adding flags, also add to `.ghci860` if impl(ghc >= 8.6) ghc-options: -Winaccessible-code + -Wstar-binder + -Wstar-is-type + if impl(ghc >= 8.6) && impl(ghc < 8.10) + -- ASR TODO (2020-02-03). This warning was deprecated in + -- GHC 8.10.1-rc1. I'm waiting the final release for removing + -- it (Issue #4242). + ghc-options: -Wimplicit-kind-vars + + if impl(ghc < 8.10) + -- ASR TODO (2020-02-03). This warning was deprecated in + -- GHC 8.10.1-rc1. I'm waiting the final release for removing + -- it (Issue #4242). + ghc-options: -Whi-shadowing + default-language: Haskell2010 default-extensions: ConstraintKinds - , DataKinds + --L-T Chen (2019-07-15): + -- Enabling DataKinds only locally makes the compile time + -- slightly shorter, see PR #3920. + --, DataKinds , DefaultSignatures , DeriveFoldable , DeriveFunctor @@ -647,8 +680,8 @@ , RecordWildCards , ScopedTypeVariables , StandaloneDeriving - , TypeSynonymInstances , TupleSections + , TypeSynonymInstances executable agda hs-source-dirs: src/main @@ -662,21 +695,26 @@ -- Nothing is used from the following package, -- except for the prelude. - , base >= 4.8.0.0 && < 6 + , base >= 4.9.0.0 && < 6 default-language: Haskell2010 -- If someone installs Agda with the setuid bit set, then the -- presence of +RTS may be a security problem (see GHC bug #3910). -- However, we sometimes recommend people to use +RTS to control -- Agda's memory usage, so we want this functionality enabled by -- default. - ghc-options: -rtsopts + -- The threaded RTS by default starts a major GC after a program has + -- been idle for 0.3 s. This feature turned out to be annoying, so + -- the idle GC is now by default turned off (-I0). + ghc-options: -threaded -rtsopts + "-with-rtsopts=-M3.5G -I0" + executable agda-mode hs-source-dirs: src/agda-mode main-is: Main.hs other-modules: Paths_Agda - build-depends: base >= 4.8.0.0 && < 4.13 - , directory >= 1.2.2.0 && < 1.4 - , filepath >= 1.4.0.0 && < 1.5 - , process >= 1.2.3.0 && < 1.7 + build-depends: base >= 4.9.0.0 && < 4.15 + , directory >= 1.2.6.2 && < 1.4 + , filepath >= 1.4.1.0 && < 1.5 + , process >= 1.4.2.0 && < 1.7 default-language: Haskell2010 diff --git a/CHANGELOG.md b/CHANGELOG.md --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,11384 +1,846 @@ -Release notes for Agda version 2.6.0.1 -====================================== - -Installation and infrastructure -------------------------------- - -* Added support for GHC 8.6.5. - -List of all closed issues -------------------------- - -For 2.6.0.1, the following issues have been closed -(see [bug tracker](https://github.com/agda/agda/issues)): - - - [#3685](https://github.com/agda/agda/issues/3685): Support GHC 8.6.5 - - [#3692](https://github.com/agda/agda/issues/3692): Omission of absurd patterns in automatically added absurd clauses causes too optimistic polarity. - - [#3694](https://github.com/agda/agda/issues/3694): Importing Agda.Builtin.Size in one module affects another module - - [#3696](https://github.com/agda/agda/issues/3696): Make `AgdaAny` polykinded? - - [#3697](https://github.com/agda/agda/issues/3697): Panic when checking non-Setω data definitions with --type-in-type - - [#3701](https://github.com/agda/agda/issues/3701): [ re agda/agda-stdlib#710 ] toNat for machine words is injective - - [#3731](https://github.com/agda/agda/issues/3731): GHC backend thinks that a constructor called 'main' is the main program - - [#3742](https://github.com/agda/agda/issues/3742): Strange error message for code that combines mutual and abstract - -Release notes for Agda version 2.6.0 -==================================== - -Highlights ----------- - -* Added support for [Cubical - Agda](https://agda.readthedocs.io/en/v2.6.0/language/cubical.html) - which adds new features such as univalence and higher inductive - types to Agda. - -* Added support for ML-style [automatic generalization of - variables](https://agda.readthedocs.io/en/v2.6.0/language/generalization-of-declared-variables.html). - -* Added a new sort ``Prop`` of [definitionally proof-irrelevant - propositions](https://agda.readthedocs.io/en/v2.6.0/language/prop.html). - -* The implementation of [instance - search](https://agda.readthedocs.io/en/v2.6.0/language/instance-arguments.html) - got a major overhaul and no longer supports overlapping instances - (unless enabled by a flag). - -Installation and infrastructure -------------------------------- - -* Added support for GHC 8.6.4. - -* Interface files for all builtin and primitive files are now - re-generated each time Agda is installed. - -Syntax ------- - -* Agda now supports implicit generalization of declared - variables. Variables to be generalized can declared with the new - keyword `variable`. For example: - - ```agda - postulate - Con : Set - - variable - Γ Δ θ : Con - ``` - - Declared variables are automatically generalized in type signatures, - module telescopes and data type and record parameters and indices: - - ```agda - postulate - Sub : Con → Con → Set - - id : Sub Γ Γ - -- -- equivalent to - -- id : {Γ : Con} → Sub Γ Γ - - _∘_ : Sub Θ Δ → Sub Γ Θ → Sub Γ Δ - -- -- equivalent to - -- _∘_ : {Γ Δ Θ : Con} → Sub Θ Δ → Sub Γ Θ → Sub Γ Δ - ``` - - See the [user manual](https://agda.readthedocs.io/en/v2.6.0/language/generalization-of-declared-variables.html) - for more details. - -* Data type and record definitions separated from their type signatures can no - longer repeat the types of the parameters, but can bind implicit parameters - by name [Issue [#1886](https://github.com/agda/agda/issues/1886)]. - - This is now allowed - ```agda - data D {a b} (A : Set a) (B : Set b) : Set (a ⊔ lsuc b) - data D {b = b} A B where - mkD : (A → Set b) → D A B - ``` - but this is not - ```agda - data I (A : Set) : Set - data I (A : Set) where - ``` - -* The label used for named implicit arguments can now be different from the - name of the bound variable [Issue [#952](https://github.com/agda/agda/issues/952)]. - - Example, - ```agda - id₁ : {A = X : Set} → X → X - id₁ x = x - - id₂ : ∀ {B = X} → X → X - id₂ {B = X} x = id₁ {A = X} x - - test : Nat - test = id₁ {A = Nat} 5 + id₂ {B = Nat} 6 - ``` - Only implicit and instance arguments can have a label and either or both of - the label and bound variable can be `_`. Labeled bindings with a type - signature can only bind a single variable. For instance, the type `Set` has - to be repeated here: - ```agda - const : {A = X : Set} {B = Y : Set} → X → Y → X - const x _ = x - ``` - -* The rules for parsing of patterns have changed slightly [Issue - [#3400](https://github.com/agda/agda/issues/3400)]. - - Now projections are treated similarly to constructors: In a pattern - name parts coming from projections can only be used as part of - projections, constructors or pattern synonyms. They cannot be used - as variables, or as part of the name of the defined value. - - Examples: - - * The following code used to be syntactically ambiguous, but is now - parsed, because A can no longer be used as a variable: - ```agda - record R : Set₂ where - field - _A : Set₁ - - open R - - r : R - r A = Set - ``` - - * On the other hand the following code is no longer parsed: - ```agda - record R : Set₁ where - field - ⟨_+_⟩ : Set - - open R - - + : Set → Set - + A = A - ``` - - -Type checking -------------- - -* Agda now supports a cubical mode which adds new features from - [Cubical Type Theory](https://arxiv.org/abs/1611.02108), including - univalence and higher inductive types. Option `--cubical` enables - the cubical mode, and cubical primitives are defined in the module - `Agda.Primitive.Cubical`. See the [user - manual](https://agda.readthedocs.io/en/v2.6.0/language/cubical.html) - for more info. - -* Agda now supports the new sort ``Prop`` of [definitionally - proof-irrelevant propositions](https://hal.inria.fr/hal-01859964). - Option `--prop` enables the `Prop` universe but is off by default. - Option `--no-prop` disables the `Prop` universe. See the [user - manual](https://agda.readthedocs.io/en/v2.6.0/language/prop.html) - for more details. - - In the absense of `Prop`, the sort `Set` is the lowest sort, thus, - the sort annotation `: Set` can be ommitted if the sort is - constrained to be weakly below `Set`. For instance: - - ```agda - {-# OPTIONS --no-prop #-} - - data Wrap A : Set where - wrap : A → Wrap A - ``` - - In contrast, when `--prop` is enabled the sort of `A` could be - either `Set` or `Prop` so this code no longer typechecks. - -* Agda now allows omitting absurd clauses in case one of the pattern - variable inhabits an obviously empty type - [Issue [#1086](https://github.com/agda/agda/issues/1086)]. - For example: - ```agda - f : Fin 1 → Nat - f zero = 0 - -- f (suc ()) -- this clause is no longer required - ``` - Absurd clauses are still required in case deep pattern matching is - needed to expose the absurd variable, or if there are no non-absurd - clauses. - - Due to the changes to the coverage checker required for this new - feature, Agda will now sometimes construct a different case when - there are multiple valid splitting orders. In some cases this may - impact the constraints that Agda is able to solve (for example, see - [#673](https://github.com/agda/agda-stdlib/pull/673) on the - standard library). - -* Since Agda 2.5.3, the hiding is considered part of the name in the - insertion of implicit arguments. Until Agda 2.5.2, the following - code was rejected: - ```agda - test : {{X : Set}} {X : Set} → Set - test {X = X} = X - ``` - The rationale was that named argument `X` is given with the wrong hiding. - The new rationale is that the hiding is considered part of the name, - distinguishing `{{X}}` from `{X}`. - This language change was accidential and has not been documented in - the 2.5.3 release notes. - -* Agda no longer allows case splitting on irrelevant arguments of - record types (see Issue - [#3056](https://github.com/agda/agda/issues/3056)). - -* Metavariables in module telescopes are now sometimes frozen later - [Issue [#1063](https://github.com/agda/agda/issues/1063)]. - - Metavariables created in the types of module parameters used to be - frozen right after the module's first mutual block had been - type-checked (unless, perhaps, if the module itself was contained in - a mutual block). Now they are instead frozen at the end of the - module (with a similar caveat regarding an outer mutual block). - -* When `--without-K` is enabled, Agda no longer allows datatypes with - large indices. For example, the following definition of equality is - now forbidden when `--without-K` is enabled: - ```agda - data _≡₀_ {ℓ} {A : Set ℓ} (x : A) : A → Set where - refl : x ≡₀ x - ``` - -* The termination checker now also looks for recursive calls in the type of definitions. - This fixes an issue where Agda allowed very dependent types - [Issue [#1556](https://github.com/agda/agda/issues/1556)]. - - This change affects induction-induction, e.g. - ```agda - mutual - data Cxt : Set where - ε : Cxt - _,_ : (Γ : Cxt) (A : Ty Γ) → Cxt - - data Ty : (Γ : Cxt) → Set where - u : ∀ Γ → Ty Γ - Π : ∀ Γ (A : Ty Γ) (B : Ty (Γ , A)) → Ty Γ - - mutual - f : Cxt → Cxt - f ε = ε - f (Γ , T) = (f Γ , g Γ T) - - g : ∀ Γ → Ty Γ → Ty (f Γ) - g Γ (u .Γ) = u (f Γ) - g Γ (Π .Γ A B) = Π (f Γ) (g Γ A) (g (Γ , A) B) - - ``` - The type of `g` contains a call `g Γ _ --> f Γ` which is now taken - into account during termination checking. - -Instance search ---------------- - -* Instance argument resolution now also applies when there are - unconstrained metavariables in the type of the argument. For - example, if there is a single instance `eqBool : Eq Bool` in scope, - then an instance argument `{{eq : Eq _}}` will be solved to - `eqBool`, setting the value of the metavariable `_` to `Bool` in the - process. - -* By default, Agda no longer allows overlapping instances. Two - instances are defined to overlap if they could both solve the - instance goal when given appropriate solutions for their recursive - (instance) arguments. Agda used to choose between undecidable - instances based on the result of recursive instance search, but this - lead to an exponential slowdown in instance resolution. Overlapping - instances can be enabled with the flag `--overlapping-instances`. - -* Explicit arguments are no longer automatically turned into instance - arguments for the purpose of recursive instance search. Instead, - explicit arguments are left unresolved and will thus never be used. - - If an instance is declared which has explicit arguments, Agda will - raise a warning that this instance will never be considered by - instance search. - -* Instance arguments that are already solved by conversion checking - are no longer ignored by instance search. Thus the constructor of - the unit type must now be explicitly be declared as an instance in - order to be considered by instance search: - ```agda - record ⊤ : Set where - instance constructor tt - ``` - -* Instances are now (correctly) required to be in scope to be eligible - (see Issue [#1913](https://github.com/agda/agda/issues/1913) - and Issue [#2489](https://github.com/agda/agda/issues/2489) - ). - This means that you can no longer import instances from parameterised modules by - ```agda - import Some.Module Arg₁ Arg2 - ``` - without opening or naming the module. - -Reflection ----------- - -* New TC primitive `noConstraints` [Issue - [#2351](https://github.com/agda/agda/issues/2351)]: - - ```agda - noConstraints : ∀ {a} {A : Set a} → TC A → TC A - ``` - - The computation `noConstraints m` fails if `m` gives rise to new, - unsolved - ["blocking"](https://github.com/agda/agda/blob/4900ef5fc61776381f3a5e9c94ef776375e9e1f1/src/full/Agda/TypeChecking/Monad/Constraints.hs#L160-L174) - constraints. - -* New TC primitive `runSpeculative` [Issue - [#3346](https://github.com/agda/agda/issues/3346)]: - - ``` - runSpeculative : ∀ {a} {A : Set a} → TC (Σ A λ _ → Bool) → TC A - ``` - - The computation `runSpeculative m` runs `m` and either keeps the new - TC state (if the second component is `true`) or resets to the old TC - state (if it is `false`). - - -Interaction and error reporting -------------------------------- - -* A new command `agda2-elaborate-give` (C-c C-m) normalizes a goal input - (it repects the C-u prefixes), type checks, and inserts the normalized - term into the goal. - -* 'Solve constraints' (C-c C-s) now turns unsolved metavariables into new - interaction holes (see Issue [#2273](https://github.com/agda/agda/issues/2273)). - -* Out-of-scope identifiers are no longer prefixed by a '.' dot [Issue - [#3127](https://github.com/agda/agda/issues/3127)]. This notation - could be confused with dot patterns, postfix projections, and - irrelevance. Now Agda will do its best to make up fresh names for - out-of-scope identifiers that do not conflict with any existing - names. In addition, these names are marked as "(out of scope)" when - printing the context. - - The change affects the printing of terms, e.g. in error messages and - interaction, and the parsing of out-of-scope variables for - case splitting (`C-c C-c` in emacs). - -* Shadowed local variables are now assigned fresh names in error - messages and interactive goals [Issue - [#572](https://github.com/agda/agda/issues/572)]. For example, - consider the following piece of code: - ```agda - postulate P : Set -> Set - - test : (B : Set) -> P B -> P B - test = λ p p -> {!!} - ``` - When asking for the goal type, Agda will now print the following: - ``` - Goal: P p₁ - ———————————————————————————————————————————————————————————— - p : P p₁ - p = p₁ : Set (not in scope) - ``` - Shadowed top-level identifiers are printed using the qualified name, - for example in - ```agda - module M where - - postulate A : Set - - test : Set → A - test A = {!!} - ``` - Agda will now show the goal type as - ``` - Goal: M.A - ———————————————————————————————————————————————————————————— - A : Set - ``` - -* When case splitting (`C-c C-c` in emacs), Agda will now filter out - impossible cases (i.e. ones where at least one of the variables - could be replaced by an absurd pattern `()`). If all the clauses - produced by a case split are impossible, Agda will not filter out - any of them. - -Pragmas and options -------------------- - -* Consistency checking of options used. - - Agda now checks that options used in imported modules are consistent - with each other, e.g. a module using `--safe`, `--without-K`, - `--no-universe-polymorphism` or `--no-sized-types` may only import - modules with the same option, and modules using `--cubical` or - `--prop` must in turn use the same option. If an interface file has - been generated using different options compared to the current ones, - Agda will now re-typecheck the file. - [Issue [#2487](https://github.com/agda/agda/issues/2487)]. - -* New option `--cubical` to enable Cubical Agda. - -* New option `--prop` to enable the ``Prop`` sort, and `--no-prop` to - disable it (default). - -* New options `--guardedness` and `--no-guardedness` [Issue - [#1209](https://github.com/agda/agda/issues/1209)]. - - Constructor-based guarded corecursion is now only (meant to be) - allowed if the `--guardedness` option is active. This option is - active by default. The combination of constructor-based guarded - corecursion and sized types is not allowed if `--safe` is used, - and activating `--safe` turns off both `--guardedness` and - `--sized-types` (because this combination is known to be - inconsistent in the current implementation). If you want to use - either constructor-based guarded corecursion or sized types in - safe mode, then you can use `--safe --guardedness` or `--safe - --sized-types` respectively (in this order). - - The option `--no-guardedness` turns off constructor-based guarded - corecursion. - -* Option `--irrelevant-projections` is now off by default and - not considered `--safe` any longer. - Reason: There are consistency issues that may be systemic - [Issue [#2170](https://github.com/agda/agda/issues/2170)]. - -* New option `--no-syntactic-equality` disables the syntactic equality - shortcut used by the conversion checker. This will slow down - typechecking in most cases, but makes the performance more - predictable and stable under minor changes. - -* New option `--overlapping-instances` enables overlapping instances - by performing recursive instance search during pruning of instance - candidates (this used to be the default behaviour). Overlapping - instances can be disabled with `--no-overlapping-instances` - (default). - -* Option (and experimental feature) - `--guardedness-preserving-type-constructors` - has been removed. - [Issue [#3180](https://github.com/agda/agda/issues/3180)]. - -* Deprecated options `--sharing` and `--no-sharing` now raise an error. - -* New primitive `primErase`. It takes a proof of equality and returns a proof of - the same equality. `primErase eq` reduces to `refl` on the diagonal. `trustMe` - is not a primitive anymore, it is implemented using `primErase`. - - The primitive is declared in `Agda.Builtin.Equality.Erase`. - -* The `REWRITE` builtin is now bound to the builtin equality type from - `Agda.Builtin.Equality` in `Agda.Builtin.Equality.Rewrite` [Issue - [#3318](https://github.com/agda/agda/issues/3318)]. - -* New primitives `primCharToNatInjective` and `primStringToListInjective` - internalising the fact that `primCharToNat` and `primStringtoList` are - injective functions. They are respectively bound in `Agda.Builtin.Char.Properties` - and `Agda.Builtin.String.Properties`. - -* The option `--only-scope-checking` is now allowed together with `--safe`. - -* The option `--ignore-interfaces` no longer ignores the interfaces of - builtin and primitive modules. For experts, there is the option - `--ignore-all-interfaces` which also rechecks builtin and primitive - files. - -* The following deprecated compiler pragmas have been removed: - - ``` - {-# COMPILED f e #-} - {-# COMPILED_TYPE A T #-} - {-# COMPILED_DATA A D C1 .. CN #-} - {-# COMPILED_DECLARE_DATA #-} - {-# COMPILED_EXPORT f g #-} - {-# IMPORT M #-} - {-# HASKELL code #-} - {-# COMPILED_UHC f e #-} - {-# COMPILED_DATA_UHC A D C1 .. CN #-} - {-# IMPORT_UHC M #-} - {-# COMPILED_JS f e #-} - ``` - - See the [user manual](https://agda.readthedocs.io/en/v2.6.0/language/foreign-function-interface.html) - for how to use the `COMPILE` and `FOREIGN` pragmas that replaced these in Agda 2.5. - -### New warnings - -* A declaration of the form `f : A` without an accompanying definition - is no longer an error, but instead raises a warning. - -* A clause that has both an absurd pattern and a right-hand side is no - longer an error, but instead raises a warning. - -* An import statement for `M` that mentions names not exported by `M` - (in either `using`, `hiding`, or `renaming`) is no longer an - error. Instead, Agda will raise a warning and ignore the names. - -* Pragma, primitive, module or import statements in a mutual block - are no longer errors. Instead, Agda will raise a warning and ignore - these statements. - -### Pragmas and options concerning universes - -* New pragma `{-# NO_UNIVERSE_CHECK #-}`. - - The pragma `{-# NO_UNIVERSE_CHECK #-}` can be put in front of a data - or record type to disable universe consistency checking locally. - Example: - ```agda - {-# NO_UNIVERSE_CHECK #-} - data U : Set where - el : Set → U - ``` - Like the similar pragmas for disabling termination and positivity - checking, `{-# NO_UNIVERSE_CHECK #-}` cannot be used with `--safe`. - -* New builtin `SETOMEGA`. - - Agda's top sort `Setω` is now defined as a builtin in `Agda.Primitive` - and can be renamed when importing that module. - -* New option `--omega-in-omega`. - - The option `--omega-in-omega` enables the typing rule `Setω : Setω`. - Example: - ```agda - {-# OPTIONS --omega-in-omega #-} - open import Agda.Primitive - - data Type : Setω where - el : ∀ {ℓ} → Set ℓ → Type - ``` - Like `--type-in-type`, this makes Agda inconsistent. However, code - written using `--omega-in-omega` is still compatible with normal - universe-polymorphic code and can be used in such files. - -Emacs mode ----------- - -* Jump-to-definition now works for record field names in record expressions - and patterns. [Issue [#3120](https://github.com/agda/agda/issues/3120)] - ```agda - record R : Set₂ where - field f : Set₁ - - exp : R - exp = record { f = Set } - - pat : R → R - pat r@record { f = X } = record r { f = X } - ``` - Jump-to-definition (`M-.` or middle-click) on any of these `f`s - now jumps to the field declaration. - -* Commas "ʻ،⸲⸴⹁⹉、︐︑﹐﹑，､" and semi-colons "؛⁏፤꛶；︔﹔⍮⸵;" added - to the input mode. - -* It is now possible to customise the highlighting of more text in - pragmas [Issue [#2452](https://github.com/agda/agda/issues/2452)]. - - Some text was already highlighted. Now there is a specific face for - the remaining text (`agda2-highlight-pragma-face`). - -LaTeX backend -------------- - -* The code environment has two new options, `inline` and `inline*`. - - These options are for typesetting inline code. The implementation of - these options is a bit of a hack. Only use these options for - typesetting a single line of code without multiple consecutive - whitespace characters (except at the beginning of the line). - - When the option `inline*` is used space (`\AgdaSpace{}`) is added at - the end of the code, and when `inline` is used space is not added. - -* Now highlighting commands for things like "this is an unsolved - meta-variable" are applied on the outside of highlighting commands - for things like "this is a postulate" [Issue - [#2474](https://github.com/agda/agda/issues/2474)]. - - Example: Instead of generating - `\AgdaPostulate{\AgdaUnsolvedMeta{F}}` Agda now generates - `\AgdaUnsolvedMeta{\AgdaPostulate{F}}`. - -* The package `agda.sty` no longer selects any fonts, and no longer - changes the input or font encodings [Issue - [#3224](https://github.com/agda/agda/issues/3224)]. - - The new behaviour is the same as the old behaviour with the options - `nofontsetup` and `noinputencodingsetup`. These options have been - removed. - - One reason for this change is that several persons have received - complaints from reviewers because they have unwittingly used - non-standard fonts in submitted papers. Another is that the `utf8x` - option to `inputenc` is now deprecated. - - Note that Agda code is now less likely to typeset properly out of - the box. See the documentation for some hints about what to do if - this affects you. - -* Some text was by default typeset in math mode when LuaLaTeX or - XeLaTeX were used, and in text mode when pdfLaTeX was used. Now text - mode is the default for all of these engines. - -* Typesetting of pragmas should now work better [Issue - [#2452](https://github.com/agda/agda/issues/2452)]. - - The `\AgdaOption` command and `AgdaOption` colour have been replaced - by `\AgdaPragma` and `AgdaPragma`. The `\AgdaPragma` command is used - where `\AgdaOption` used to be used (for certain options), but also - in other cases (for other options and certain other text in - pragmas). - -* There is no longer any special treatment of the character `-` [Issue - [#2452](https://github.com/agda/agda/issues/2452)]. - - This might, depending on things like what font your are using, mean - that the token `--` is typeset like an en dash (–). However, this is - not the case for at least one common monospace font (in at least one - setting). - -* The default value of `\AgdaEmptySkip` has been changed from - `\baselineskip` to `\abovedisplayskip`. This could mean that less - vertical space is used to render empty lines in code blocks. - -HTML backend ------------- - -* New option `--html-highlight=[code,all,auto]`. - - The option `--html-highlight=code` makes the HTML-backend generate - files with: - - 0. No HTML footer/header - 1. Agda codes highlighted - 2. Non-Agda code parts as-is - 3. Output file extension as-is (i.e. `.lagda.md` becomes `.md`) - 4. For ReStructuredText, a `.. raw:: html\n` will be inserted - before every code blocks - - This makes it possible to use an ordinary Markdown/ReStructuredText - processor to render the generated HTML. - - This will affect all the files involved in one compilation, making - pure Agda code files rendered without HTML footer/header as well. - To use `code` with literate Agda files and `all` with pure Agda - files, use `--html-highlight=auto`, which means auto-detection. - - The old and default behaviour is still `--html-highlight=all`. - -List of all closed issues -------------------------- - -For 2.6.0, the following issues have been closed -(see [bug tracker](https://github.com/agda/agda/issues)): - - - [#572](https://github.com/agda/agda/issues/572): Shadowed identifiers should be preceded by a dot when printed - - [#723](https://github.com/agda/agda/issues/723): Instance search needs to know whether a meta must be a function type - - [#758](https://github.com/agda/agda/issues/758): No highlighting for syntax declarations - - [#887](https://github.com/agda/agda/issues/887): Case-split causes problems for coverage checker - - [#952](https://github.com/agda/agda/issues/952): Parse named implicit pi {x = y : A} -> B - - [#1003](https://github.com/agda/agda/issues/1003): No highlighting for ambiguous instance argument - - [#1063](https://github.com/agda/agda/issues/1063): Freeze metas in module telescope after checking the module? - - [#1086](https://github.com/agda/agda/issues/1086): Make absurd patterns not needed at toplevel - - [#1209](https://github.com/agda/agda/issues/1209): Guardedness checker inconsistency with copatterns - - [#1581](https://github.com/agda/agda/issues/1581): Fields of opened records sometimes highlighted, sometimes not - - [#1602](https://github.com/agda/agda/issues/1602): NonStrict arguments should be allowed to occur relevantly in the type - - [#1706](https://github.com/agda/agda/issues/1706): Feature request: ML-style forall-generalization - - [#1764](https://github.com/agda/agda/issues/1764): Type in type and universe polymorphism - - [#1886](https://github.com/agda/agda/issues/1886): Second copies of telescopes not checked? - - [#1909](https://github.com/agda/agda/issues/1909): parameters are not dropped from reflected pattern lambda - - [#1913](https://github.com/agda/agda/issues/1913): Names that are not in scope can sometimes be candidates for instance resolution - - [#1995](https://github.com/agda/agda/issues/1995): Correct names in goal types after multiple renaming imports. - - [#2044](https://github.com/agda/agda/issues/2044): Better diagnosis for failed instance search - - [#2089](https://github.com/agda/agda/issues/2089): ''No such module'' is a rude error message for private modules - - [#2153](https://github.com/agda/agda/issues/2153): PDF version of Language Documentation on readthedocs lacks most Unicode characters - - [#2273](https://github.com/agda/agda/issues/2273): C-c C-s should put new goals instead of underscores for unknown subterms - - [#2351](https://github.com/agda/agda/issues/2351): expose noConstraints to reflection framework - - [#2452](https://github.com/agda/agda/issues/2452): The LaTeX backend does not handle options very well - - [#2473](https://github.com/agda/agda/issues/2473): Don't reread the source code without checking that it is unchanged - - [#2487](https://github.com/agda/agda/issues/2487): Options used for different modules must be consistent with each other, and options used when loading an interface must be consistent with those used when the interface was created - - [#2489](https://github.com/agda/agda/issues/2489): Where clauses in functions leak instances to global instance search - - [#2490](https://github.com/agda/agda/issues/2490): possible non-terminating inference of instance arguments? - - [#2513](https://github.com/agda/agda/issues/2513): Extensible syntax for function space annotations - - [#2548](https://github.com/agda/agda/issues/2548): Move the "Old Reference Manual" to the current documentation - - [#2563](https://github.com/agda/agda/issues/2563): Improve documentation and error reporting related to instance resolution (especially unconstrained metavariables) - - [#2579](https://github.com/agda/agda/issues/2579): Import statements with module instantiation should not trigger an error message - - [#2618](https://github.com/agda/agda/issues/2618): Reflection and pattern-matching lambdas - - [#2670](https://github.com/agda/agda/issues/2670): Instance arguments and multi-sorted algebras - - [#2757](https://github.com/agda/agda/issues/2757): Proposal: split non-strict relevance into shape-irrelevance, parametricity, and runtime-irrelevance - - [#2760](https://github.com/agda/agda/issues/2760): Relax instance search restriction on unconstrained metas - - [#2774](https://github.com/agda/agda/issues/2774): Internal error with sized types - - [#2783](https://github.com/agda/agda/issues/2783): Make more primitive/builtin modules safe? - - [#2789](https://github.com/agda/agda/issues/2789): Narrow and broad options - - [#2791](https://github.com/agda/agda/issues/2791): More illtyped meta solutions - - [#2797](https://github.com/agda/agda/issues/2797): Relevance check missed for overloaded projection - - [#2833](https://github.com/agda/agda/issues/2833): Coverage checker splits on result too eagerly - - [#2837](https://github.com/agda/agda/issues/2837): The Emacs mode only handles LaTeX-based literate Agda - - [#2872](https://github.com/agda/agda/issues/2872): Case splitting adds a dot in front of pattern matches on Chars - - [#2880](https://github.com/agda/agda/issues/2880): Disallow FFI binding for defined functions when --safe is used - - [#2892](https://github.com/agda/agda/issues/2892): 'With' should also abstract over the type of stripped dot patterns - - [#2893](https://github.com/agda/agda/issues/2893): Display warnings also when an error is encountered - - [#2899](https://github.com/agda/agda/issues/2899): Add a warning for infix notations without corresponding fixity declaration - - [#2929](https://github.com/agda/agda/issues/2929): Turn "missing definition" into a warning - - [#2936](https://github.com/agda/agda/issues/2936): Sort warning flags alphabetically in user manual - - [#2939](https://github.com/agda/agda/issues/2939): make install-bin on a Mac can fail to install text-icu - - [#2964](https://github.com/agda/agda/issues/2964): Mismatch between order of matching in clauses and case tree; subject reduction broken - - [#2969](https://github.com/agda/agda/issues/2969): Module parameter is erased from dot pattern - - [#2979](https://github.com/agda/agda/issues/2979): Rewriting matching does not respect eta rules - - [#2993](https://github.com/agda/agda/issues/2993): Quadratic (failing) instance search - - [#3010](https://github.com/agda/agda/issues/3010): Field of opened record does not get highlighted - - [#3032](https://github.com/agda/agda/issues/3032): spurious meta in dot pattern - - [#3056](https://github.com/agda/agda/issues/3056): Matching on irrelevant variable of dependent record type should not be allowed - - [#3057](https://github.com/agda/agda/issues/3057): A module can export two definitions with the same name - - [#3068](https://github.com/agda/agda/issues/3068): Add option to turn off syntactic equality check - - [#3095](https://github.com/agda/agda/issues/3095): Would like to make hidden variable visible but it is created ambiguous - - [#3102](https://github.com/agda/agda/issues/3102): Performance regression: very slow reduction in the presence of many module parameters - - [#3114](https://github.com/agda/agda/issues/3114): Missing alpha-renaming when printing constraints - - [#3120](https://github.com/agda/agda/issues/3120): No tooltips for record field names in record expressions - - [#3122](https://github.com/agda/agda/issues/3122): Hidden record fields are not picked up from module in record expression - - [#3124](https://github.com/agda/agda/issues/3124): De Bruijn index in lhs checking error message - - [#3125](https://github.com/agda/agda/issues/3125): Internal error in InstanceArguments.hs:292 - - [#3127](https://github.com/agda/agda/issues/3127): Notation for out-of-scope variables conflicts with notation for irrelevance - - [#3128](https://github.com/agda/agda/issues/3128): Sigma builtin not added to setup, agdai file missing. - - [#3130](https://github.com/agda/agda/issues/3130): Conflict between dot pattern and postfix projection - - [#3137](https://github.com/agda/agda/issues/3137): Preserve Markdown as-is when outputting HTML - - [#3138](https://github.com/agda/agda/issues/3138): Result splitter introduces pattern variable that conflicts with constructor - - [#3139](https://github.com/agda/agda/issues/3139): Internal error in parser - - [#3147](https://github.com/agda/agda/issues/3147): Non-linear as-patterns - - [#3152](https://github.com/agda/agda/issues/3152): `give` in a do-block inserts spurious parentheses - - [#3153](https://github.com/agda/agda/issues/3153): Type checker fails to infer missing signature of module parameter. - - [#3161](https://github.com/agda/agda/issues/3161): Case splitter produces end-of-comment - - [#3169](https://github.com/agda/agda/issues/3169): Doc for rewriting - - [#3170](https://github.com/agda/agda/issues/3170): UnicodeDeclare fails with pdflatex from TeX Live 2018 - - [#3175](https://github.com/agda/agda/issues/3175): Instance resolution fails with defined method - - [#3176](https://github.com/agda/agda/issues/3176): Empty lambdas are sometimes considered definitionally equal, other times not - - [#3180](https://github.com/agda/agda/issues/3180): Remove feature `--guardedness-preserving-type-constructors` - - [#3188](https://github.com/agda/agda/issues/3188): Warnings disappear when fatal error is encountered - - [#3195](https://github.com/agda/agda/issues/3195): Internal error at Auto/Typecheck.hs:373 - - [#3196](https://github.com/agda/agda/issues/3196): Turning MissingDefinition into a warning - - [#3200](https://github.com/agda/agda/issues/3200): Function marked as irrelevant when it isn't - - [#3201](https://github.com/agda/agda/issues/3201): [ warning ] AbsurdPatternRequiresNoRHS - - [#3205](https://github.com/agda/agda/issues/3205): [ cleanup + warning ] ModuleDoesntExport can be recovered from - - [#3224](https://github.com/agda/agda/issues/3224): Switch from utf8x to utf8? Make agda.sty easier to maintain? - - [#3235](https://github.com/agda/agda/issues/3235): Cannot pass backend flags via emacs variable `agda2-program-args` - - [#3247](https://github.com/agda/agda/issues/3247): Support cabal-install >= 2.4.1.0 in the Makefile - - [#3248](https://github.com/agda/agda/issues/3248): Max of two sizes less than i - - [#3253](https://github.com/agda/agda/issues/3253): [ fix ] ignore duplicate declarations of libraries - - [#3254](https://github.com/agda/agda/issues/3254): `cpphs` doesn't build with GHC 8.6.* - - [#3256](https://github.com/agda/agda/issues/3256): Internal error at src/full/Agda/TypeChecking/Reduce.hs:148 - - [#3257](https://github.com/agda/agda/issues/3257): Anonymous top-level modules can have names with multiple components - - [#3258](https://github.com/agda/agda/issues/3258): Ordering the constructor names at Definition. - - [#3262](https://github.com/agda/agda/issues/3262): Suboptimal placement of "missing with-clauses" error - - [#3264](https://github.com/agda/agda/issues/3264): When refine leads to a termination error it should say so rather than "cannot refine" - - [#3268](https://github.com/agda/agda/issues/3268): [ haddock ] Fix haddock formatting - - [#3285](https://github.com/agda/agda/issues/3285): Internal error for syntax declaration - - [#3302](https://github.com/agda/agda/issues/3302): Multiple definitions called _ are sometimes allowed, sometimes not - - [#3307](https://github.com/agda/agda/issues/3307): `--no-unicode` bug: case splitting inside a pattern matching lambda still produces unicode arrows - - [#3309](https://github.com/agda/agda/issues/3309): Use of irrelevant arguments with copatterns and irrelevant fields - - [#3313](https://github.com/agda/agda/issues/3313): Add --html-highlight support for the HTML backend - - [#3315](https://github.com/agda/agda/issues/3315): The primErase primitive is not safe - - [#3318](https://github.com/agda/agda/issues/3318): Lots of primitives and builtins are not declared in the primitive/builtin modules - - [#3320](https://github.com/agda/agda/issues/3320): Extra indentation when code is hidden - - [#3323](https://github.com/agda/agda/issues/3323): Internal error with inconsistent irrelevance info between declaration and definition of data type - - [#3338](https://github.com/agda/agda/issues/3338): Missing Definitions not recognised in instance search - - [#3342](https://github.com/agda/agda/issues/3342): GHC panic on stack and GHC 7.10.3 - - [#3344](https://github.com/agda/agda/issues/3344): Disable compilation with GHC 8.6.1 - - [#3356](https://github.com/agda/agda/issues/3356): C-c C-s prints postfix projections by default - - [#3363](https://github.com/agda/agda/issues/3363): The wiki should support HTTPS - - [#3364](https://github.com/agda/agda/issues/3364): Funny scope error when trying to import as qualified - - [#3366](https://github.com/agda/agda/issues/3366): Add a command line flag to change the extension of the files generated by the HTML backend - - [#3368](https://github.com/agda/agda/issues/3368): Support GHC 8.6.2 - - [#3370](https://github.com/agda/agda/issues/3370): [ fix ] < and > need to be in math mode in latex - - [#3371](https://github.com/agda/agda/issues/3371): Document common LaTeX backend pitfalls - - [#3372](https://github.com/agda/agda/issues/3372): Provide some simple LaTeX backend templates - - [#3373](https://github.com/agda/agda/issues/3373): Wrap HTML in `raw` directive when working with ReStructuredText - - [#3379](https://github.com/agda/agda/issues/3379): Adding a tutorial set in the readthedocs frontpage - - [#3380](https://github.com/agda/agda/issues/3380): Too much erasure in strict backends - - [#3394](https://github.com/agda/agda/issues/3394): Internal error in mutual block with unsolved implicit argument in termination checker - - [#3400](https://github.com/agda/agda/issues/3400): Obscure parse error with copattern and infix field - - [#3403](https://github.com/agda/agda/issues/3403): Internal error in Agda.TypeChecking.Rules.Term - - [#3404](https://github.com/agda/agda/issues/3404): Positivity checker marks postulates as constant in mutual block - - [#3407](https://github.com/agda/agda/issues/3407): Internal error at "src/full/Agda/TypeChecking/Reduce/Fast.hs:1338" - - [#3409](https://github.com/agda/agda/issues/3409): No error if mapping the empty type to non-empty Haskell type - - [#3410](https://github.com/agda/agda/issues/3410): ghc backend generates program that segfaults - - [#3419](https://github.com/agda/agda/issues/3419): Allow unconstrained instances & disallow overlapping instances - - [#3420](https://github.com/agda/agda/issues/3420): Inductive definitions live in a larger set --without-K - - [#3425](https://github.com/agda/agda/issues/3425): Internal error at src/full/Agda/Termination/Monad.hs:177 - - [#3426](https://github.com/agda/agda/issues/3426): Termination checking false positive when using "where" - - [#3428](https://github.com/agda/agda/issues/3428): Another interal error in Substitute:72 when filling a hole - - [#3431](https://github.com/agda/agda/issues/3431): Rewrite rule doesn't fire during conversion checking - - [#3434](https://github.com/agda/agda/issues/3434): Regression related to instance resolution - - [#3435](https://github.com/agda/agda/issues/3435): Performance regression - - [#3439](https://github.com/agda/agda/issues/3439): Setω doesn’t respect --type-in-type - - [#3441](https://github.com/agda/agda/issues/3441): Generate Level expressions with fewer parentheses - - [#3442](https://github.com/agda/agda/issues/3442): Support GHC 8.6.3 - - [#3443](https://github.com/agda/agda/issues/3443): "internal error" in Agda of December 7, 2018 - - [#3444](https://github.com/agda/agda/issues/3444): `Setup.hs` is not generating the interface files - - [#3445](https://github.com/agda/agda/issues/3445): case splitting attempts to shadow constructor - - [#3451](https://github.com/agda/agda/issues/3451): The --no-sized-types option is broken - - [#3452](https://github.com/agda/agda/issues/3452): Case split on irrelevant argument goes through but is later rejected - - [#3454](https://github.com/agda/agda/issues/3454): Highlighting for incomplete pattern matching should be above highliting for non-exact split - - [#3456](https://github.com/agda/agda/issues/3456): [ new ] Injectivity of prim(NatToChar/StringToList) - - [#3461](https://github.com/agda/agda/issues/3461): Macro loop - - [#3463](https://github.com/agda/agda/issues/3463): Impossible to give certain instance arguments by name? - - [#3466](https://github.com/agda/agda/issues/3466): two definitionally equal terms are not equal - - [#3471](https://github.com/agda/agda/issues/3471): Can't install via cabal-install on current Haskell Platform - - [#3480](https://github.com/agda/agda/issues/3480): Parse error at EOF should be reported before EOF (especially if there is a long comment before EOF) - - [#3483](https://github.com/agda/agda/issues/3483): Internal error at TypeChecking/Monad/Signature.hs:732 - - [#3485](https://github.com/agda/agda/issues/3485): [ warnings ] for empty primitive blocks - - [#3491](https://github.com/agda/agda/issues/3491): Internal error src/full/Agda/TypeChecking/Rules/LHS.hs:294 after pattern matching - - [#3498](https://github.com/agda/agda/issues/3498): Internal error in activateLoadedFileCache - - [#3501](https://github.com/agda/agda/issues/3501): Case split in let clause causes internal error - - [#3503](https://github.com/agda/agda/issues/3503): Internal error in BasicOps - - [#3514](https://github.com/agda/agda/issues/3514): Accidential language change in 2.5.3: hiding is now part of name when resolving hidden argument insertion - - [#3517](https://github.com/agda/agda/issues/3517): Option consistency checking bug - - [#3518](https://github.com/agda/agda/issues/3518): Performance regression - - [#3521](https://github.com/agda/agda/issues/3521): Documentation: fixes a plural issue in copatterns - - [#3526](https://github.com/agda/agda/issues/3526): Do not generate trivially impossible clause when case-splitting - - [#3533](https://github.com/agda/agda/issues/3533): [ fix #3526 ] Remove trivially impossible clauses from case-split - - [#3534](https://github.com/agda/agda/issues/3534): Problem finding higher-order instances - - [#3536](https://github.com/agda/agda/issues/3536): Patternmatching on coinductive record fields breaks - - [#3544](https://github.com/agda/agda/issues/3544): internal error @ TypeChecking/Forcing.hs:227 - - [#3548](https://github.com/agda/agda/issues/3548): [ new ] Add support for compiling literate Org documents - - [#3554](https://github.com/agda/agda/issues/3554): Type checker explosion - - [#3561](https://github.com/agda/agda/issues/3561): fix typo: "FreBSD" => "FreeBSD" - - [#3566](https://github.com/agda/agda/issues/3566): Missing name when printing type of definition of a record - - [#3578](https://github.com/agda/agda/issues/3578): Pattern matching unifier normalizes too much - - [#3586](https://github.com/agda/agda/issues/3586): Internal error in ConcreteToAbstract.hs:2217 - - [#3590](https://github.com/agda/agda/issues/3590): Superlinear time required for simple code - - [#3597](https://github.com/agda/agda/issues/3597): Agda loops on simple code with a record and a hole - - [#3600](https://github.com/agda/agda/issues/3600): Size solver complains, explicit sizes work - - [#3610](https://github.com/agda/agda/issues/3610): Support GHC 8.6.4 - - [#3621](https://github.com/agda/agda/issues/3621): performance problem - - [#3631](https://github.com/agda/agda/issues/3631): Performance with --no-universe-polymorphism - - [#3638](https://github.com/agda/agda/issues/3638): Rewrite rules do not fire in goal normalization in parametrized module - - [#3639](https://github.com/agda/agda/issues/3639): Argument to function created by tactic is lost - - [#3640](https://github.com/agda/agda/issues/3640): Polarity: Size index check crashes due to wrong parameter number calculation - - [#3641](https://github.com/agda/agda/issues/3641): Remove old compiler pragmas - - [#3648](https://github.com/agda/agda/issues/3648): Agda could fail to build if a .agda-lib file exists in a parent directory - - [#3651](https://github.com/agda/agda/issues/3651): internal error ghc backend - - [#3657](https://github.com/agda/agda/issues/3657): Disable compilation with Windows and GHC 8.6.3 - - [#3678](https://github.com/agda/agda/issues/3678): Two out-of-scope variables are given the same name - - [#3687](https://github.com/agda/agda/issues/3687): Show module contents (C-c C-o) prints garbled names in clause - -Release notes for Agda version 2.5.4.2 -====================================== - -Installation and infrastructure -------------------------------- - -* Fixed installation with some old versions of `cabal-install` - [Issue [#3225](https://github.com/agda/agda/issues/3225)]. - -* Using `cpp` instead of `cpphs` as the default preprocessor - [Issue [#3223](https://github.com/agda/agda/issues/3223)]. - -* Added support for GHC 8.4.4. - -Other closed issues --------------------- - -For 2.5.4.2 the following issues have also been closed -(see [bug tracker](https://github.com/agda/agda/issues)): - - - [#3177](https://github.com/agda/agda/issues/3177): Slow typechecking with unsolved instance constraint - - [#3199](https://github.com/agda/agda/issues/3199): Panics when serialising absolute paths - - [#3312](https://github.com/agda/agda/issues/3312): Crash in Substitute.hs - -Release notes for Agda version 2.5.4.1 -====================================== - -Installation and infrastructure -------------------------------- - -* Generated the interface file for the `Sigma.agda` built-in when - installing Agda - [Issue [#3128](https://github.com/agda/agda/issues/3128)]. - -Emacs mode ----------- - -* Light highlighting is no longer applied continuously, but only when - the file is saved [Issue - [#3119](https://github.com/agda/agda/issues/3119)]. - -Release notes for Agda version 2.5.4 -==================================== - -Installation and infrastructure -------------------------------- - -* Added support for GHC 8.2.2 and GHC 8.4.3. - - Note that GHC 8.4.* requires `cabal-install` ≥ 2.2.0.0. - -* Removed support for GHC 7.8.4. - -* Included user manual in PDF format in `doc/user-manual.pdf`. - -Language --------- - -* Call-by-need reduction. - - Compile-time weak-head evaluation is now call-by-need, but each weak-head - reduction has a local heap, so sharing is not maintained between different - reductions. - - The reduction machine has been rewritten from scratch and should be faster - than the old one in all cases, even those not exploiting laziness. - -* Compile-time inlining. - - Simple definitions (that don't do any pattern matching) marked as INLINE are - now also inlined at compile time, whereas before they were only inlined by - the compiler backends. Inlining only triggers in function bodies and not in - type signatures, to preserve goal types as far as possible. - -* Automatic inlining. - - Definitions satisfying the following criteria are now automatically inlined - (can be disabled using the new NOINLINE pragma): - - - No pattern matching. - - Uses each argument at most once. - - Does not use all its arguments. - - Automatic inlining can be turned off using the flag `--no-auto-inline`. This - can be useful when debugging tactics that may be affected by whether or not - a particular definition is being inlined. - -### Syntax - -* Do-notation. - - There is now builtin do-notation syntax. This means that `do` is a reserved - keyword and cannot be used as an identifier. - - Do-blocks support lets and pattern matching binds. If the pattern in a bind - is non-exhaustive the other patterns need to be handled in a `where`-clause - (see example below). - - Example: - - ```agda - filter : {A : Set} → (A → Bool) → List A → List A - filter p xs = do - x ← xs - true ← return (p x) - where false → [] - return x - ``` - - Do-blocks desugar to `_>>=_` and `_>>_` before scope checking, so whatever - definitions of these two functions are in scope of the do-block will be used. - - More precisely: - - - Simple bind - - ```agda - do x ← m - m' - ``` - desugars to `m >>= λ x → m'`. - - - Pattern bind - - ```agda - do p ← m where pᵢ → mᵢ - m' - ``` - desugars to `m >>= λ { p → m'; pᵢ → mᵢ }`, where `pᵢ → mᵢ` is an arbitrary - sequence of clauses and follows the usual layout rules for `where`. If `p` - is exhaustive the `where` clause can be omitted. - - - Non-binding operation - - ```agda - do m - m' - ``` - desugars to `m >> m'`. - - - Let - - ```agda - do let ds - m - ``` - desugars to `let ds in m`, where `ds` is an arbitrary sequence of valid let-declarations. - - - The last statement in the do block must be a plain expression (no let or bind). - - Bind statements can use either `←` or `<-`. Neither of these are reserved, so - code outside do-blocks can use identifiers with these names, but inside a - do-block they would need to be used qualified or under different names. - -* Infix let declarations. [Issue [#917](https://github.com/agda/agda/issues/917)] - - Let declarations can now be defined in infix (or mixfix) style. For instance: - - ```agda - f : Nat → Nat - f n = let _!_ : Nat → Nat → Nat - x ! y = 2 * x + y - in n ! n - ``` - -* Overloaded pattern synonyms. [Issue [#2787](https://github.com/agda/agda/issues/2787)] - - Pattern synonyms can now be overloaded if all candidates have the same - *shape*. Two pattern synonym definitions have the same shape if they are - equal up to variable and constructor names. Shapes are checked at resolution - time. - - For instance, the following is accepted: - - ```agda - open import Agda.Builtin.Nat - - data List (A : Set) : Set where - lnil : List A - lcons : A → List A → List A - - data Vec (A : Set) : Nat → Set where - vnil : Vec A 0 - vcons : ∀ {n} → A → Vec A n → Vec A (suc n) - - pattern [] = lnil - pattern [] = vnil - - pattern _∷_ x xs = lcons x xs - pattern _∷_ y ys = vcons y ys - - lmap : ∀ {A B} → (A → B) → List A → List B - lmap f [] = [] - lmap f (x ∷ xs) = f x ∷ lmap f xs - - vmap : ∀ {A B n} → (A → B) → Vec A n → Vec B n - vmap f [] = [] - vmap f (x ∷ xs) = f x ∷ vmap f xs - ``` - -* If the file has no top-level module header, the first module - cannot have the same name as the file. - [Issues [#2808](https://github.com/agda/agda/issues/2808) - and [#1077](https://github.com/agda/agda/issues/1077)] - - This means that the following file `File.agda` is rejected: - ```agda - -- no module header - postulate A : Set - module File where -- inner module with the same name as the file - ``` - Agda reports `Illegal declarations(s) before top-level module` - at the `postulate`. - This is to avoid confusing scope errors in similar situations. - - If a top-level module header is inserted manually, the file is accepted: - - ```agda - module _ where -- user written module header - postulate A : Set - module File where -- inner module with the same name as the file, ok - ``` - -### Pattern matching - -* Forced constructor patterns. - - Constructor patterns can now be dotted to indicate that Agda should not case - split on them but rather their value is forced by the type of the other - patterns. The difference between this and a regular dot pattern is that - forced constructor patterns can still bind variables in their arguments. - For example, - - ```agda - open import Agda.Builtin.Nat - - data Vec (A : Set) : Nat → Set where - nil : Vec A zero - cons : (n : Nat) → A → Vec A n → Vec A (suc n) - - append : {A : Set} (m n : Nat) → Vec A m → Vec A n → Vec A (m + n) - append .zero n nil ys = ys - append (.suc m) n (cons .m x xs) ys = cons (m + n) x (append m n xs ys) - ``` - -* Inferring the type of a function based on its patterns - - Agda no longer infers the type of a function based on the patterns used in - its definition. [Issue [#2834](https://github.com/agda/agda/issues/2834)] - - This means that the following Agda program is no longer accepted: - ```agda - open import Agda.Builtin.Nat - - f : _ → _ - f zero = zero - f (suc n) = n - ``` - Agda now requires the type of the argument of `f` to be given explicitly. - -* Improved constraint solving for pattern matching functions - - Constraint solving for functions where each right-hand side has a distinct - rigid head has been extended to also cover the case where some clauses return - an argument of the function. A typical example is append on lists: - - ```agda - _++_ : {A : Set} → List A → List A → List A - [] ++ ys = ys - (x ∷ xs) ++ ys = x ∷ (xs ++ ys) - ``` - - Agda can now solve constraints like `?X ++ ys == 1 ∷ ys` when `ys` is a - neutral term. - -* Record expressions translated to copatterns - - Definitions of the form - - ```agda - f ps = record { f₁ = e₁; ..; fₙ = eₙ } - ``` - - are translated internally to use copatterns: - - ```agda - f ps .f₁ = e₁ - ... - f ps .fₙ = eₙ - ``` - - This means that `f ps` does not reduce, but thanks to η-equality the two - definitions are equivalent. - - The change should lead to fewer big record expressions showing up in goal - types, and potentially significant performance improvement in some cases. - - This may have a minor impact on with-abstraction and code using `--rewriting` - since η-equality is not used in these cases. - -* When using `with`, it is now allowed to replace any pattern from the parent - clause by a variable in the with clause. For example: - - ```agda - f : List ℕ → List ℕ - f [] = [] - f (x ∷ xs) with x ≤? 10 - f xs | p = {!!} - ``` - - In the with clause, `xs` is treated as a let-bound variable with value - `.x ∷ .xs` (where `.x : ℕ` and `.xs : List ℕ` are out of scope) and - `p : Dec (.x ≤ 10)`. - - Since with-abstraction may change the type of variables, instantiations - of variables in the with clause are type checked again after with-abstraction. - -### Builtins - -* Added support for built-in 64-bit machine words. - - These are defined in `Agda.Builtin.Word` and come with two primitive - operations to convert to and from natural numbers. - - ```agda - Word64 : Set - primWord64ToNat : Word64 → Nat - primWord64FromNat : Nat → Word64 - ``` - - Converting to a natural number is the trivial embedding, and converting from a natural number - gives you the remainder modulo 2^64. The proofs of these theorems are not - primitive, but can be defined in a library using `primTrustMe`. - - Basic arithmetic operations can be defined on `Word64` by converting to - natural numbers, peforming the corresponding operation, and then converting - back. The compiler will optimise these to use 64-bit arithmetic. For - instance, - - ```agda - addWord : Word64 → Word64 → Word64 - addWord a b = primWord64FromNat (primWord64ToNat a + primWord64ToNat b) - - subWord : Word64 → Word64 → Word64 - subWord a b = primWord64FromNat (primWord64ToNat a + 18446744073709551616 - primWord64ToNat b) - ``` - - These compiles (in the GHC backend) to addition and subtraction on - `Data.Word.Word64`. - -* New primitive primFloatLess and changed semantics of primFloatNumericalLess. - - `primFloatNumericalLess` now uses standard IEEE `<`, so for instance - `NaN < x = x < NaN = false`. - - On the other hand `primFloatLess` provides a total order on `Float`, with - `-Inf < NaN < -1.0 < -0.0 < 0.0 < 1.0 < Inf`. - -* The `SIZEINF` builtin is now given the name `∞` in - `Agda.Builtin.Size` [Issue - [#2931](https://github.com/agda/agda/issues/2931)]. - - Previously it was given the name `ω`. - -### Reflection - -* New TC primitive: `declarePostulate`. [Issue - [#2782](https://github.com/agda/agda/issues/2782)] - - ```agda - declarePostulate : Arg Name → Type → TC ⊤ - ``` - - This can be used to declare new postulates. The Visibility of the - Arg must not be hidden. This feature fails when executed with - `--safe` flag from command-line. - -Pragmas and options -------------------- - -* The `--caching` option is ON by default and is also a valid pragma. - Caching can (sometimes) speed up re-typechecking in `--interaction` - mode by reusing the result of the previous typechecking for the - prefix of the file that has not changed (with a granularity at the - level of declarations/mutual blocks). - - It can be turned off by passing ```--no-caching``` to ```agda``` or - with the following at the top of your file. - - ```agda - {-# OPTIONS --no-caching #-} - ``` - -* The `--sharing` and `--no-sharing` options have been deprecated and do - nothing. - - Compile-time evaluation is now always call-by-need. - -* BUILTIN pragmas can now appear before the top-level module header - and in parametrized modules. - [Issue [#2824](https://github.com/agda/agda/issues/2824)] - ```agda - {-# OPTIONS --rewriting #-} - open import Agda.Builtin.Equality - {-# BUILTIN REWRITE _≡_ #-} -- here - module TopLevel (A : Set) where - {-# BUILTIN REWRITE _≡_ #-} -- or here - ``` - Note that it is still the case that built-ins cannot be bound if - they depend on module parameters from an enclosing module. For - instance, the following is illegal: - ```agda - module _ {a} {A : Set a} where - data _≡_ (x : A) : A → Set a where - refl : x ≡ x - {-# BUILTIN EQUALITY _≡_ #-} - ``` - -* Builtin `NIL` and `CONS` have been merged with `LIST`. - - When binding the `LIST` builtin, `NIL` and `CONS` are bound to - the appropriate constructors automatically. This means that instead - of writing - - ```agda - {-# BUILTIN LIST List #-} - {-# BUILTIN NIL [] #-} - {-# BUILTIN CONS _∷_ #-} - ``` - - you just write - - ```agda - {-# BUILTIN LIST List #-} - ``` - - Attempting to bind `NIL` or `CONS` results in a warning and has otherwise no - effect. - -* The `--no-unicode` pragma prevents Agda from introducing unicode characters - when pretty printing a term. Lambda, Arrows and Forall quantifiers are all - replaced by their ascii only version. Instead of resorting to subscript - suffixes, Agda uses ascii digit characters. - -* New option `--inversion-max-depth=N`. - - The depth is used to avoid looping due to inverting pattern matching for - unsatisfiable constraints [Issue [#431](https://github.com/agda/agda/issues/431)]. - This option is only expected to be necessary in pathological cases. - -* New option `--no-print-pattern-synonyms`. - - This disables the use of pattern synonyms in output from Agda. - See [Issue [#2902](https://github.com/agda/agda/issues/2902)] for situations - where this might be desirable. - -* New fine-grained control over the warning machinery: ability to (en/dis)able - warnings on a one-by-one basis. - -* The command line option `--help` now takes an optional argument which - allows the user to request more specific usage information about particular - topics. The only one added so far is `warning`. - -* New pragma NOINLINE. - - ```agda - {-# NOINLINE f #-} - ``` - - Disables automatic inlining of `f`. - -* New pragma WARNING_ON_USAGE - - ``` - {-# WARNING_ON_USAGE QName Message #} - ``` - - Prints Message whenever QName is used. - -Emacs mode ----------- - -* Banana brackets have been added to the Agda input method. - ``` - \(( #x2985 LEFT WHITE PARENTHESIS - \)) #x2986 RIGHT WHITE PARENTHESIS - ``` - -* Result splitting will introduce the trailing hidden arguments, - if there is nothing else todo - [Issue [#2871](https://github.com/agda/agda/issues/2871)]. - Example: - ```agda - data Fun (A : Set) : Set where - mkFun : (A → A) → Fun A - - test : {A : Set} → Fun A - test = ? - - ``` - Splitting on the result here (`C-c C-c RET`) will append - `{A}` to the left hand side. - ```agda - test {A} = ? - ``` - -* Light highlighting is performed dynamically, even if the file is not - loaded [Issue [#2794](https://github.com/agda/agda/issues/2794)]. - - This light highlighting is based on the token stream generated by - Agda's lexer: the code is only highlighted if the file is lexically - correct. If the Agda backend is not busy with something else, then - the code is highlighted automatically in certain situations: - - * When the file is saved. - - * When Emacs has been idle, continuously, for a certain period of - time (by default 0.2 s) after the last modification of the file, - and the file has not been saved (or marked as being unmodified). - This functionality can be turned off, and the time period can be - customised. - -* Highlighting of comments is no longer handled by Font Lock mode - [Issue [#2794](https://github.com/agda/agda/issues/2794)]. - -* The Emacs mode's syntax table has been changed. - - Previously `_` was treated as punctuation. Now it is treated in the - same way as most other characters: if the standard syntax table - assigns it the syntax class "whitespace", "open parenthesis" or - "close parenthesis", then it gets that syntax class, and otherwise - it gets the syntax class "word constituent". - -Compiler backends ------------------ - -* The GHC backend now automatically compiles BUILTIN LIST to Haskell lists. - - This means that it's no longer necessary to give a COMPILE GHC pragma for the - builtin list type. Indeed, doing so has no effect on the compilation and - results in a warning. - -* The GHC backend performance improvements. - - Generated Haskell code now contains approximate type signatures, which lets - GHC get rid of many of the `unsafeCoerce`s. This leads to performance - improvements of up to 50% of compiled code. - -* The GHC backend now compiles the `INFINITY`, `SHARP` and `FLAT` - builtins in a different way [Issue - [#2909](https://github.com/agda/agda/issues/2909)]. - - Previously these were compiled to (basically) nothing. Now the - `INFINITY` builtin is compiled to `Infinity`, available from - `MAlonzo.RTE`: - - ```haskell - data Inf a = Sharp { flat :: a } - type Infinity level a = Inf a - ``` - - The `SHARP` builtin is compiled to `Sharp`, and the `FLAT` builtin - is (by default) compiled to a corresponding destructor. - - Note that code that interacts with Haskell libraries may have to be - updated. As an example, here is one way to print colists of - characters using the Haskell function `putStr`: - - ```agda - open import Agda.Builtin.Char - open import Agda.Builtin.Coinduction - open import Agda.Builtin.IO - open import Agda.Builtin.Unit - - data Colist {a} (A : Set a) : Set a where - [] : Colist A - _∷_ : A → ∞ (Colist A) → Colist A - - {-# FOREIGN GHC - data Colist a = Nil | Cons a (MAlonzo.RTE.Inf (Colist a)) - type Colist' l a = Colist a - - fromColist :: Colist a -> [a] - fromColist Nil = [] - fromColist (Cons x xs) = x : fromColist (MAlonzo.RTE.flat xs) - #-} - - {-# COMPILE GHC Colist = data Colist' (Nil | Cons) #-} - - postulate - putStr : Colist Char → IO ⊤ - - {-# COMPILE GHC putStr = putStr . fromColist #-} - ``` - -* `COMPILE GHC` pragmas have been included for the size primitives - [Issue [#2879](https://github.com/agda/agda/issues/2879)]. - -LaTeX backend -------------- - -* The `code` environment can now take arguments [Issues - [#2744](https://github.com/agda/agda/issues/2744) and - [#2453](https://github.com/agda/agda/issues/2453)]. - - Everything from \begin{code} to the end of the line is preserved in - the generated LaTeX code, and not treated as Agda code. - - The default implementation of the `code` environment recognises one - optional argument, `hide`, which can be used for code that should be - type-checked, but not typeset: - ```latex - \begin{code}[hide] - open import Module - \end{code} - ``` - - The `AgdaHide` macro has not been removed, but has been deprecated - in favour of `[hide]`. - -* The `AgdaSuppressSpace` and `AgdaMultiCode` environments no longer - take an argument. - - Instead some documents need to be compiled multiple times. - -* The `--count-clusters` flag can now be given in `OPTIONS` pragmas. - -* The `nofontsetup` option to the LaTeX package `agda` was broken, and - has (hopefully) been fixed - [Issue [#2773](https://github.com/agda/agda/issues/2773)]. - - Fewer packages than before are loaded when `nofontsetup` is used, - see `agda.sty` for details. Furthermore, if LuaLaTeX or XeLaTeX are - not used, then the font encoding is no longer changed. - -* The new option `noinputencodingsetup` instructs the LaTeX package - `agda` to not change the input encoding, and to not load the `ucs` - package. - -* Underscores are now typeset using `\AgdaUnderscore{}`. - - The default implementation is `\_` (the command that was previously - generated for underscores). Note that it is possible to override - this implementation. - -* OtherAspects (unsolved meta variables, catchall clauses, etc.) are - now correctly highlighted in the LaTeX backend (and the HTML one). - [Issue [#2474](https://github.com/agda/agda/issues/2474)] - -* `postprocess-latex.pl` does not add extra spaces around tagged `\Agda*{}` - commands anymore. - -HTML backend ------------- - -* An identifier (excluding bound variables), - gets the identifier itself as an anchor, - _in addition_ to the file position - [Issue [#2756](https://github.com/agda/agda/issues/2756)]. - In Agda 2.5.3, the identifier anchor would _replace_ the file position anchor - [Issue [#2604](https://github.com/agda/agda/issues/2604)]. - - Symbolic anchors look like - ```html - - - ``` - while file position anchors just give the character position in the file: - ```html - - ``` - - Top-level module names do not get a symbolic anchor, since the position of - a top-level module is defined to be the beginning of the file. - - Example: - - ```agda - module Issue2604 where -- Character position anchor - - test1 : Set₁ -- Issue2604.html#test1 - test1 = bla - where - bla = Set -- Only character position anchor - - test2 : Set₁ -- Issue2604.html#test2 - test2 = bla - where - bla = Set -- Only character position anchor - - test3 : Set₁ -- Issue2604.html#test3 - test3 = bla - module M where -- Issue2604.html#M - bla = Set -- Issue2604.html#M.bla - - module NamedModule where -- Issue2604.html#NamedModule - test4 : Set₁ -- Issue2604.html#NamedModule.test4 - test4 = M.bla - - module _ where -- Only character position anchor - test5 : Set₁ -- Only character position anchor - test5 = M.bla - ``` - -List of closed issues ---------------------- - -For 2.5.4, the following issues have been closed -(see [bug tracker](https://github.com/agda/agda/issues)): - - - [#351](https://github.com/agda/agda/issues/351): Constraint solving for irrelevant metas - - [#421](https://github.com/agda/agda/issues/421): Higher order positivity - - [#431](https://github.com/agda/agda/issues/431): Constructor-headed function makes type-checker diverge - - [#437](https://github.com/agda/agda/issues/437): Detect when something cannot be a function type - - [#488](https://github.com/agda/agda/issues/488): Refining on user defined syntax mixes up the order of the subgoals - - [#681](https://github.com/agda/agda/issues/681): Lack of visual state indicators in new Emacs mode - - [#689](https://github.com/agda/agda/issues/689): Contradictory constraints should yield error - - [#708](https://github.com/agda/agda/issues/708): Coverage checker not taking literal patterns into account properly - - [#875](https://github.com/agda/agda/issues/875): Nonstrict irrelevance violated by implicit inference - - [#964](https://github.com/agda/agda/issues/964): Allow unsolved metas in imported files - - [#987](https://github.com/agda/agda/issues/987): --html anchors could be more informative - - [#1054](https://github.com/agda/agda/issues/1054): Inlined Agda code in LaTeX backend - - [#1131](https://github.com/agda/agda/issues/1131): Infix definitions not allowed in let definitions - - [#1169](https://github.com/agda/agda/issues/1169): Auto fails with non-terminating function - - [#1268](https://github.com/agda/agda/issues/1268): Hard to print type of variable if the type starts with an instance argument - - [#1384](https://github.com/agda/agda/issues/1384): Order of constructor arguments matters for coverage checker - - [#1425](https://github.com/agda/agda/issues/1425): Instances with relevant recursive instance arguments are not considered in irrelevant positions - - [#1548](https://github.com/agda/agda/issues/1548): Confusing error about ambiguous definition with parametrized modules - - [#1884](https://github.com/agda/agda/issues/1884): what is the format of the libraries and defaults files - - [#1906](https://github.com/agda/agda/issues/1906): Possible performance problem - - [#2056](https://github.com/agda/agda/issues/2056): Cannot instantiate meta to solution...: Pattern checking done too early in where block - - [#2067](https://github.com/agda/agda/issues/2067): Display forms in parameterised module too general - - [#2183](https://github.com/agda/agda/issues/2183): Allow splitting on dotted variables - - [#2226](https://github.com/agda/agda/issues/2226): open {{...}} gets hiding wrong - - [#2255](https://github.com/agda/agda/issues/2255): Performance issue with deeply-nested lambdas - - [#2306](https://github.com/agda/agda/issues/2306): Commands in the emacs-mode get confused if we add question marks to the file - - [#2384](https://github.com/agda/agda/issues/2384): More fine-grained blocking in constraint solver - - [#2401](https://github.com/agda/agda/issues/2401): LaTeX backend error - - [#2404](https://github.com/agda/agda/issues/2404): checkType doesn't accept a type-checking definition checked with the same type - - [#2420](https://github.com/agda/agda/issues/2420): Failed to solve level constraints in record type with hole - - [#2421](https://github.com/agda/agda/issues/2421): After emacs starts up, Agda does not process file without restart of Agda - - [#2436](https://github.com/agda/agda/issues/2436): Agda allows coinductive records with eta-equality - - [#2450](https://github.com/agda/agda/issues/2450): Irrelevant variables are pruned too eagerly - - [#2474](https://github.com/agda/agda/issues/2474): The LaTeX and HTML backends do not highlight (all) unsolved metas - - [#2484](https://github.com/agda/agda/issues/2484): Regression related to sized types - - [#2526](https://github.com/agda/agda/issues/2526): Better documentation of record modules - - [#2536](https://github.com/agda/agda/issues/2536): UTF8 parsed incorrectly for literate agda files - - [#2565](https://github.com/agda/agda/issues/2565): Options for the interaction action give to keep the overloaded literals and sections? - - [#2576](https://github.com/agda/agda/issues/2576): Shadowing data decl by data sig produces Missing type signature error - - [#2594](https://github.com/agda/agda/issues/2594): Valid partial cover rejected: "Cannot split on argument of non-datatype" - - [#2600](https://github.com/agda/agda/issues/2600): Stack complains about Agda.cabal - - [#2607](https://github.com/agda/agda/issues/2607): Instance search confused when an instance argument is sourced from a record - - [#2617](https://github.com/agda/agda/issues/2617): Installation instructions - - [#2623](https://github.com/agda/agda/issues/2623): Incorrect indentation when \AgdaHide is used - - [#2634](https://github.com/agda/agda/issues/2634): Fixity declaration ignored in definitions in record - - [#2636](https://github.com/agda/agda/issues/2636): The positivity checker complains when a new definition is added in the same where clause - - [#2640](https://github.com/agda/agda/issues/2640): Unifier dots the relevant pattern variables when it should dot the irrelevant ones - - [#2668](https://github.com/agda/agda/issues/2668): Changing the visibility of a module parameter breaks `with` - - [#2728](https://github.com/agda/agda/issues/2728): Bad interaction between caching and the warning machinery - - [#2738](https://github.com/agda/agda/issues/2738): Update Stackage LTS from 9.1 to version supporting Alex 3.2.3 - - [#2744](https://github.com/agda/agda/issues/2744): It should be possible to give arguments to the code environment - - [#2745](https://github.com/agda/agda/issues/2745): Broken build with GHC 7.8.4 due to (new) version 1.2.2.0 of hashtables - - [#2749](https://github.com/agda/agda/issues/2749): Add --no-unicode cli option to Agda - - [#2751](https://github.com/agda/agda/issues/2751): Unsolved constraints, but no highlighting - - [#2752](https://github.com/agda/agda/issues/2752): Mutual blocks inside instance blocks - - [#2753](https://github.com/agda/agda/issues/2753): Unsolved constraint, related to instance arguments and sized types - - [#2756](https://github.com/agda/agda/issues/2756): HTML backend generates broken links - - [#2758](https://github.com/agda/agda/issues/2758): Relevant meta is instantiated with irrelevant solution - - [#2759](https://github.com/agda/agda/issues/2759): Empty mutual blocks should be warning rather than error - - [#2762](https://github.com/agda/agda/issues/2762): Automatically generate DISPLAY pragmas to fold pattern synonyms - - [#2763](https://github.com/agda/agda/issues/2763): Internal Error at "src/full/Agda/TypeChecking/Abstract.hs:138" - - [#2765](https://github.com/agda/agda/issues/2765): Inferred level expressions are often "reversed" - - [#2769](https://github.com/agda/agda/issues/2769): Agda prints ill-formed expression, record argument dropped - - [#2771](https://github.com/agda/agda/issues/2771): Erroneous 'with' error message - - [#2773](https://github.com/agda/agda/issues/2773): The nofontsetup option does not work as advertised - - [#2775](https://github.com/agda/agda/issues/2775): Irrelevance to be taken into account in 'with' abstraction. - - [#2776](https://github.com/agda/agda/issues/2776): Dotted variable in inferred type - - [#2780](https://github.com/agda/agda/issues/2780): Improve level constraint solving for groups of inequality constraints - - [#2782](https://github.com/agda/agda/issues/2782): Extending Agda reflection to introduce postulates - - [#2785](https://github.com/agda/agda/issues/2785): internal error @ ConcreteToAbstract.hs:721 - - [#2787](https://github.com/agda/agda/issues/2787): Overloaded pattern synonyms - - [#2792](https://github.com/agda/agda/issues/2792): Safe modules can sometimes not be imported from unsafe modules - - [#2794](https://github.com/agda/agda/issues/2794): Using \texttt{-} destroys code coloring in literate file - - [#2796](https://github.com/agda/agda/issues/2796): Overloaded (inherited) projection resolution fails with parametrized record - - [#2798](https://github.com/agda/agda/issues/2798): The LaTeX backend ignores the "operator" aspect - - [#2802](https://github.com/agda/agda/issues/2802): Printing of overloaded functions broken due to eager normalization of projections - - [#2803](https://github.com/agda/agda/issues/2803): Case splitting loses names of hidden arguments - - [#2808](https://github.com/agda/agda/issues/2808): Confusing error when inserting declaration before top-level module - - [#2810](https://github.com/agda/agda/issues/2810): Make `--caching` a pragma option - - [#2811](https://github.com/agda/agda/issues/2811): OPTION --caching allowed in file (Issue #2810) - - [#2819](https://github.com/agda/agda/issues/2819): Forcing analysis doesn't consider relevance - - [#2821](https://github.com/agda/agda/issues/2821): BUILTIN BOOL gremlin - - [#2824](https://github.com/agda/agda/issues/2824): Allow {-# BUILTIN #-} in preamble and in parametrized modules - - [#2826](https://github.com/agda/agda/issues/2826): Case splitting on earlier variable uses duplicate variable name - - [#2827](https://github.com/agda/agda/issues/2827): Variables off in with-clauses. Parameter refinement? - - [#2831](https://github.com/agda/agda/issues/2831): NO_POSITIVITY_CHECK pragma can be written before a mutual block without data or record types - - [#2832](https://github.com/agda/agda/issues/2832): BUILTIN NIL and CONS are not needed - - [#2834](https://github.com/agda/agda/issues/2834): Disambiguation of type based on pattern leads to non-unique meta solution - - [#2836](https://github.com/agda/agda/issues/2836): The Emacs mode does not handle .lagda.tex files - - [#2840](https://github.com/agda/agda/issues/2840): Internal error in positivity with modules/datatype definitions - - [#2841](https://github.com/agda/agda/issues/2841): Opting out of idiom brackets - - [#2844](https://github.com/agda/agda/issues/2844): Root documentation URL redirects to version 2.5.2 - - [#2849](https://github.com/agda/agda/issues/2849): Internal error at absurd pattern followed by `rewrite` - - [#2854](https://github.com/agda/agda/issues/2854): Agda worries about possibly empty type of sizes even when no builtins for size are active - - [#2855](https://github.com/agda/agda/issues/2855): Single-clause definition is both unreachable and incomplete - - [#2856](https://github.com/agda/agda/issues/2856): Panic: unbound variable - - [#2859](https://github.com/agda/agda/issues/2859): Error "pattern variable shadows constructor" caused by parameter refinement - - [#2862](https://github.com/agda/agda/issues/2862): inconsistency from a mutual datatype declaration and module definition - - [#2867](https://github.com/agda/agda/issues/2867): Give does not insert parenthesis for module parameters - - [#2868](https://github.com/agda/agda/issues/2868): With --postfix-projections, record fields are printed preceded by a dot when working within the record - - [#2870](https://github.com/agda/agda/issues/2870): Lexical error for \- (hyphen) - - [#2871](https://github.com/agda/agda/issues/2871): Introduce just trailing hidden arguments by result splitting - - [#2873](https://github.com/agda/agda/issues/2873): Refinement problem in presence of overloaded constructors - - [#2874](https://github.com/agda/agda/issues/2874): Internal error in src/full/Agda/TypeChecking/Coverage/Match.hs:312 - - [#2878](https://github.com/agda/agda/issues/2878): Support for GHC 8.4.1 - - [#2879](https://github.com/agda/agda/issues/2879): Include COMPILE GHC pragmas for size primitives - - [#2881](https://github.com/agda/agda/issues/2881): Internal error in BasicOps - - [#2883](https://github.com/agda/agda/issues/2883): "internal error in TypeChecking/Substitute.hs:379" - - [#2884](https://github.com/agda/agda/issues/2884): Missing PDF user manual in the tarball - - [#2888](https://github.com/agda/agda/issues/2888): Internal error caused by new forcing translation - - [#2894](https://github.com/agda/agda/issues/2894): Unifier tries to eta expand non-eta record - - [#2896](https://github.com/agda/agda/issues/2896): Unifier throws away pattern - - [#2897](https://github.com/agda/agda/issues/2897): Internal error for local modules with refined parameters - - [#2904](https://github.com/agda/agda/issues/2904): No tab completion for GHCNoMain - - [#2906](https://github.com/agda/agda/issues/2906): Confusing "cannot be translated to a Haskell type" error message - - [#2908](https://github.com/agda/agda/issues/2908): primForce is compiled away - - [#2909](https://github.com/agda/agda/issues/2909): Agda uses newtypes incorrectly, causing wellformed programs to loop - - [#2911](https://github.com/agda/agda/issues/2911): Inferring missing instance clause panics in refined context - - [#2912](https://github.com/agda/agda/issues/2912): Add fine-grained control over the displayed warnings - - [#2914](https://github.com/agda/agda/issues/2914): Slicing ignores as pragma? - - [#2916](https://github.com/agda/agda/issues/2916): The GHC backend generates code with an incorrect number of constructor arguments - - [#2917](https://github.com/agda/agda/issues/2917): Very slow due to unsolved size? - - [#2919](https://github.com/agda/agda/issues/2919): Internal error in Agda.TypeChecking.Forcing - - [#2921](https://github.com/agda/agda/issues/2921): COMPILE data for data types with erased constructor arguments - - [#2923](https://github.com/agda/agda/issues/2923): Word.agda not included as builtin - - [#2925](https://github.com/agda/agda/issues/2925): Allow adding the same rewrite rules multiple times - - [#2927](https://github.com/agda/agda/issues/2927): Panic related to sized types - - [#2928](https://github.com/agda/agda/issues/2928): Internal error in Agda.TypeChecking.Rules.LHS - - [#2931](https://github.com/agda/agda/issues/2931): Rename Agda.Builtin.Size.ω to ∞? - - [#2941](https://github.com/agda/agda/issues/2941): "coinductive" record inconsistent - - [#2944](https://github.com/agda/agda/issues/2944): Regression, seemingly related to record expressions - - [#2945](https://github.com/agda/agda/issues/2945): Inversion warning in code that used to be accepted - - [#2947](https://github.com/agda/agda/issues/2947): Internal error in Agda.TypeChecking.Forcing - - [#2952](https://github.com/agda/agda/issues/2952): Wrong compilation of pattern matching to Haskell - - [#2953](https://github.com/agda/agda/issues/2953): Generated Haskell code does not typecheck - - [#2954](https://github.com/agda/agda/issues/2954): Pattern matching on string gives unexpected unreachable clause - - [#2957](https://github.com/agda/agda/issues/2957): Support for async 2.2.1 - - [#2958](https://github.com/agda/agda/issues/2958): `as` names being duplicated in buffer after `with` - - [#2959](https://github.com/agda/agda/issues/2959): Repeating a successful command after revert + reload fails with caching enabled - - [#2960](https://github.com/agda/agda/issues/2960): Uncommenting indented lines doesn't work - - [#2963](https://github.com/agda/agda/issues/2963): Extended lambdas bypass positivity checking in records - - [#2966](https://github.com/agda/agda/issues/2966): Internal error in Auto - - [#2968](https://github.com/agda/agda/issues/2968): Bad Interaction with copatterns and eta?, leads to ill-typed terms in error messages. - - [#2971](https://github.com/agda/agda/issues/2971): Copattern split with `--no-irrelevant-projections` panics - - [#2974](https://github.com/agda/agda/issues/2974): Copatterns break canonicity - - [#2975](https://github.com/agda/agda/issues/2975): Termination checker runs too early for definitions inside record (or: positivity checker runs too late) - - [#2976](https://github.com/agda/agda/issues/2976): Emacs mode reports errors in connection with highlighting comments - - [#2978](https://github.com/agda/agda/issues/2978): Double solving of meta - - [#2985](https://github.com/agda/agda/issues/2985): The termination checker accepts non-terminating code - - [#2989](https://github.com/agda/agda/issues/2989): Internal error when checking record match in let expr - - [#2990](https://github.com/agda/agda/issues/2990): Performance regression related to the abstract machine - - [#2994](https://github.com/agda/agda/issues/2994): Solution accepted in hole is subsequently rejected on reload - - [#2996](https://github.com/agda/agda/issues/2996): Internal error with -v tc.cover:20 - - [#2997](https://github.com/agda/agda/issues/2997): Internal error in Agda.TypeChecking.Rules.LHS - - [#2998](https://github.com/agda/agda/issues/2998): Regression: With clause pattern x is not an instance of its parent pattern "eta expansion of x" - - [#3002](https://github.com/agda/agda/issues/3002): Spurious 1 after simplification - - [#3004](https://github.com/agda/agda/issues/3004): Agda hangs on extended lambda - - [#3007](https://github.com/agda/agda/issues/3007): Internal error in Parser - - [#3012](https://github.com/agda/agda/issues/3012): Internal Error at : "src/full/Agda/TypeChecking/Reduce/Fast.hs:1030" - - [#3014](https://github.com/agda/agda/issues/3014): Internal error in Rules.LHS - - [#3020](https://github.com/agda/agda/issues/3020): Missing highlighting in record modules - - [#3023](https://github.com/agda/agda/issues/3023): Support for GHC 8.4.2 - - [#3024](https://github.com/agda/agda/issues/3024): Postfix projection patterns not highlighted correctly with agda --latex - - [#3030](https://github.com/agda/agda/issues/3030): [ warning ] user defined warnings - - [#3031](https://github.com/agda/agda/issues/3031): Eta failure for record meta with irrelevant fields - - [#3033](https://github.com/agda/agda/issues/3033): Giving and solving don't insert parenthesis for applications in dot pattern - - [#3044](https://github.com/agda/agda/issues/3044): Internal error in src/full/Agda/TypeChecking/Substitute/Class.hs:209 - - [#3045](https://github.com/agda/agda/issues/3045): GHC backend generates type without enough arguments - - [#3046](https://github.com/agda/agda/issues/3046): do-notation causes parse errors in subsequent where clauses - - [#3049](https://github.com/agda/agda/issues/3049): Positivity unsoundness - - [#3050](https://github.com/agda/agda/issues/3050): We revert back to call-by-name during positivity checking - - [#3051](https://github.com/agda/agda/issues/3051): Pattern synonyms should be allowed in mutual blocks - - [#3052](https://github.com/agda/agda/issues/3052): Another recent inference change - - [#3062](https://github.com/agda/agda/issues/3062): Literal match does not respect first-match semantics - - [#3063](https://github.com/agda/agda/issues/3063): Internal error in Agda.TypeChecking.Forcing - - [#3064](https://github.com/agda/agda/issues/3064): Coverage checker bogus on literals combined with copatterns - - [#3065](https://github.com/agda/agda/issues/3065): Internal error in coverage checker triggered by literal dot pattern - - [#3067](https://github.com/agda/agda/issues/3067): checking hangs on invalid program - - [#3072](https://github.com/agda/agda/issues/3072): invalid section printing - - [#3074](https://github.com/agda/agda/issues/3074): Wrong hiding causes internal error in LHS checker - - [#3075](https://github.com/agda/agda/issues/3075): Automatic inlining and tactics - - [#3078](https://github.com/agda/agda/issues/3078): Error building with GHC 7.10.2: Missing transformers library - - [#3079](https://github.com/agda/agda/issues/3079): Wrong parameter hiding for instance open - - [#3080](https://github.com/agda/agda/issues/3080): Case splitting prints out-of-scope pattern synonyms - - [#3082](https://github.com/agda/agda/issues/3082): Emacs mode regression: a ? inserted before existing hole hijacks its interaction point - - [#3083](https://github.com/agda/agda/issues/3083): Wrong hiding in module application - - [#3084](https://github.com/agda/agda/issues/3084): Changes to mode line do not take effect immediately - - [#3085](https://github.com/agda/agda/issues/3085): Postpone checking a pattern let binding when type is blocked - - [#3090](https://github.com/agda/agda/issues/3090): Internal error in parser when using parentheses in BUILTIN pragma - - [#3096](https://github.com/agda/agda/issues/3096): Support GHC 8.4.3 - -Release notes for Agda version 2.5.3 -==================================== - -Installation and infrastructure -------------------------------- - -* Added support for GHC 8.0.2 and 8.2.1. - -* Removed support for GHC 7.6.3. - -* Markdown support for literate Agda - \[PR [#2357](https://github.com/agda/agda/pull/2357)]. - - Files ending in `.lagda.md` will be parsed as literate Markdown files. - - + Code blocks start with ```` ``` ```` or ```` ```agda ```` in its own line, and end with - ```` ``` ````, also in its own line. - + Code blocks which should be type-checked by Agda but should not be visible - when the Markdown is rendered may be enclosed in HTML comment delimiters - (``). - + Code blocks which should be ignored by Agda, but rendered in the final - document may be indented by four spaces. - + Note that inline code fragments are not supported due to the difficulty of - interpreting their indentation level with respect to the rest of the file. - -Language --------- - -### Pattern matching - -* Dot patterns. - - The dot in front of an inaccessible pattern can now be skipped if the - pattern consists entirely of constructors or literals. For example: - ```agda - open import Agda.Builtin.Bool - - data D : Bool → Set where - c : D true - - f : (x : Bool) → D x → Bool - f true c = true - - ``` - Before this change, you had to write `f .true c = true`. - -* With-clause patterns can be replaced by _ - [Issue [#2363](https://github.com/agda/agda/issues/2363)]. - Example: - ```agda - test : Nat → Set - test zero with zero - test _ | _ = Nat - test (suc x) with zero - test _ | _ = Nat - ``` - We do not have to spell out the pattern of the parent clause - (`zero` / `suc x`) in the with-clause if we do not need the - pattern variables. Note that `x` is not in scope in the - with-clause! - - A more elaborate example, which cannot be reduced to - an ellipsis `...`: - ```agda - record R : Set where - coinductive -- disallow matching - field f : Bool - n : Nat - - data P (r : R) : Nat → Set where - fTrue : R.f r ≡ true → P r zero - nSuc : P r (suc (R.n r)) - - data Q : (b : Bool) (n : Nat) → Set where - true! : Q true zero - suc! : ∀{b n} → Q b (suc n) - - test : (r : R) {n : Nat} (p : P r n) → Q (R.f r) n - test r nSuc = suc! - test r (fTrue p) with R.f r - test _ (fTrue ()) | false - test _ _ | true = true! -- underscore instead of (isTrue _) - ``` - -* Pattern matching lambdas (also known as extended lambdas) can now be - nullary, mirroring the behaviour for ordinary function definitions. - [Issue [#2671](https://github.com/agda/agda/issues/2671)] - - This is useful for case splitting on the result inside an - expression: given - ```agda - record _×_ (A B : Set) : Set where - field - π₁ : A - π₂ : B - open _×_ - ``` - one may case split on the result (C-c C-c RET) in a hole - ```agda - λ { → {!!}} - ``` - of type A × B to produce - ```agda - λ { .π₁ → {!!} ; .π₂ → {!!}} - ``` - -* Records with a field of an empty type are now recognized as empty by Agda. - In particular, they can be matched against with an absurd pattern (). - For example: - ```agda - data ⊥ : Set where - - record Empty : Set where - field absurdity : ⊥ - - magic : Empty → ⊥ - magic () - ``` - -* Injective pragmas. - - Injective pragmas can be used to mark a definition as injective for the - pattern matching unifier. This can be used as a version of - `--injective-type-constructors` that only applies to specific datatypes. - For example: - ```agda - open import Agda.Builtin.Equality - data Fin : Nat → Set where - zero : {n : Nat} → Fin (suc n) - suc : {n : Nat} → Fin n → Fin (suc n) - - {-# INJECTIVE Fin #-} - - Fin-injective : {m n : Nat} → Fin m ≡ Fin n → m ≡ n - Fin-injective refl = refl - ``` - Aside from datatypes, this pragma can also be used to mark other definitions - as being injective (for example postulates). - -* Metavariables can no longer be instantiated during case splitting. This means - Agda will refuse to split instead of taking the first constructor it finds. - For example: - ```agda - open import Agda.Builtin.Nat - - data Vec (A : Set) : Nat → Set where - nil : Vec A 0 - cons : {n : Nat} → A → Vec A n → Vec A (suc n) - - foo : Vec Nat _ → Nat - foo x = {!x!} - ``` - In Agda 2.5.2, case splitting on `x` produced the single clause - `foo nil = {!!}`, but now Agda refuses to split. - -### Reflection - -* New TC primitive: `debugPrint`. - - ```agda - debugPrint : String → Nat → List ErrorPart → TC ⊤ - ``` - - This maps to the internal function `reportSDoc`. Debug output is enabled with - the `-v` flag at the command line, or in an `OPTIONS` pragma. For instance, - giving `-v a.b.c:10` enables printing from `debugPrint "a.b.c.d" 10 msg`. In the - Emacs mode, debug output ends up in the `*Agda debug*` buffer. - -### Built-ins - -* BUILTIN REFL is now superfluous, subsumed by BUILTIN EQUALITY - [Issue [#2389](https://github.com/agda/agda/issues/2389)]. - -* BUILTIN EQUALITY is now more liberal - [Issue [#2386](https://github.com/agda/agda/issues/2386)]. - It accepts, among others, the following new definitions of equality: - ```agda - -- Non-universe polymorphic: - data _≡_ {A : Set} (x : A) : A → Set where - refl : x ≡ x - - -- ... with explicit argument to refl; - data _≡_ {A : Set} : (x y : A) → Set where - refl : {x : A} → x ≡ x - - -- ... even visible - data _≡_ {A : Set} : (x y : A) → Set where - refl : (x : A) → x ≡ x - - -- Equality in a different universe than domain: - -- (also with explicit argument to refl) - data _≡_ {a} {A : Set a} (x : A) : A → Set where - refl : x ≡ x - - ``` - The standard definition is still: - ```agda - -- Equality in same universe as domain: - data _≡_ {a} {A : Set a} (x : A) : A → Set a where - refl : x ≡ x - ``` - -### Miscellaneous - -* Rule change for omitted top-level module headers. - [Issue [#1077](https://github.com/agda/agda/issues/1077)] - - If your file is named `Bla.agda`, then the following content - is rejected. - ```agda - foo = Set - module Bla where - bar = Set - ``` - Before the fix of this issue, Agda would add the missing module - header `module Bla where` at the top of the file. - However, in this particular case it is more likely the user - put the declaration `foo = Set` before the module start in error. - Now you get the error - ``` - Illegal declaration(s) before top-level module - ``` - if the following conditions are met: - - 1. There is at least one non-import declaration or non-toplevel pragma - before the start of the first module. - - 2. The module has the same name as the file. - - 3. The module is the only module at this level - (may have submodules, of course). - - If you should see this error, insert a top-level module - before the illegal declarations, or move them inside the - existing module. - -Emacs mode ----------- - -* New warnings: - - - Unreachable clauses give rise to a simple warning. They are - highlighted in gray. - - - Incomplete patterns are non-fatal warnings: it is possible - to keep interacting with the file (the reduction will simply - be stuck on arguments not matching any pattern). - The definition with incomplete patterns are highlighted in - wheat. - -* Clauses which do not hold definitionally are now highlighted in white smoke. - -* Fewer commands have the side effect that the buffer is saved. - -* Aborting commands. - - Now one can (try to) abort an Agda command by using `C-c C-x C-a` or - a menu entry. The effect is similar to that of restarting Agda (`C-c - C-x C-r`), but some state is preserved, which could mean that it - takes less time to reload the module. - - Warning: If a command is aborted while it is writing data to disk - (for instance .agdai files or Haskell files generated by the GHC - backend), then the resulting files may be corrupted. Note also that - external commands (like GHC) are not aborted, and their output may - continue to be sent to the Emacs mode. - -* New bindings for the Agda input method: - - - All the bold digits are now available. The naming scheme is `\Bx` for digit `x`. - - - Typing `\:` you can now get a whole slew of colons. - - (The Agda input method originally only bound the standard unicode colon, - which looks deceptively like the normal colon.) - -* Case splitting now preserves underscores. - [Issue [#819](https://github.com/agda/agda/issues/819)] - ```agda - data ⊥ : Set where - - test : {A B : Set} → A → ⊥ → B - test _ x = {! x !} - ``` - Splitting on `x` yields - ```agda - test _ () - ``` - -* Interactively expanding ellipsis. - [Issue [#2589](https://github.com/agda/agda/issues/2589)] - An ellipsis in a with-clause can be expanded by splitting on "variable" "." (dot). - ```agda - test0 : Nat → Nat - test0 x with zero - ... | q = {! . !} -- C-c C-c - ``` - Splitting on dot here yields: - ```agda - test0 x | q = ? - ``` - -* New command to check an expression against the type of the hole - it is in and see what it elaborates to. - [Issue [#2700](https://github.com/agda/agda/issues/2700)] - This is useful to determine e.g. what solution typeclass resolution yields. - The command is bound to `C-c C-;` and respects the `C-u` modifier. - - ```agda - record Pointed (A : Set) : Set where - field point : A - - it : ∀ {A : Set} {{x : A}} → A - it {{x}} = x - - instance _ = record { point = 3 - 4 } - - _ : Pointed Nat - _ = {! it !} -- C-u C-u C-c C-; - ``` - yields - ```agda - Goal: Pointed Nat - Elaborates to: record { point = 0 } - ``` - -* If `agda2-give` is called with a prefix, then giving is forced, - i.e., the safety checks are skipped, - including positivity, termination, and double type-checking. - [Issue [#2730](https://github.com/agda/agda/issues/2730)] - - Invoke forced giving with key sequence `C-u C-c C-SPC`. - - -Library management ------------------- - -* The `name` field in an `.agda-lib` file is now optional. - [Issue [#2708](https://github.com/agda/agda/issues/2708)] - - This feature is convenient if you just want to specify the dependencies - and include pathes for your local project in an `.agda-lib` file. - - Naturally, libraries without names cannot be depended on. - - -Compiler backends ------------------ - -* Unified compiler pragmas - - The compiler pragmas (`COMPILED`, `COMPILED_DATA`, etc.) have been unified across - backends into two new pragmas: - - ``` - {-# COMPILE #-} - {-# FOREIGN #-} - ``` - - The old pragmas still work, but will emit a warning if used. They will be - removed completely in Agda 2.6. - - The translation of old pragmas into new ones is as follows: - - Old | New - --- | --- - `{-# COMPILED f e #-}` | `{-# COMPILE GHC f = e #-}` - `{-# COMPILED_TYPE A T #-}` | `{-# COMPILE GHC A = type T #-}` - `{-# COMPILED_DATA A D C1 .. CN #-}` | `{-# COMPILE GHC A = data D (C1 \| .. \| CN) #-}` - `{-# COMPILED_DECLARE_DATA #-}` | obsolete, removed - `{-# COMPILED_EXPORT f g #-}` | `{-# COMPILE GHC f as g #-}` - `{-# IMPORT M #-}` | `{-# FOREIGN GHC import qualified M #-}` - `{-# HASKELL code #-}` | `{-# FOREIGN GHC code #-}` - `{-# COMPILED_UHC f e #-}` | `{-# COMPILE UHC f = e #-}` - `{-# COMPILED_DATA_UHC A D C1 .. CN #-}` | `{-# COMPILE UHC A = data D (C1 \| .. \| CN) #-}` - `{-# IMPORT_UHC M #-}` | `{-# FOREIGN UHC __IMPORT__ M #-}` - `{-# COMPILED_JS f e #-}` | `{-# COMPILE JS f = e #-}` - -* GHC Haskell backend - - The COMPILED pragma (and the corresponding COMPILE GHC pragma) is now also - allowed for functions. This makes it possible to have both an Agda - implementation and a native Haskell runtime implementation. - - The GHC file header pragmas `LANGUAGE`, `OPTIONS_GHC`, and `INCLUDE` - inside a `FOREIGN GHC` pragma are recognized and printed correctly - at the top of the generated Haskell file. - [Issue [#2712](https://github.com/agda/agda/issues/2712)] - - -* UHC compiler backend - - The UHC backend has been moved to its own repository - [https://github.com/agda/agda-uhc] and is no longer part of the Agda - distribution. - -* Haskell imports are no longer transitively inherited from imported modules. - - The (now deprecated) IMPORT and IMPORT_UHC pragmas no longer cause import - statements in modules importing the module containing the pragma. - - The same is true for the corresponding FOREIGN pragmas. - -* Support for stand-alone backends. - - There is a new API in `Agda.Compiler.Backend` for creating stand-alone - backends using Agda as a library. This allows prospective backend writers to - experiment with new backends without having to change the Agda code base. - -HTML backend ------------- - -* Anchors for identifiers (excluding bound variables) are now the - identifiers themselves rather than just the file position - [Issue [#2604](https://github.com/agda/agda/issues/2604)]. - - Symbolic anchors look like - ```html - - - ``` - while other anchors just give the character position in the file: - ```html - - ``` - - Top-level module names do not get a symbolic anchor, since the position of - a top-level module is defined to be the beginning of the file. - - Example: - - ```agda - module Issue2604 where -- Character position anchor - - test1 : Set₁ -- Issue2604.html#test1 - test1 = bla - where - bla = Set -- Character position anchor - - test2 : Set₁ -- Issue2604.html#test2 - test2 = bla - where - bla = Set -- Character position anchor - - test3 : Set₁ -- Issue2604.html#test3 - test3 = bla - module M where -- Issue2604.html#M - bla = Set -- Issue2604.html#M.bla - - module NamedModule where -- Issue2604.html#NamedModule - test4 : Set₁ -- Issue2604.html#NamedModule.test4 - test4 = M.bla - - module _ where -- Character position anchor - test5 : Set₁ -- Character position anchor - test5 = M.bla - ``` - -* Some generated HTML files now have different file names [Issue - [#2725](https://github.com/agda/agda/issues/2725)]. - - Agda now uses an encoding that amounts to first converting the - module names to UTF-8, and then percent-encoding the resulting - bytes. For instance, HTML for the module `Σ` is placed in - `%CE%A3.html`. - -LaTeX backend -------------- - -* The LaTeX backend now handles indentation in a different way [Issue - [#1832](https://github.com/agda/agda/issues/1832)]. - - A constraint on the indentation of the first token *t* on a line is - determined as follows: - * Let *T* be the set containing every previous token (in any code - block) that is either the initial token on its line or preceded by - at least one whitespace character. - * Let *S* be the set containing all tokens in *T* that are not - *shadowed* by other tokens in *T*. A token *t₁* is shadowed by - *t₂* if *t₂* is further down than *t₁* and does not start to the - right of *t₁*. - * Let *L* be the set containing all tokens in *S* that start to the - left of *t*, and *E* be the set containing all tokens in *S* that - start in the same column as *t*. - * The constraint is that *t* must be indented further than every - token in *L*, and aligned with every token in *E*. - - Note that if any token in *L* or *E* belongs to a previous code - block, then the constraint may not be satisfied unless (say) the - `AgdaAlign` environment is used in an appropriate way. - - If custom settings are used, for instance if `\AgdaIndent` is - redefined, then the constraint discussed above may not be satisfied. - (Note that the meaning of the `\AgdaIndent` command's argument has - changed, and that the command is now used in a different way in the - generated LaTeX files.) - - Examples: - * Here `C` is indented further than `B`: - - ```agda - postulate - A B - C : Set - ``` - - * Here `C` is not (necessarily) indented further than `B`, because - `X` shadows `B`: - - ```agda - postulate - A B : Set - X - C : Set - ``` - - The new rule is inspired by, but not identical to, the one used by - lhs2TeX's poly mode (see Section 8.4 of the [manual for lhs2TeX - version 1.17](https://www.andres-loeh.de/lhs2tex/Guide2-1.17.pdf)). - -* Some spacing issues - [[#2353](https://github.com/agda/agda/issues/2353), - [#2441](https://github.com/agda/agda/issues/2441), - [#2733](https://github.com/agda/agda/issues/2733), - [#2740](https://github.com/agda/agda/issues/2740)] have been fixed. - -* The user can now control the typesetting of (certain) individual tokens - by redefining the `\AgdaFormat` command. Example: - ```latex - \usepackage{ifthen} - - % Insert extra space before some tokens. - \DeclareRobustCommand{\AgdaFormat}[2]{% - \ifthenelse{ - \equal{#1}{≡⟨} \OR - \equal{#1}{≡⟨⟩} \OR - \equal{#1}{∎} - }{\ }{}#2} - ``` - Note the use of `\DeclareRobustCommand`. The first argument to - `\AgdaFormat` is the token, and the second argument the thing to - be typeset. - -* One can now instruct the agda package not to select any fonts. - - If the `nofontsetup` option is used, then some font packages are - loaded, but specific fonts are not selected: - ```latex - \usepackage[nofontsetup]{agda} - ``` - -* The height of empty lines is now configurable - [[#2734](https://github.com/agda/agda/issues/2734)]. - - The height is controlled by the length `\AgdaEmptySkip`, which by - default is `\baselineskip`. - -* The alignment feature regards the string `+̲`, containing `+` and a - combining character, as having length two. However, it seems more - reasonable to treat it as having length one, as it occupies a single - column, if displayed "properly" using a monospace font. The new flag - `--count-clusters` is an attempt at fixing this. When this flag is - enabled the backend counts ["extended grapheme - clusters"](http://www.unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries) - rather than code points. - - Note that this fix is not perfect: a single extended grapheme - cluster might be displayed in different ways by different programs, - and might, in some cases, occupy more than one column. Here are some - examples of extended grapheme clusters, all of which are treated as - a single character by the alignment algorithm: - ``` - │ │ - │+̲│ - │Ö̂│ - │நி│ - │ᄀힰᇹ│ - │ᄀᄀᄀᄀᄀᄀힰᇹᇹᇹᇹᇹᇹ│ - │ │ - ``` - - Note also that the layout machinery does not count extended grapheme - clusters, but code points. The following code is syntactically - correct, but if `--count-clusters` is used, then the LaTeX backend - does not align the two `field` keywords: - ```agda - record +̲ : Set₁ where field A : Set - field B : Set - ``` - - The `--count-clusters` flag is not enabled in all builds of Agda, - because the implementation depends on the - [ICU](http://site.icu-project.org) library, the installation of - which could cause extra trouble for some users. The presence of this - flag is controlled by the Cabal flag `enable-cluster-counting`. - -* A faster variant of the LaTeX backend: QuickLaTeX. - - When this variant of the backend is used the top-level module is not - type-checked, only scope-checked. This implies that some - highlighting information is not available. For instance, overloaded - constructors are not resolved. - - QuickLaTeX can be invoked from the Emacs mode, or using `agda - --latex --only-scope-checking`. If the module has already been - type-checked successfully, then this information is reused; in this - case QuickLaTeX behaves like the regular LaTeX backend. - - The `--only-scope-checking` flag can also be used independently, but - it is perhaps unclear what purpose that would serve. (The flag can - currently not be combined with `--html`, `--dependency-graph` or - `--vim`.) The flag is not allowed in safe mode. - -Pragmas and options -------------------- - -* The `--safe` option is now a valid pragma. - - This makes it possible to declare a module as being part of the safe - subset of the language by stating `{-# OPTIONS --safe #-}` at the top - of the corresponding file. Incompatibilities between the `--safe` option - and other options or language constructs are non-fatal errors. - -* The `--no-main` option is now a valid pragma. - - One can now suppress the compiler warning about a missing main function by - putting - ```agda - {-# OPTIONS --no-main #-} - ``` - on top of the file. - -* New command-line option and pragma `--warning=MODE` (or `-W MODE`) for - setting the warning mode. Current options are - - `warn` for displaying warnings (default) - - `error` for turning warnings into errors - - `ignore` for not displaying warnings - -List of fixed issues --------------------- - -For 2.5.3, the following issues have been fixed -(see [bug tracker](https://github.com/agda/agda/issues)): - - - [#142](https://github.com/agda/agda/issues/142): Inherited dot patterns in with functions are not checked - - [#623](https://github.com/agda/agda/issues/623): Error message points to importing module rather than imported module - - [#657](https://github.com/agda/agda/issues/657): Yet another display form problem - - [#668](https://github.com/agda/agda/issues/668): Ability to stop, or restart, typechecking somehow - - [#705](https://github.com/agda/agda/issues/705): confusing error message for ambiguous datatype module name - - [#719](https://github.com/agda/agda/issues/719): Error message for duplicate module definition points to external module instead of internal module - - [#776](https://github.com/agda/agda/issues/776): Unsolvable constraints should give error - - [#819](https://github.com/agda/agda/issues/819): Case-splitting doesn't preserve underscores - - [#883](https://github.com/agda/agda/issues/883): Rewrite loses type information - - [#899](https://github.com/agda/agda/issues/899): Instance search fails if there are several definitionally equal values in scope - - [#1077](https://github.com/agda/agda/issues/1077): problem with module syntax, with parametric module import - - [#1126](https://github.com/agda/agda/issues/1126): Port optimizations from the Epic backend - - [#1175](https://github.com/agda/agda/issues/1175): Internal Error in Auto - - [#1544](https://github.com/agda/agda/issues/1544): Positivity polymorphism needed for compositional positivity analysis - - [#1611](https://github.com/agda/agda/issues/1611): Interactive splitting instantiates meta - - [#1664](https://github.com/agda/agda/issues/1664): Add Reflection primitives to expose precedence and fixity - - [#1817](https://github.com/agda/agda/issues/1817): Solvable size constraints reported as unsolvable - - [#1832](https://github.com/agda/agda/issues/1832): Insufficient indentation in LaTeX-rendered Agda code - - [#1834](https://github.com/agda/agda/issues/1834): Copattern matching: order of clauses should not matter here - - [#1886](https://github.com/agda/agda/issues/1886): Second copies of telescopes not checked? - - [#1899](https://github.com/agda/agda/issues/1899): Positivity checker does not treat datatypes and record types in the same way - - [#1975](https://github.com/agda/agda/issues/1975): Type-incorrect instantiated overloaded constructor accepted in pattern - - [#1976](https://github.com/agda/agda/issues/1976): Type-incorrect instantiated projection accepted in pattern - - [#2035](https://github.com/agda/agda/issues/2035): Matching on string causes solver to fail with internal error - - [#2146](https://github.com/agda/agda/issues/2146): Unicode syntax for instance arguments - - [#2217](https://github.com/agda/agda/issues/2217): Abort Agda without losing state - - [#2229](https://github.com/agda/agda/issues/2229): Absence or presence of top-level module header affects scope - - [#2253](https://github.com/agda/agda/issues/2253): Wrong scope error for abstract constructors - - [#2261](https://github.com/agda/agda/issues/2261): Internal error in Auto/CaseSplit.hs:284 - - [#2270](https://github.com/agda/agda/issues/2270): Printer does not use sections. - - [#2329](https://github.com/agda/agda/issues/2329): Size solver does not use type `Size< i` to gain the necessary information - - [#2354](https://github.com/agda/agda/issues/2354): Interaction between instance search, size solver, and ordinary constraint solver. - - [#2355](https://github.com/agda/agda/issues/2355): Literate Agda parser does not recognize TeX comments - - [#2360](https://github.com/agda/agda/issues/2360): With clause stripping chokes on ambiguous projection - - [#2362](https://github.com/agda/agda/issues/2362): Printing of parent patterns when with-clause does not match - - [#2363](https://github.com/agda/agda/issues/2363): Allow underscore in with-clause patterns - - [#2366](https://github.com/agda/agda/issues/2366): With-clause patterns renamed in error message - - [#2368](https://github.com/agda/agda/issues/2368): Internal error after refining a tactic @ MetaVars.hs:267 - - [#2371](https://github.com/agda/agda/issues/2371): Shadowed module parameter crashes interaction - - [#2372](https://github.com/agda/agda/issues/2372): problems when instances are declared with inferred types - - [#2374](https://github.com/agda/agda/issues/2374): Ambiguous projection pattern could be disambiguated by visibility - - [#2376](https://github.com/agda/agda/issues/2376): Termination checking interacts badly with eta-contraction - - [#2377](https://github.com/agda/agda/issues/2377): open public is useless before module header - - [#2381](https://github.com/agda/agda/issues/2381): Search (`C-c C-z`) panics on pattern synonyms - - [#2386](https://github.com/agda/agda/issues/2386): Relax requirements of BUILTIN EQUALITY - - [#2389](https://github.com/agda/agda/issues/2389): BUILTIN REFL not needed - - [#2400](https://github.com/agda/agda/issues/2400): LaTeX backend error on LaTeX comments - - [#2402](https://github.com/agda/agda/issues/2402): Parameters not dropped when reporting incomplete patterns - - [#2403](https://github.com/agda/agda/issues/2403): Termination checker should reduce arguments in structural order check - - [#2405](https://github.com/agda/agda/issues/2405): instance search failing in parameterized module - - [#2408](https://github.com/agda/agda/issues/2408): DLub sorts are not serialized - - [#2412](https://github.com/agda/agda/issues/2412): Problem with checking with sized types - - [#2413](https://github.com/agda/agda/issues/2413): Agda crashes on x@y pattern - - [#2415](https://github.com/agda/agda/issues/2415): Size solver reports "inconsistent upper bound" even though there is a solution - - [#2416](https://github.com/agda/agda/issues/2416): Cannot give size as computed by solver - - [#2422](https://github.com/agda/agda/issues/2422): Overloaded inherited projections don't resolve - - [#2423](https://github.com/agda/agda/issues/2423): Inherited projection on lhs - - [#2426](https://github.com/agda/agda/issues/2426): On just warning about missing cases - - [#2429](https://github.com/agda/agda/issues/2429): Irrelevant lambda should be accepted when relevant lambda is expected - - [#2430](https://github.com/agda/agda/issues/2430): Another regression related to parameter refinement? - - [#2433](https://github.com/agda/agda/issues/2433): rebindLocalRewriteRules re-adds global rewrite rules - - [#2434](https://github.com/agda/agda/issues/2434): Exact split analysis is too strict when matching on eta record constructor - - [#2441](https://github.com/agda/agda/issues/2441): Incorrect alignement in latex using the new ACM format - - [#2444](https://github.com/agda/agda/issues/2444): Generalising compiler pragmas - - [#2445](https://github.com/agda/agda/issues/2445): The LaTeX backend is slow - - [#2447](https://github.com/agda/agda/issues/2447): Cache loaded interfaces even if a type error is encountered - - [#2449](https://github.com/agda/agda/issues/2449): Agda depends on additional C library icu - - [#2451](https://github.com/agda/agda/issues/2451): Agda panics when attempting to rewrite a typeclass Eq - - [#2456](https://github.com/agda/agda/issues/2456): Internal error when postulating instance - - [#2458](https://github.com/agda/agda/issues/2458): Regression: Agda-2.5.3 loops where Agda-2.5.2 passes - - [#2462](https://github.com/agda/agda/issues/2462): Overloaded postfix projection does not resolve - - [#2464](https://github.com/agda/agda/issues/2464): Eta contraction for irrelevant functions breaks subject reduction - - [#2466](https://github.com/agda/agda/issues/2466): Case split to make hidden variable visible does not work - - [#2467](https://github.com/agda/agda/issues/2467): REWRITE without BUILTIN REWRITE crashes - - [#2469](https://github.com/agda/agda/issues/2469): "Partial" pattern match causes segfault at runtime - - [#2472](https://github.com/agda/agda/issues/2472): Regression related to the auto command - - [#2477](https://github.com/agda/agda/issues/2477): Sized data type analysis brittle, does not reduce size - - [#2478](https://github.com/agda/agda/issues/2478): Multiply defined labels on the user manual (pdf) - - [#2479](https://github.com/agda/agda/issues/2479): "Occurs check" error in generated Haskell code - - [#2480](https://github.com/agda/agda/issues/2480): Agda accepts incorrect (?) code, subject reduction broken - - [#2482](https://github.com/agda/agda/issues/2482): Wrong counting of data parameters with new-style mutual blocks - - [#2483](https://github.com/agda/agda/issues/2483): Files are sometimes truncated to a size of 201 bytes - - [#2486](https://github.com/agda/agda/issues/2486): Imports via FOREIGN are not transitively inherited anymore - - [#2488](https://github.com/agda/agda/issues/2488): Instance search inhibits holes for instance fields - - [#2493](https://github.com/agda/agda/issues/2493): Regression: Agda seems to loop when expression is given - - [#2494](https://github.com/agda/agda/issues/2494): Instance fields sometimes have incorrect goal types - - [#2495](https://github.com/agda/agda/issues/2495): Regression: termination checker of Agda-2.5.3 seemingly loops where Agda-2.5.2 passes - - [#2500](https://github.com/agda/agda/issues/2500): Adding fields to a record can cause Agda to reject previous definitions - - [#2510](https://github.com/agda/agda/issues/2510): Wrong error with --no-pattern-matching - - [#2517](https://github.com/agda/agda/issues/2517): "Not a variable error" - - [#2518](https://github.com/agda/agda/issues/2518): CopatternReductions in TreeLess - - [#2523](https://github.com/agda/agda/issues/2523): The documentation of `--without-K` is outdated - - [#2529](https://github.com/agda/agda/issues/2529): Unable to install Agda on Windows. - - [#2537](https://github.com/agda/agda/issues/2537): case splitting with 'with' creates {_} instead of replicating the arguments it found. - - [#2538](https://github.com/agda/agda/issues/2538): Internal error when parsing as-pattern - - [#2543](https://github.com/agda/agda/issues/2543): Case splitting with ellipsis produces spurious parentheses - - [#2545](https://github.com/agda/agda/issues/2545): Race condition in api tests - - [#2549](https://github.com/agda/agda/issues/2549): Rewrite rule for higher path constructor does not fire - - [#2550](https://github.com/agda/agda/issues/2550): Internal error in Agda.TypeChecking.Substitute - - [#2552](https://github.com/agda/agda/issues/2552): Let bindings in module telescopes crash Agda.Interaction.BasicOps - - [#2553](https://github.com/agda/agda/issues/2553): Internal error in Agda.TypeChecking.CheckInternal - - [#2554](https://github.com/agda/agda/issues/2554): More flexible size-assignment in successor style - - [#2555](https://github.com/agda/agda/issues/2555): Why does the positivity checker care about non-recursive occurrences? - - [#2558](https://github.com/agda/agda/issues/2558): Internal error in Warshall Solver - - [#2560](https://github.com/agda/agda/issues/2560): Internal Error in Reduce.Fast - - [#2564](https://github.com/agda/agda/issues/2564): Non-exact-split highlighting makes other highlighting disappear - - [#2568](https://github.com/agda/agda/issues/2568): agda2-infer-type-maybe-toplevel (in hole) does not respect "single-solution" requirement of instance resolution - - [#2571](https://github.com/agda/agda/issues/2571): Record pattern translation does not eta contract - - [#2573](https://github.com/agda/agda/issues/2573): Rewrite rules fail depending on unrelated changes - - [#2574](https://github.com/agda/agda/issues/2574): No link attached to module without toplevel name - - [#2575](https://github.com/agda/agda/issues/2575): Internal error, related to caching - - [#2577](https://github.com/agda/agda/issues/2577): deBruijn fail for higher order instance problem - - [#2578](https://github.com/agda/agda/issues/2578): Catch-all clause face used incorrectly for parent with pattern - - [#2579](https://github.com/agda/agda/issues/2579): Import statements with module instantiation should not trigger an error message - - [#2580](https://github.com/agda/agda/issues/2580): Implicit absurd match is NonVariant, explicit not - - [#2583](https://github.com/agda/agda/issues/2583): Wrong de Bruijn index introduced by absurd pattern - - [#2584](https://github.com/agda/agda/issues/2584): Duplicate warning printing - - [#2585](https://github.com/agda/agda/issues/2585): Definition by copatterns not modulo eta - - [#2586](https://github.com/agda/agda/issues/2586): "λ where" with single absurd clause not parsed - - [#2588](https://github.com/agda/agda/issues/2588): `agda --latex` produces invalid LaTeX when there are block comments - - [#2592](https://github.com/agda/agda/issues/2592): Internal Error in Agda/TypeChecking/Serialise/Instances/Common.hs - - [#2597](https://github.com/agda/agda/issues/2597): Inline record definitions confuse the reflection API - - [#2602](https://github.com/agda/agda/issues/2602): Debug output messes up AgdaInfo buffer - - [#2603](https://github.com/agda/agda/issues/2603): Internal error in MetaVars.hs - - [#2604](https://github.com/agda/agda/issues/2604): Use QNames as anchors in generated HTML - - [#2605](https://github.com/agda/agda/issues/2605): HTML backend generates anchors for whitespace - - [#2606](https://github.com/agda/agda/issues/2606): Check that LHS of a rewrite rule doesn't reduce is too strict - - [#2612](https://github.com/agda/agda/issues/2612): `exact-split` documentation is outdated and incomplete - - [#2613](https://github.com/agda/agda/issues/2613): Parametrised modules, with-abstraction and termination - - [#2620](https://github.com/agda/agda/issues/2620): Internal error in auto. - - [#2621](https://github.com/agda/agda/issues/2621): Case splitting instantiates meta - - [#2626](https://github.com/agda/agda/issues/2626): triggered internal error with sized types in MetaVars module - - [#2629](https://github.com/agda/agda/issues/2629): Exact splitting should not complain about absurd clauses - - [#2631](https://github.com/agda/agda/issues/2631): docs for auto aren't clear on how to use flags/options - - [#2632](https://github.com/agda/agda/issues/2632): some flags to auto dont seem to work in current agda 2.5.2 - - [#2637](https://github.com/agda/agda/issues/2637): Internal error in Agda.TypeChecking.Pretty, possibly related to sized types - - [#2639](https://github.com/agda/agda/issues/2639): Performance regression, possibly related to the size solver - - [#2641](https://github.com/agda/agda/issues/2641): Required instance of FromNat when compiling imported files - - [#2642](https://github.com/agda/agda/issues/2642): Records with duplicate fields - - [#2644](https://github.com/agda/agda/issues/2644): Wrong substitution in expandRecordVar - - [#2645](https://github.com/agda/agda/issues/2645): Agda accepts postulated fields in a record - - [#2646](https://github.com/agda/agda/issues/2646): Only warn if fixities for undefined symbols are given - - [#2649](https://github.com/agda/agda/issues/2649): Empty list of "previous definition" in duplicate definition error - - [#2652](https://github.com/agda/agda/issues/2652): Added a new variant of the colon to the Agda input method - - [#2653](https://github.com/agda/agda/issues/2653): agda-mode: "cannot refine" inside instance argument even though term to be refined typechecks there - - [#2654](https://github.com/agda/agda/issues/2654): Internal error on result splitting without --postfix-projections - - [#2664](https://github.com/agda/agda/issues/2664): Segmentation fault with compiled programs using mutual record - - [#2665](https://github.com/agda/agda/issues/2665): Documentation: Record update syntax in wrong location - - [#2666](https://github.com/agda/agda/issues/2666): Internal error at Agda/Syntax/Abstract/Name.hs:113 - - [#2667](https://github.com/agda/agda/issues/2667): Panic error on unbound variable. - - [#2669](https://github.com/agda/agda/issues/2669): Interaction: incorrect field variable name generation - - [#2671](https://github.com/agda/agda/issues/2671): Feature request: nullary pattern matching lambdas - - [#2679](https://github.com/agda/agda/issues/2679): Internal error at "Typechecking/Abstract.hs:133" and "TypeChecking/Telescope.hs:68" - - [#2682](https://github.com/agda/agda/issues/2682): What are the rules for projections of abstract records? - - [#2684](https://github.com/agda/agda/issues/2684): Bad error message for abstract constructor - - [#2686](https://github.com/agda/agda/issues/2686): Abstract constructors should be ignored when resolving overloading - - [#2690](https://github.com/agda/agda/issues/2690): [regression?] Agda engages in deep search instead of immediately failing - - [#2700](https://github.com/agda/agda/issues/2700): Add a command to check against goal type (and normalise) - - [#2703](https://github.com/agda/agda/issues/2703): Regression: Internal error for underapplied indexed constructor - - [#2705](https://github.com/agda/agda/issues/2705): The GHC backend might diverge in infinite file creation - - [#2708](https://github.com/agda/agda/issues/2708): Why is the `name` field in .agda-lib files mandatory? - - [#2710](https://github.com/agda/agda/issues/2710): Type checker hangs - - [#2712](https://github.com/agda/agda/issues/2712): Compiler Pragma for headers - - [#2714](https://github.com/agda/agda/issues/2714): Option --no-main should be allowed as file-local option - - [#2717](https://github.com/agda/agda/issues/2717): internal error at DisplayForm.hs:197 - - [#2718](https://github.com/agda/agda/issues/2718): Interactive 'give' doesn't insert enough parenthesis - - [#2721](https://github.com/agda/agda/issues/2721): Without-K doesn't prevent heterogeneous conflict between literals - - [#2723](https://github.com/agda/agda/issues/2723): Unreachable clauses in definition by copattern matching trip clause compiler - - [#2725](https://github.com/agda/agda/issues/2725): File names for generated HTML files - - [#2726](https://github.com/agda/agda/issues/2726): Old regression related to with - - [#2727](https://github.com/agda/agda/issues/2727): Internal errors related to rewrite - - [#2729](https://github.com/agda/agda/issues/2729): Regression: case splitting uses variable name variants instead of the unused original names - - [#2730](https://github.com/agda/agda/issues/2730): Command to give in spite of termination errors - - [#2731](https://github.com/agda/agda/issues/2731): Agda fails to build with happy 1.19.6 - - [#2733](https://github.com/agda/agda/issues/2733): Avoid some uses of \AgdaIndent? - - [#2734](https://github.com/agda/agda/issues/2734): Make height of empty lines configurable - - [#2736](https://github.com/agda/agda/issues/2736): Segfault using Alex 3.2.2 and cpphs - - [#2740](https://github.com/agda/agda/issues/2740): Indenting every line of code should be a no-op - -Release notes for Agda version 2.5.2 -==================================== - -Installation and infrastructure -------------------------------- - -* Modular support for literate programming - - Literate programming support has been moved out of the lexer and into the - `Agda.Syntax.Parser.Literate` module. - - Files ending in `.lagda` are still interpreted as literate TeX. - The extension `.lagda.tex` may now also be used for literate TeX files. - - Support for more literate code formats and extensions can be added - modularly. - - By default, `.lagda.*` files are opened in the Emacs mode - corresponding to their last extension. One may switch to and from - Agda mode manually. - -* reStructuredText - - Literate Agda code can now be written in reStructuredText format, using - the `.lagda.rst` extension. - - As a general rule, Agda will parse code following a line ending in `::`, - as long as that line does not start with `..`. The module name must - match the path of the file in the documentation, and must be given - explicitly. Several files have been converted already, for instance: - - - `language/mixfix-operators.lagda.rst` - - `tools/compilers.lagda.rst` - - Note that: - - - Code blocks inside an rST comment block will be type-checked by Agda, - but not rendered in the documentation. - - Code blocks delimited by `.. code-block:: agda` will be rendered in - the final documenation, but not type-checked by Agda. - - All lines inside a codeblock must be further indented than the first line - of the code block. - - Indentation must be consistent between code blocks. In other - words, the file as a whole must be a valid Agda file if all the - literate text is replaced by white space. - -* Documentation testing - - All documentation files in the `doc/user-manual` directory that end - in `.lagda.rst` can be typechecked by running `make - user-manual-test`, and also as part of the general test suite. - -* Support installation through Stack - - The Agda sources now also include a configuration for the stack install tool - (tested through continuous integration). - - It should hence be possible to repeatably build any future Agda version - (including unreleased commits) from source by checking out that version and - running `stack install` from the checkout directory. - By using repeatable builds, this should keep selecting the same dependencies - in the face of new releases on Hackage. - - For further motivation, see - Issue [#2005](https://github.com/agda/agda/issues/2005). - -* Removed the `--test` command-line option - - This option ran the internal test-suite. This test-suite was - implemented using Cabal supports for - test-suites. [Issue [#2083](https://github.com/agda/agda/issues/2083)]. - -* The `--no-default-libraries` flag has been split into two flags - [Issue [#1937](https://github.com/agda/agda/issues/1937)] - - - `--no-default-libraries`: Ignore the defaults file but still look for local - `.agda-lib` files - - `--no-libraries`: Don't use any `.agda-lib` files (the previous behaviour - of `--no-default-libraries`). - -* If `agda` was built inside `git` repository, then the `--version` flag - will display the hash of the commit used, and whether the tree was - `-dirty` (i.e. there were uncommited changes in the working directory). - Otherwise, only the version number is shown. - -Language --------- - -* Dot patterns are now optional - - Consider the following program - - ```agda - data Vec (A : Set) : Nat → Set where - [] : Vec A zero - cons : ∀ n → A → Vec A n → Vec A (suc n) - - vmap : ∀ {A B} n → (A → B) → Vec A n → Vec B n - vmap .zero f [] = [] - vmap .(suc m) f (cons m x xs) = cons m (f x) (vmap m f xs) - ``` - - If we don't care about the dot patterns they can (and could previously) be - replaced by wildcards: - - ```agda - vmap : ∀ {A B} n → (A → B) → Vec A n → Vec B n - vmap _ f [] = [] - vmap _ f (cons m x xs) = cons m (f x) (vmap m f xs) - ``` - - Now it is also allowed to give a variable pattern in place of the dot - pattern. In this case the variable will be bound to the value of the dot - pattern. For our example: - - ```agda - vmap : ∀ {A B} n → (A → B) → Vec A n → Vec B n - vmap n f [] = [] - vmap n f (cons m x xs) = cons m (f x) (vmap m f xs) - ``` - - In the first clause `n` reduces to `zero` and in the second clause - `n` reduces to `suc m`. - -* Module parameters can now be refined by pattern matching - - Previously, pattern matches that would refine a variable outside the - current left-hand side was disallowed. For instance, the following - would give an error, since matching on the vector would - instantiate `n`. - - ```agda - module _ {A : Set} {n : Nat} where - f : Vec A n → Vec A n - f [] = [] - f (x ∷ xs) = x ∷ xs - ``` - - Now this is no longer disallowed. Instead `n` is bound to the - appropriate value in each clause. - -* With-abstraction now abstracts also in module parameters - - The change that allows pattern matching to refine module parameters also - allows with-abstraction to abstract in them. For instance, - - ```agda - module _ (n : Nat) (xs : Vec Nat (n + n)) where - f : Nat - f with n + n - f | nn = ? -- xs : Vec Nat nn - ``` - - Note: Any function argument or lambda-bound variable bound outside a given - function counts as a module parameter. - - To prevent abstraction in a parameter you can hide it inside a definition. In - the above example, - - ```agda - module _ (n : Nat) (xs : Vec Nat (n + n)) where - - ys : Vec Nat (n + n) - ys = xs - - f : Nat - f with n + n - f | nn = ? -- xs : Vec Nat nn, ys : Vec Nat (n + n) - ``` - -* As-patterns [Issue [#78](https://github.com/agda/agda/issues/78)]. - - As-patterns (`@`-patterns) are finally working and can be used to name a - pattern. The name has the same scope as normal pattern variables (i.e. the - right-hand side, where clause, and dot patterns). The name reduces to the - value of the named pattern. For example:: - - ```agda - module _ {A : Set} (_<_ : A → A → Bool) where - merge : List A → List A → List A - merge xs [] = xs - merge [] ys = ys - merge xs@(x ∷ xs₁) ys@(y ∷ ys₁) = - if x < y then x ∷ merge xs₁ ys - else y ∷ merge xs ys₁ - ``` - -* Idiom brackets. - - There is new syntactic sugar for idiom brackets: - - `(| e a1 .. an |)` expands to - - `pure e <*> a1 <*> .. <*> an` - - The desugaring takes place before scope checking and only requires names - `pure` and `_<*>_` in scope. Idiom brackets work well with operators, for - instance - - `(| if a then b else c |)` desugars to - - `pure if_then_else_ <*> a <*> b <*> c` - - Limitations: - - - The top-level application inside idiom brackets cannot include - implicit applications, so `(| foo {x = e} a b |)` is illegal. In - the case `e` is pure you can write `(| (foo {x = e}) a b |)` - which desugars to - - `pure (foo {x = e}) <*> a <*> b` - - - Binding syntax and operator sections cannot appear immediately inside - idiom brackets. - -* Layout for pattern matching lambdas. - - You can now write pattern matching lambdas using the syntax - - ```agda - λ where false → true - true → false - ``` - - avoiding the need for explicit curly braces and semicolons. - -* Overloaded projections - [Issue [#1944](https://github.com/agda/agda/issues/1944)]. - - Ambiguous projections are no longer a scope error. Instead they get - resolved based on the type of the record value they are - eliminating. This corresponds to constructors, which can be - overloaded and get disambiguated based on the type they are - introducing. Example: - - ```agda - module _ (A : Set) (a : A) where - - record R B : Set where - field f : B - open R public - - record S B : Set where - field f : B - open S public - ``` - - Exporting `f` twice from both `R` and `S` is now allowed. Then, - - ```agda - r : R A - f r = a - - s : S A - f s = f r - ``` - - disambiguates to: - - ```agda - r : R A - R.f r = a - - s : S A - S.f s = R.f r - ``` - - If the type of the projection is known, it can also be disambiguated - unapplied. - - ```agda - unapplied : R A -> A - unapplied = f - ``` - -* Postfix projections - [Issue [#1963](https://github.com/agda/agda/issues/1963)]. - - Agda now supports a postfix syntax for projection application. - This style is more in harmony with copatterns. For example: - - ```agda - record Stream (A : Set) : Set where - coinductive - field head : A - tail : Stream A - - open Stream - - repeat : ∀{A} (a : A) → Stream A - repeat a .head = a - repeat a .tail = repeat a - - zipWith : ∀{A B C} (f : A → B → C) (s : Stream A) (t : Stream B) → Stream C - zipWith f s t .head = f (s .head) (t .head) - zipWith f s t .tail = zipWith f (s .tail) (t .tail) - - module Fib (Nat : Set) (zero one : Nat) (plus : Nat → Nat → Nat) where - - {-# TERMINATING #-} - fib : Stream Nat - fib .head = zero - fib .tail .head = one - fib .tail .tail = zipWith plus fib (fib .tail) - ``` - - The thing we eliminate with projection now is visibly the head, - i.e., the left-most expression of the sequence (e.g. `repeat` in - `repeat a .tail`). - - The syntax overlaps with dot patterns, but for type correct left - hand sides there is no confusion: Dot patterns eliminate function - types, while (postfix) projection patterns eliminate record types. - - By default, Agda prints system-generated projections (such as by - eta-expansion or case splitting) prefix. This can be changed with - the new option: - - ```agda - {-# OPTIONS --postfix-projections #-} - ``` - - Result splitting in extended lambdas (aka pattern lambdas) always - produces postfix projections, as prefix projection pattern do not - work here: a prefix projection needs to go left of the head, but the - head is omitted in extended lambdas. - - ```agda - dup : ∀{A : Set}(a : A) → A × A - dup = λ{ a → ? } - ``` - - Result splitting (`C-c C-c RET`) here will yield: - - ```agda - dup = λ{ a .proj₁ → ? ; a .proj₂ → ? } - ``` - -* Projection parameters - [Issue [#1954](https://github.com/agda/agda/issues/1954)]. - - When copying a module, projection parameters will now stay hidden - arguments, even if the module parameters are visible. - This matches the situation we had for constructors since long. - Example: - - ```agda - module P (A : Set) where - record R : Set where - field f : A - - open module Q A = P A - ``` - - Parameter `A` is now hidden in `R.f`: - - ```agda - test : ∀{A} → R A → A - test r = R.f r - ``` - - Note that a module parameter that corresponds to the record value - argument of a projection will not be hidden. - - ```agda - module M (A : Set) (r : R A) where - open R A r public - - test' : ∀{A} → R A → A - test' r = M.f r - ``` - -* Eager insertion of implicit arguments - [Issue [#2001](https://github.com/agda/agda/issues/2001)] - - Implicit arguments are now (again) eagerly inserted in left-hand sides. The - previous behaviour of inserting implicits for where blocks, but not - right-hand sides was not type safe. - -* Module applications can now be eta expanded/contracted without - changing their behaviour - [Issue #[1985](https://github.com/agda/agda/issues/1985)] - - Previously definitions exported using `open public` got the - incorrect type for underapplied module applications. - - Example: - - ```agda - module A where - postulate A : Set - - module B (X : Set) where - open A public - - module C₁ = B - module C₂ (X : Set) = B X - ``` - - Here both `C₁.A` and `C₂.A` have type `(X : Set) → Set`. - -* Polarity pragmas. - - Polarity pragmas can be attached to postulates. The polarities express - how the postulate's arguments are used. The following polarities - are available: - - `_`: Unused. - - `++`: Strictly positive. - - `+`: Positive. - - `-`: Negative. - - `*`: Unknown/mixed. - - Polarity pragmas have the form - - ``` - {-# POLARITY name #-} - ``` - - and can be given wherever fixity declarations can be given. The - listed polarities apply to the given postulate's arguments - (explicit/implicit/instance), from left to right. Polarities - currently cannot be given for module parameters. If the postulate - takes n arguments (excluding module parameters), then the number of - polarities given must be between 0 and n (inclusive). - - Polarity pragmas make it possible to use postulated type formers in - recursive types in the following way: - - ```agda - postulate - ∥_∥ : Set → Set - - {-# POLARITY ∥_∥ ++ #-} - - data D : Set where - c : ∥ D ∥ → D - ``` - - Note that one can use postulates that may seem benign, together with - polarity pragmas, to prove that the empty type is inhabited: - - ```agda - postulate - _⇒_ : Set → Set → Set - lambda : {A B : Set} → (A → B) → A ⇒ B - apply : {A B : Set} → A ⇒ B → A → B - - {-# POLARITY _⇒_ ++ #-} - - data ⊥ : Set where - - data D : Set where - c : D ⇒ ⊥ → D - - not-inhabited : D → ⊥ - not-inhabited (c f) = apply f (c f) - - inhabited : D - inhabited = c (lambda not-inhabited) - - bad : ⊥ - bad = not-inhabited inhabited - ``` - - Polarity pragmas are not allowed in safe mode. - -* Declarations in a `where`-block are now - private. [Issue [#2101](https://github.com/agda/agda/issues/2101)] - This means that - - ```agda - f ps = body where - decls - ``` - - is now equivalent to - - ```agda - f ps = body where - private - decls - ``` - - This changes little, since the `decls` were anyway not in scope - outside `body`. However, it makes a difference for abstract - definitions, because private type signatures can see through - abstract definitions. Consider: - - ```agda - record Wrap (A : Set) : Set where - field unwrap : A - - postulate - P : ∀{A : Set} → A → Set - - abstract - - unnamedWhere : (A : Set) → Set - unnamedWhere A = A - where -- the following definitions are private! - B : Set - B = Wrap A - - postulate - b : B - test : P (Wrap.unwrap b) -- succeeds - ``` - - The `abstract` is inherited in `where`-blocks from the parent (here: - function `unnamedWhere`). Thus, the definition of `B` is opaque and - the type equation `B = Wrap A` cannot be used to check type - signatures, not even of abstract definitions. Thus, checking the - type `P (Wrap.unwrap b)` would fail. However, if `test` is - private, abstract definitions are translucent in its type, and - checking succeeds. With the implemented change, all - `where`-definitions are private, in this case `B`, `b`, and `test`, - and the example succeeds. - - Nothing changes for the named forms of `where`, - - ```agda - module M where - module _ where - ``` - - For instance, this still fails: - - ```agda - abstract - - unnamedWhere : (A : Set) → Set - unnamedWhere A = A - module M where - B : Set - B = Wrap A - - postulate - b : B - test : P (Wrap.unwrap b) -- fails - ``` - -* Private anonymous modules now work as expected - [Issue [#2199](https://github.com/agda/agda/issues/2199)] - - Previously the `private` was ignored for anonymous modules causing - its definitions to be visible outside the module containing the - anonymous module. This is no longer the case. For instance, - - ```agda - module M where - private - module _ (A : Set) where - Id : Set - Id = A - - foo : Set → Set - foo = Id - - open M - - bar : Set → Set - bar = Id -- Id is no longer in scope here - ``` - -* Pattern synonyms are now expanded on left hand sides of DISPLAY - pragmas [Issue [#2132](https://github.com/agda/agda/issues/2132)]. - Example: - - ```agda - data D : Set where - C c : D - g : D → D - - pattern C′ = C - - {-# DISPLAY C′ = C′ #-} - {-# DISPLAY g C′ = c #-} - ``` - - This now behaves as: - - ```agda - {-# DISPLAY C = C′ #-} - {-# DISPLAY g C = c #-} - ``` - - Expected error for - - ```agda - test : C ≡ g C - test = refl - ``` - - is thus: - - ``` - C′ != c of type D - ``` - -* The built-in floats have new semantics to fix inconsistencies - and to improve cross-platform portability. - - - Float equality has been split into two primitives. - ``primFloatEquality`` is designed to establish - decidable propositional equality while - ``primFloatNumericalEquality`` is intended for numerical - computations. They behave as follows: - - ``` - primFloatEquality NaN NaN = True - primFloatEquality 0.0 -0.0 = False - - primFloatNumericalEquality NaN NaN = False - primFloatNumericalEquality 0.0 -0.0 = True - ``` - - This change fixes an inconsistency, see [Issue [#2169](https://github.com/agda/agda/issues/2169)]. - For further detail see the [user manual](http://agda.readthedocs.io/en/v2.5.2/language/built-ins.html#floats). - - - Floats now have only one `NaN` value. This is necessary - for proper Float support in the JavaScript backend, - as JavaScript (and some other platforms) only support - one `NaN` value. - - - The primitive function `primFloatLess` was renamed - `primFloatNumericalLess`. - -* Added new primitives to built-in floats: - - - `primFloatNegate : Float → Float` - [Issue [#2194](https://github.com/agda/agda/issues/2194)] - - - Trigonometric primitives - [Issue [#2200](https://github.com/agda/agda/issues/2200)]: - - ```agda - primCos : Float → Float - primTan : Float → Float - primASin : Float → Float - primACos : Float → Float - primATan : Float → Float - primATan2 : Float → Float → Float - ``` - -* Anonymous declarations - [Issue [#1465](https://github.com/agda/agda/issues/1465)]. - - A module can contain an arbitrary number of declarations - named `_` which will scoped-checked and type-checked but - won't be made available in the scope (nor exported). They - cannot introduce arguments on the LHS (but one can use - lambda-abstractions on the RHS) and they cannot be defined - by recursion. - - ```agda - _ : Set → Set - _ = λ x → x - ``` - -### Rewriting - -* The REWRITE pragma can now handle several names. E.g.: - ```agda - {-# REWRITE eq1 eq2 #-} - ``` - -### Reflection - -* You can now use macros in reflected terms - [Issue [#2130](https://github.com/agda/agda/issues/2130)]. - - For instance, given a macro - - ```agda - macro - some-tactic : Term → TC ⊤ - some-tactic = ... - ``` - - the term `def (quote some-tactic) []` represents a call to the - macro. This makes it a lot easier to compose tactics. - -* The reflection machinery now uses normalisation less often: - - * Macros no longer normalise the (automatically quoted) term - arguments. - - * The TC primitives `inferType`, `checkType` and `quoteTC` no longer - normalise their arguments. - - * The following deprecated constructions may also have been changed: - `quoteGoal`, `quoteTerm`, `quoteContext` and `tactic`. - -* New TC primitive: `withNormalisation`. - - To recover the old normalising behaviour of `inferType`, `checkType`, - `quoteTC` and `getContext`, you can wrap them inside a call to - `withNormalisation true`: - - ```agda - withNormalisation : ∀ {a} {A : Set a} → Bool → TC A → TC A - ``` - -* New TC primitive: `reduce`. - - ```agda - reduce : Term → TC Term - ``` - - Reduces its argument to weak head normal form. - -* Added new TC primitive: `isMacro` - [Issue [#2182](https://github.com/agda/agda/issues/2182)] - - ```agda - isMacro : Name → TC Bool - ``` - - Returns `true` if the name refers to a macro, otherwise `false`. - -* The `record-type` constructor now has an extra argument containing - information about the record type's fields: - ```agda - data Definition : Set where - … - record-type : (c : Name) (fs : List (Arg Name)) → Definition - … - ``` - -Type checking -------------- - -* Files with open metas can be imported now - [Issue [#964](https://github.com/agda/agda/issues/964)]. This - should make simultaneous interactive development on several modules - more pleasant. - - Requires option: `--allow-unsolved-metas` - - Internally, before serialization, open metas are turned into postulates named - - ``` - unsolved#meta. - ``` - - where `` is the internal meta variable number. - -* The performance of the compile-time evaluator has been greatly improved. - - - Fixed a memory leak in evaluator - (Issue [#2147](https://github.com/agda/agda/issues/2147)). - - - Reduction speed improved by an order of magnitude and is now - comparable to the performance of GHCi. Still call-by-name though. - -* The detection of types that satisfy K added in Agda 2.5.1 has been - rolled back (see - Issue [#2003](https://github.com/agda/agda/issues/2003)). - -* Eta-equality for record types is now only on after the positivity - checker has confirmed it is safe to have it. Eta-equality for - unguarded inductive records previously lead to looping of the type - checker. - [See Issue [#2197](https://github.com/agda/agda/issues/2197)] - - ```agda - record R : Set where - inductive - field r : R - - loops : R - loops = ? - ``` - - As a consequence of this change, the following example does not - type-check any more: - - ```agda - mutual - record ⊤ : Set where - - test : ∀ {x y : ⊤} → x ≡ y - test = refl - ``` - - It fails because the positivity checker is only run after the mutual - block, thus, eta-equality for `⊤` is not available when checking - test. - - One can declare eta-equality explicitly, though, to make this - example work. - - ```agda - mutual - record ⊤ : Set where - eta-equality - - test : ∀ {x y : ⊤} → x ≡ y - test = refl - ``` - -* Records with instance fields are now eta expanded before instance search. - - For instance, assuming `Eq` and `Ord` with boolean functions `_==_` and `_<_` - respectively, - - ```agda - record EqAndOrd (A : Set) : Set where - field {{eq}} : Eq A - {{ord}} : Ord A - - - leq : {A : Set} {{_ : EqAndOrd A}} → A → A → Bool - leq x y = x == y || x < y - ``` - - Here the `EqAndOrd` record is automatically unpacked before instance search, - revealing the component `Eq` and `Ord` instances. - - This can be used to simulate superclass dependencies. - -* Overlappable record instance fields. - - Instance fields in records can be marked as overlappable using the new - `overlap` keyword: - - ```agda - record Ord (A : Set) : Set where - field - _<_ : A → A → Bool - overlap {{eqA}} : Eq A - ``` - - When instance search finds multiple candidates for a given instance goal and - they are **all** overlappable it will pick the left-most candidate instead of - refusing to solve the instance goal. - - This can be use to solve the problem arising from shared "superclass" - dependencies. For instance, if you have, in addition to `Ord` above, a `Num` - record that also has an `Eq` field and want to write a function requiring - both `Ord` and `Num`, any `Eq` constraint will be solved by the `Eq` instance - from whichever argument that comes first. - - ```agda - record Num (A : Set) : Set where - field - fromNat : Nat → A - overlap {{eqA}} : Eq A - - lessOrEqualFive : {A : Set} {{NumA : Num A}} {{OrdA : Ord A}} → A → Bool - lessOrEqualFive x = x == fromNat 5 || x < fromNat 5 - ``` - - In this example the call to `_==_` will use the `eqA` field from `NumA` - rather than the one from `OrdA`. Note that these may well be different. - -* Instance fields can be left out of copattern matches - [Issue [#2288](https://github.com/agda/agda/issues/2288)] - - Missing cases for instance fields (marked `{{` `}}`) in copattern matches - will be solved using instance search. This makes defining instances with - superclass fields much nicer. For instance, we can define `Nat` instances of - `Eq`, `Ord` and `Num` from above as follows: - - ```agda - instance - EqNat : Eq Nat - _==_ {{EqNat}} n m = eqNat n m - - OrdNat : Ord Nat - _<_ {{OrdNat}} n m = lessNat n m - - NumNat : Num Nat - fromNat {{NumNat}} n = n - ``` - - The `eqA` fields of `Ord` and `Num` are filled in using instance search (with - `EqNat` in this case). - -* Limited instance search depth - [Issue [#2269](https://github.com/agda/agda/issues/2269)] - - To prevent instance search from looping on bad instances - (see [Issue #1743](https://github.com/agda/agda/issues/1743)) the search - depth of instance search is now limited. The maximum depth can be set with - the `--instance-search-depth` flag and the default value is `500`. - -Emacs mode ----------- - -* New command `C-u C-u C-c C-n`: Use `show` to display the result of - normalisation. - - Calling `C-u C-u C-c C-n` on an expression `e` (in a hole or at top level) - normalises `show e` and prints the resulting string, or an error message if - the expression does not normalise to a literal string. - - This is useful when working with complex data structures for which you have - defined a nice `Show` instance. - - Note that the name `show` is hardwired into the command. - -* Changed feature: Interactively split result. - - Make-case (`C-c C-c`) with no variables will now *either* introduce - function arguments *or* do a copattern split (or fail). - - This is as before: - - ```agda - test : {A B : Set} (a : A) (b : B) → A × B - test a b = ? - - -- expected: - -- proj₁ (test a b) = {!!} - -- proj₂ (test a b) = {!!} - - testFun : {A B : Set} (a : A) (b : B) → A × B - testFun = ? - - -- expected: - -- testFun a b = {!!} - ``` - - This is has changed: - - ```agda - record FunRec A : Set where - field funField : A → A - open FunRec - - testFunRec : ∀{A} → FunRec A - testFunRec = ? - - -- expected (since 2016-05-03): - -- funField testFunRec = {!!} - - -- used to be: - -- funField testFunRec x = {!!} - ``` - -* Changed feature: Split on hidden variables. - - Make-case (`C-c C-c`) will no longer split on the given hidden - variables, but only make them visible. (Splitting can then be - performed in a second go.) - - ```agda - test : ∀{N M : Nat} → Nat → Nat → Nat - test N M = {!.N N .M!} - ``` - - Invoking splitting will result in: - - ```agda - test {N} {M} zero M₁ = ? - test {N} {M} (suc N₁) M₁ = ? - ``` - - The hidden `.N` and `.M` have been brought into scope, the - visible `N` has been split upon. - -* Non-fatal errors/warnings. - - Non-fatal errors and warnings are now displayed in the info buffer - and do not interrupt the typechecking of the file. - - Currently termination errors, unsolved metavariables, unsolved - constraints, positivity errors, deprecated BUILTINs, and empty - REWRITING pragmas are non-fatal errors. - -* Highlighting for positivity check failures - - Negative occurences of a datatype in its definition are now - highlighted in a way similar to termination errors. - -* The abbrev for codata was replaced by an abbrev for code - environments. - - If you type `c C-x '` (on a suitably standard setup), then Emacs - will insert the following text: - - ```agda - \begin{code} \end{code}. - ``` - -* The LaTeX backend can now be invoked from the Emacs mode. - - Using the compilation command (`C-c C-x C-c`). - - The flag `--latex-dir` can be used to set the output directory (by - default: `latex`). Note that if this directory is a relative path, - then it is interpreted relative to the "project root". (When the - LaTeX backend is invoked from the command line the path is - interpreted relative to the current working directory.) Example: If - the module `A.B.C` is located in the file `/foo/A/B/C.agda`, then - the project root is `/foo/`, and the default output directory is - `/foo/latex/`. - -* The compilation command (`C-c C-x C-c`) now by default asks for a - backend. - - To avoid this question, set the customisation variable - `agda2-backend` to an appropriate value. - -* The command `agda2-measure-load-time` no longer "touches" the file, - and the optional argument `DONT-TOUCH` has been removed. - -* New command `C-u (C-u) C-c C-s`: Simplify or normalise the solution `C-c C-s` produces - - When writing examples, it is nice to have the hole filled in with - a normalised version of the solution. Calling `C-c C-s` on - - ```agda - _ : reverse (0 ∷ 1 ∷ []) ≡ ? - _ = refl - ``` - - used to yield the non informative `reverse (0 ∷ 1 ∷ [])` when we would - have hopped to get `1 ∷ 0 ∷ []` instead. We can now control finely the - degree to which the solution is simplified. - -* Changed feature: Solving the hole at point - - Calling `C-c C-s` inside a specific goal does not solve *all* the goals - already instantiated internally anymore: it only solves the one at hand - (if possible). - -* New bindings: All the blackboard bold letters are now available - [Pull Request [#2305](https://github.com/agda/agda/pull/2305)] - - The Agda input method only bound a handful of the blackboard bold letters - but programmers were actually using more than these. They are now all - available: lowercase and uppercase. Some previous bindings had to be - modified for consistency. The naming scheme is as follows: - - * `\bx` for lowercase blackboard bold - * `\bX` for uppercase blackboard bold - * `\bGx` for lowercase greek blackboard bold (similar to `\Gx` for - greeks) - * `\bGX` for uppercase greek blackboard bold (similar to `\GX` for - uppercase greeks) - -* Replaced binding for go back - - Use `M-,` (instead of `M-*`) for go back in Emacs ≥ 25.1 (and - continue using `M-*` with previous versions of Emacs). - -Compiler backends ------------------ - -* JS compiler backend - - The JavaScript backend has been (partially) rewritten. The - JavaScript backend now supports most Agda features, notably - copatterns can now be compiled to JavaScript. Furthermore, the - existing optimizations from the other backends now apply to the - JavaScript backend as well. - -* GHC, JS and UHC compiler backends - - Added new primitives to built-in floats - [Issues [#2194](https://github.com/agda/agda/issues/2194) and - [#2200](https://github.com/agda/agda/issues/2200)]: - - ```agda - primFloatNegate : Float → Float - primCos : Float → Float - primTan : Float → Float - primASin : Float → Float - primACos : Float → Float - primATan : Float → Float - primATan2 : Float → Float → Float - ``` - -LaTeX backend -------------- - -* Code blocks are now (by default) surrounded by vertical space. - [Issue [#2198](https://github.com/agda/agda/issues/2198)] - - Use `\AgdaNoSpaceAroundCode{}` to avoid this vertical space, and - `\AgdaSpaceAroundCode{}` to reenable it. - - Note that, if `\AgdaNoSpaceAroundCode{}` is used, then empty lines - before or after a code block will not necessarily lead to empty - lines in the generated document. However, empty lines *inside* the - code block do (by default) lead to empty lines in the output. - - If you prefer the previous behaviour, then you can use the `agda.sty` - file that came with the previous version of Agda. - -* `\AgdaHide{...}` now eats trailing spaces (using `\ignorespaces`). - -* New environments: `AgdaAlign`, `AgdaSuppressSpace` and - `AgdaMultiCode`. - - Sometimes one might want to break up a code block into multiple - pieces, but keep code in different blocks aligned with respect to - each other. Then one can use the `AgdaAlign` environment. Example - usage: - ```latex - \begin{AgdaAlign} - \begin{code} - code - code (more code) - \end{code} - Explanation... - \begin{code} - aligned with "code" - code (aligned with (more code)) - \end{code} - \end{AgdaAlign} - ``` - Note that `AgdaAlign` environments should not be nested. - - Sometimes one might also want to hide code in the middle of a code - block. This can be accomplished in the following way: - ```latex - \begin{AgdaAlign} - \begin{code} - visible - \end{code} - \AgdaHide{ - \begin{code} - hidden - \end{code}} - \begin{code} - visible - \end{code} - \end{AgdaAlign} - ``` - However, the result may be ugly: extra space is perhaps inserted - around the code blocks. - - The `AgdaSuppressSpace` environment ensures that extra space is only - inserted before the first code block, and after the last one (but - not if `\AgdaNoSpaceAroundCode{}` is used). - - The environment takes one argument, the number of wrapped code - blocks (excluding hidden ones). Example usage: - ```latex - \begin{AgdaAlign} - \begin{code} - code - more code - \end{code} - Explanation... - \begin{AgdaSuppressSpace}{2} - \begin{code} - aligned with "code" - aligned with "more code" - \end{code} - \AgdaHide{ - \begin{code} - hidden code - \end{code}} - \begin{code} - also aligned with "more code" - \end{code} - \end{AgdaSuppressSpace} - \end{AgdaAlign} - ``` - - Note that `AgdaSuppressSpace` environments should not be nested. - - There is also a combined environment, `AgdaMultiCode`, that combines - the effects of `AgdaAlign` and `AgdaSuppressSpace`. - -Tools ------ - -### agda-ghc-names - -The `agda-ghc-names` now has its own repository at - - https://github.com/agda/agda-ghc-names - -and is no longer distributed with Agda. - -Release notes for Agda version 2.5.1.2 -====================================== - -* Fixed broken type signatures that were incorrectly accepted due to - [GHC #12784](https://ghc.haskell.org/trac/ghc/ticket/12784). - -Release notes for Agda version 2.5.1.1 -====================================== - -Installation and infrastructure -------------------------------- - -* Added support for GHC 8.0.1. - -* Documentation is now built with Python >=3.3, as done by - [readthedocs.org](https://readthedocs.org/). - -Bug fixes ---------- - -* Fixed a serious performance problem with instance search - - Issues [#1952](https://github.com/agda/agda/issues/1952) and - [#1998](https://github.com/agda/agda/issues/1998). Also related: - [#1955](https://github.com/agda/agda/issues/1955) and - [#2025](https://github.com/agda/agda/issues/2025) - -* Interactively splitting variable with `C-c C-c` no longer introduces - new trailing patterns. This fixes - Issue [#1950](https://github.com/agda/agda/issues/1950). - - ```agda - data Ty : Set where - _⇒_ : Ty → Ty → Ty - - ⟦_⟧ : Ty → Set - ⟦ A ⇒ B ⟧ = ⟦ A ⟧ → ⟦ B ⟧ - - data Term : Ty → Set where - K : (A B : Ty) → Term (A ⇒ (B ⇒ A)) - - test : (A : Ty) (a : Term A) → ⟦ A ⟧ - test A a = {!a!} - ``` - - Before change, case splitting on `a` would give - - ```agda - test .(A ⇒ (B ⇒ A)) (K A B) x x₁ = ? - ``` - - Now, it yields - - ```agda - test .(A ⇒ (B ⇒ A)) (K A B) = ? - ``` - -* In literate TeX files, `\begin{code}` and `\end{code}` can be - preceded (resp. followed) by TeX code on the same line. This fixes - Issue [#2077](https://github.com/agda/agda/issues/2077). - -* Other issues fixed (see - [bug tracker](https://github.com/agda/agda/issues)): - - [#1951](https://github.com/agda/agda/issues/1951) (mixfix binders - not working in 'syntax') - - [#1967](https://github.com/agda/agda/issues/1967) (too eager - insteance search error) - - [#1974](https://github.com/agda/agda/issues/1974) (lost constraint - dependencies) - - [#1982](https://github.com/agda/agda/issues/1982) (internal error in - unifier) - - [#2034](https://github.com/agda/agda/issues/2034) (function type - instance goals) - -Compiler backends ------------------ - -* UHC compiler backend - - Added support for UHC 1.1.9.4. - -Release notes for Agda version 2.5.1 -==================================== - -Documentation -------------- - -* There is now an official Agda User Manual: - https://agda.readthedocs.io/ - -Installation and infrastructure -------------------------------- - -* Builtins and primitives are now defined in a new set of modules available to - all users, independent of any particular library. The modules are - - ```agda - Agda.Builtin.Bool - Agda.Builtin.Char - Agda.Builtin.Coinduction - Agda.Builtin.Equality - Agda.Builtin.Float - Agda.Builtin.FromNat - Agda.Builtin.FromNeg - Agda.Builtin.FromString - Agda.Builtin.IO - Agda.Builtin.Int - Agda.Builtin.List - Agda.Builtin.Nat - Agda.Builtin.Reflection - Agda.Builtin.Size - Agda.Builtin.Strict - Agda.Builtin.String - Agda.Builtin.TrustMe - Agda.Builtin.Unit - ``` - - The standard library reexports the primitives from the new modules. - - The `Agda.Builtin` modules are installed in the same way as - `Agda.Primitive`, but unlike `Agda.Primitive` they are not loaded - automatically. - -Pragmas and options -------------------- - -* Library management - - There is a new 'library' concept for managing include paths. A library - consists of - - a name, - - a set of libraries it depends on, and - - a set of include paths. - - A library is defined in a `.agda-lib` file using the following - format: - - ``` - name: LIBRARY-NAME -- Comment - depend: LIB1 LIB2 - LIB3 - LIB4 - include: PATH1 - PATH2 - PATH3 - ``` - - Dependencies are library names, not paths to `.agda-lib` files, and - include paths are relative to the location of the library-file. - - To be useable, a library file has to be listed (with its full path) - in `AGDA_DIR/libraries` (or `AGDA_DIR/libraries-VERSION`, for a - given Agda version). `AGDA_DIR` defaults to `~/.agda` on Unix-like - systems and `C:/Users/USERNAME/AppData/Roaming/agda` or similar on - Windows, and can be overridden by setting the `AGDA_DIR` environment - variable. - - Environment variables in the paths (of the form `$VAR` or `${VAR}`) - are expanded. The location of the libraries file used can be - overridden using the `--library-file=FILE` flag, although this is - not expected to be very useful. - - You can find out the precise location of the 'libraries' file by - calling `agda -l fjdsk Dummy.agda` and looking at the error message - (assuming you don't have a library called fjdsk installed). - - There are three ways a library gets used: - - - You supply the `--library=LIB` (or `-l LIB`) option to - Agda. This is equivalent to adding a `-iPATH` for each of the - include paths of `LIB` and its (transitive) dependencies. - - - No explicit `--library` flag is given, and the current project - root (of the Agda file that is being loaded) or one of its - parent directories contains a `.agda-lib` file defining a - library `LIB`. This library is used as if a `--librarary=LIB` - option had been given, except that it is not necessary for the - library to be listed in the `AGDA_DIR/libraries` file. - - - No explicit `--library` flag, and no `.agda-lib` file in the - project root. In this case the file `AGDA_DIR/defaults` is read - and all libraries listed are added to the path. The defaults - file should contain a list of library names, each on a separate - line. In this case the current directory is also added to the - path. - - To disable default libraries, you can give the flag - `--no-default-libraries`. - - Library names can end with a version number (for instance, - `mylib-1.2.3`). When resolving a library name (given in a `--library` - flag, or listed as a default library or library dependency) the - following rules are followed: - - - If you don't give a version number, any version will do. - - - If you give a version number an exact match is required. - - - When there are multiple matches an exact match is preferred, and - otherwise the latest matching version is chosen. - - For example, suppose you have the following libraries installed: - `mylib`, `mylib-1.0`, `otherlib-2.1`, and `otherlib-2.3`. In this - case, aside from the exact matches you can also say - `--library=otherlib` to get `otherlib-2.3`. - -* New Pragma `COMPILED_DECLARE_DATA` for binding recursively defined - Haskell data types to recursively defined Agda data types. - - If you have a Haskell type like - - ```haskell - {-# LANGUAGE GADTs #-} - - module Issue223 where - - data A where - BA :: B -> A - - data B where - AB :: A -> B - BB :: B - ``` - - You can now bind it to corresponding mutual Agda inductive data - types as follows: - - ```agda - {-# IMPORT Issue223 #-} - - data A : Set - {-# COMPILED_DECLARE_DATA A Issue223.A #-} - data B : Set - {-# COMPILED_DECLARE_DATA B Issue223.B #-} - - data A where - BA : B → A - - {-# COMPILED_DATA A Issue223.A Issue223.BA #-} - data B where - AB : A → B - BB : B - - {-# COMPILED_DATA B Issue223.B Issue223.AB Issue223.BB #-} - ``` - - This fixes Issue [#223](https://github.com/agda/agda/issues/223). - -* New pragma `HASKELL` for adding inline Haskell code (GHC backend only) - - Arbitrary Haskell code can be added to a module using the `HASKELL` - pragma. For instance, - - ```agda - {-# HASKELL - echo :: IO () - echo = getLine >>= putStrLn - #-} - - postulate echo : IO ⊤ - {-# COMPILED echo echo #-} - ``` - -* New option `--exact-split`. - - The `--exact-split` flag causes Agda to raise an error whenever a - clause in a definition by pattern matching cannot be made to hold - definitionally (i.e. as a reduction rule). Specific clauses can be - excluded from this check by means of the `{-# CATCHALL #-}` pragma. - - For instance, the following definition will be rejected as the second clause - cannot be made to hold definitionally: - - ```agda - min : Nat → Nat → Nat - min zero y = zero - min x zero = zero - min (suc x) (suc y) = suc (min x y - ``` - - Catchall clauses have to be marked as such, for instance: - - ```agda - eq : Nat → Nat → Bool - eq zero zero = true - eq (suc m) (suc n) = eq m n - {-# CATCHALL #-} - eq _ _ = false - ``` - -* New option: `--no-exact-split`. - - This option can be used to override a global `--exact-split` in a - file, by adding a pragma `{-# OPTIONS --no-exact-split #-}`. - -* New options: `--sharing` and `--no-sharing`. - - These options are used to enable/disable sharing and call-by-need - evaluation. The default is `--no-sharing`. - - Note that they cannot appear in an OPTIONS pragma, but have to be - given as command line arguments or added to the Agda Program Args - from Emacs with `M-x customize-group agda2`. - -* New pragma `DISPLAY`. - - ```agda - {-# DISPLAY f e1 .. en = e #-} - ``` - - This causes `f e1 .. en` to be printed in the same way as `e`, where - `ei` can bind variables used in `e`. The expressions `ei` and `e` - are scope checked, but not type checked. - - For example this can be used to print overloaded (instance) functions with - the overloaded name: - - ```agda - instance - NumNat : Num Nat - NumNat = record { ..; _+_ = natPlus } - - {-# DISPLAY natPlus a b = a + b #-} - ``` - - Limitations - - - Left-hand sides are restricted to variables, constructors, defined - functions or types, and literals. In particular, lambdas are not - allowed in left-hand sides. - - - Since `DISPLAY` pragmas are not type checked implicit argument - insertion may not work properly if the type of `f` computes to an - implicit function space after pattern matching. - -* Removed pragma `{-# ETA R #-}` - - The pragma `{-# ETA R #-}` is replaced by the `eta-equality` directive - inside record declarations. - -* New option `--no-eta-equality`. - - The `--no-eta-equality` flag disables eta rules for declared record - types. It has the same effect as `no-eta-equality` inside each - declaration of a record type `R`. - - If used with the OPTIONS pragma it will not affect records defined - in other modules. - -* The semantics of `{-# REWRITE r #-}` pragmas in parametrized modules - has changed (see - Issue [#1652](https://github.com/agda/agda/issues/1652)). - - Rewrite rules are no longer lifted to the top context. Instead, they - now only apply to terms in (extensions of) the module context. If - you want the old behaviour, you should put the `{-# REWRITE r #-}` - pragma outside of the module (i.e. unindent it). - -* New pragma `{-# INLINE f #-}` causes `f` to be inlined during - compilation. - -* The `STATIC` pragma is now taken into account during compilation. - - Calls to a function marked `STATIC` are normalised before - compilation. The typical use case for this is to mark the - interpreter of an embedded language as `STATIC`. - -* Option `--type-in-type` no longer implies - `--no-universe-polymorphism`, thus, it can be used with explicit - universe - levels. [Issue [#1764](https://github.com/agda/agda/issues/1764)] It - simply turns off error reporting for any level mismatch now. - Examples: - - ```agda - {-# OPTIONS --type-in-type #-} - - Type : Set - Type = Set - - data D {α} (A : Set α) : Set where - d : A → D A - - data E α β : Set β where - e : Set α → E α β - ``` - -* New `NO_POSITIVITY_CHECK` pragma to switch off the positivity checker - for data/record definitions and mutual blocks. - - The pragma must precede a data/record definition or a mutual block. - - The pragma cannot be used in `--safe` mode. - - Examples (see `Issue1614*.agda` and `Issue1760*.agda` in - `test/Succeed/`): - - 1. Skipping a single data definition. - - ```agda - {-# NO_POSITIVITY_CHECK #-} - data D : Set where - lam : (D → D) → D - ``` - - 2. Skipping a single record definition. - - ```agda - {-# NO_POSITIVITY_CHECK #-} - record U : Set where - field ap : U → U - ``` - - 3. Skipping an old-style mutual block: Somewhere within a `mutual` - block before a data/record definition. - - ```agda - mutual - data D : Set where - lam : (D → D) → D - - {-# NO_POSITIVITY_CHECK #-} - record U : Set where - field ap : U → U - ``` - - 4. Skipping an old-style mutual block: Before the `mutual` keyword. - - ```agda - {-# NO_POSITIVITY_CHECK #-} - mutual - data D : Set where - lam : (D → D) → D - - record U : Set where - field ap : U → U - ``` - - 5. Skipping a new-style mutual block: Anywhere before the - declaration or the definition of data/record in the block. - - ```agda - record U : Set - data D : Set - - record U where - field ap : U → U - - {-# NO_POSITIVITY_CHECK #-} - data D where - lam : (D → D) → D - ``` - -* Removed `--no-coverage-check` - option. [Issue [#1918](https://github.com/agda/agda/issues/1918)] - -Language --------- - -### Operator syntax - -* The default fixity for syntax declarations has changed from -666 to 20. - -* Sections. - - Operators can be sectioned by replacing arguments with underscores. - There must not be any whitespace between these underscores and the - adjacent nameparts. Examples: - - ```agda - pred : ℕ → ℕ - pred = _∸ 1 - - T : Bool → Set - T = if_then ⊤ else ⊥ - - if : {A : Set} (b : Bool) → A → A → A - if b = if b then_else_ - ``` - - Sections are translated into lambda expressions. Examples: - - ```agda - _∸ 1 ↦ λ section → section ∸ 1 - - if_then ⊤ else ⊥ ↦ λ section → if section then ⊤ else ⊥ - - if b then_else_ ↦ λ section section₁ → - if b then section else section₁ - ``` - - Operator sections have the same fixity as the underlying operator - (except in cases like `if b then_else_`, in which the section is - "closed", but the operator is not). - - Operator sections are not supported in patterns (with the exception - of dot patterns), and notations coming from syntax declarations - cannot be sectioned. - -* A long-standing operator fixity bug has been fixed. As a consequence - some programs that used to parse no longer do. - - Previously each precedence level was (incorrectly) split up into - five separate ones, ordered as follows, with the earlier ones - binding less tightly than the later ones: - - - Non-associative operators. - - - Left associative operators. - - - Right associative operators. - - - Prefix operators. - - - Postfix operators. - - Now this problem has been addressed. It is no longer possible to mix - operators of a given precedence level but different associativity. - However, prefix and right associative operators are seen as having - the same associativity, and similarly for postfix and left - associative operators. - - Examples - -------- - - The following code is no longer accepted: - - ```agda - infixl 6 _+_ - infix 6 _∸_ - - rejected : ℕ - rejected = 1 + 0 ∸ 1 - ``` - - However, the following previously rejected code is accepted: - - ```agda - infixr 4 _,_ - infix 4 ,_ - - ,_ : {A : Set} {B : A → Set} {x : A} → B x → Σ A B - , y = _ , y - - accepted : Σ ℕ λ i → Σ ℕ λ j → Σ (i ≡ j) λ _ → Σ ℕ λ k → j ≡ k - accepted = 5 , , refl , , refl - ``` - -* The classification of notations with binders into the categories - infix, prefix, postfix or closed has - changed. [Issue [#1450](https://github.com/agda/agda/issues/1450)] - - The difference is that, when classifying the notation, only - *regular* holes are taken into account, not *binding* ones. - - Example: The notation - - ```agda - syntax m >>= (λ x → f) = x <- m , f - ``` - - was previously treated as infix, but is now treated as prefix. - -* Notation can now include wildcard binders. - - Example: `syntax Σ A (λ _ → B) = A × B` - -* If an overloaded operator is in scope with several distinct - precedence levels, then several instances of this operator will be - included in the operator grammar, possibly leading to ambiguity. - Previously the operator was given the default fixity - [Issue [#1436](https://github.com/agda/agda/issues/1436)]. - - There is an exception to this rule: If there are multiple precedences, - but at most one is explicitly declared, then only one instance will be - included in the grammar. If there are no explicitly declared - precedences, then this instance will get the default precedence, and - otherwise it will get the declared precedence. - - If multiple occurrences of an operator are "merged" in the grammar, - and they have distinct associativities, then they are treated as - being non-associative. - - The three paragraphs above also apply to identical notations (coming - from syntax declarations) for a given overloaded name. - - Examples: - - ```agda - module A where - - infixr 5 _∷_ - infixr 5 _∙_ - infixl 3 _+_ - infix 1 bind - - syntax bind c (λ x → d) = x ← c , d - - module B where - - infix 5 _∷_ - infixr 4 _∙_ - -- No fixity declaration for _+_. - infixl 2 bind - - syntax bind c d = c ∙ d - - module C where - - infixr 2 bind - - syntax bind c d = c ∙ d - - open A - open B - open C - - -- _∷_ is infix 5. - -- _∙_ has two fixities: infixr 4 and infixr 5. - -- _+_ is infixl 3. - -- A.bind's notation is infix 1. - -- B.bind and C.bind's notations are infix 2. - - -- There is one instance of "_ ∷ _" in the grammar, and one - -- instance of "_ + _". - - -- There are three instances of "_ ∙ _" in the grammar, one - -- corresponding to A._∙_, one corresponding to B._∙_, and one - -- corresponding to both B.bind and C.bind. - ``` - -### Reflection - -* The reflection framework has received a massive overhaul. - - A new type of reflected type checking computations supplants most of - the old reflection primitives. The `quoteGoal`, `quoteContext` and - tactic primitives are deprecated and will be removed in the future, - and the `unquoteDecl` and `unquote` primitives have changed - behaviour. Furthermore the following primitive functions have been - replaced by builtin type checking computations: - - ```agda - - primQNameType --> AGDATCMGETTYPE - - primQNameDefinition --> AGDATCMGETDEFINITION - - primDataConstructors --> subsumed by AGDATCMGETDEFINITION - - primDataNumberOfParameters --> subsumed by AGDATCMGETDEFINITION - ``` - - See below for details. - -* Types are no longer packaged with a sort. - - The `AGDATYPE` and `AGDATYPEEL` built-ins have been - removed. Reflected types are now simply terms. - -* Reflected definitions have more information. - - The type for reflected definitions has changed to - - ```agda - data Definition : Set where - fun-def : List Clause → Definition - data-type : Nat → List Name → Definition -- parameters and constructors - record-type : Name → Definition -- name of the data/record type - data-con : Name → Definition -- name of the constructor - axiom : Definition - prim-fun : Definition - ``` - - Correspondingly the built-ins for function, data and record - definitions (`AGDAFUNDEF`, `AGDAFUNDEFCON`, `AGDADATADEF`, - `AGDARECORDDEF`) have been removed. - -* Reflected type checking computations. - - There is a primitive `TC` monad representing type checking - computations. The `unquote`, `unquoteDecl`, and the new `unquoteDef` - all expect computations in this monad (see below). The interface to - the monad is the following - - ```agda - -- Error messages can contain embedded names and terms. - data ErrorPart : Set where - strErr : String → ErrorPart - termErr : Term → ErrorPart - nameErr : Name → ErrorPart - - {-# BUILTIN AGDAERRORPART ErrorPart #-} - {-# BUILTIN AGDAERRORPARTSTRING strErr #-} - {-# BUILTIN AGDAERRORPARTTERM termErr #-} - {-# BUILTIN AGDAERRORPARTNAME nameErr #-} - - postulate - TC : ∀ {a} → Set a → Set a - returnTC : ∀ {a} {A : Set a} → A → TC A - bindTC : ∀ {a b} {A : Set a} {B : Set b} → TC A → (A → TC B) → TC B - - -- Unify two terms, potentially solving metavariables in the process. - unify : Term → Term → TC ⊤ - - -- Throw a type error. Can be caught by catchTC. - typeError : ∀ {a} {A : Set a} → List ErrorPart → TC A - - -- Block a type checking computation on a metavariable. This will abort - -- the computation and restart it (from the beginning) when the - -- metavariable is solved. - blockOnMeta : ∀ {a} {A : Set a} → Meta → TC A - - -- Backtrack and try the second argument if the first argument throws a - -- type error. - catchTC : ∀ {a} {A : Set a} → TC A → TC A → TC A - - -- Infer the type of a given term - inferType : Term → TC Type - - -- Check a term against a given type. This may resolve implicit arguments - -- in the term, so a new refined term is returned. Can be used to create - -- new metavariables: newMeta t = checkType unknown t - checkType : Term → Type → TC Term - - -- Compute the normal form of a term. - normalise : Term → TC Term - - -- Get the current context. - getContext : TC (List (Arg Type)) - - -- Extend the current context with a variable of the given type. - extendContext : ∀ {a} {A : Set a} → Arg Type → TC A → TC A - - -- Set the current context. - inContext : ∀ {a} {A : Set a} → List (Arg Type) → TC A → TC A - - -- Quote a value, returning the corresponding Term. - quoteTC : ∀ {a} {A : Set a} → A → TC Term - - -- Unquote a Term, returning the corresponding value. - unquoteTC : ∀ {a} {A : Set a} → Term → TC A - - -- Create a fresh name. - freshName : String → TC QName - - -- Declare a new function of the given type. The function must be defined - -- later using 'defineFun'. Takes an Arg Name to allow declaring instances - -- and irrelevant functions. The Visibility of the Arg must not be hidden. - declareDef : Arg QName → Type → TC ⊤ - - -- Define a declared function. The function may have been declared using - -- 'declareDef' or with an explicit type signature in the program. - defineFun : QName → List Clause → TC ⊤ - - -- Get the type of a defined name. Replaces 'primQNameType'. - getType : QName → TC Type - - -- Get the definition of a defined name. Replaces 'primQNameDefinition'. - getDefinition : QName → TC Definition - - {-# BUILTIN AGDATCM TC #-} - {-# BUILTIN AGDATCMRETURN returnTC #-} - {-# BUILTIN AGDATCMBIND bindTC #-} - {-# BUILTIN AGDATCMUNIFY unify #-} - {-# BUILTIN AGDATCMNEWMETA newMeta #-} - {-# BUILTIN AGDATCMTYPEERROR typeError #-} - {-# BUILTIN AGDATCMBLOCKONMETA blockOnMeta #-} - {-# BUILTIN AGDATCMCATCHERROR catchTC #-} - {-# BUILTIN AGDATCMINFERTYPE inferType #-} - {-# BUILTIN AGDATCMCHECKTYPE checkType #-} - {-# BUILTIN AGDATCMNORMALISE normalise #-} - {-# BUILTIN AGDATCMGETCONTEXT getContext #-} - {-# BUILTIN AGDATCMEXTENDCONTEXT extendContext #-} - {-# BUILTIN AGDATCMINCONTEXT inContext #-} - {-# BUILTIN AGDATCMQUOTETERM quoteTC #-} - {-# BUILTIN AGDATCMUNQUOTETERM unquoteTC #-} - {-# BUILTIN AGDATCMFRESHNAME freshName #-} - {-# BUILTIN AGDATCMDECLAREDEF declareDef #-} - {-# BUILTIN AGDATCMDEFINEFUN defineFun #-} - {-# BUILTIN AGDATCMGETTYPE getType #-} - {-# BUILTIN AGDATCMGETDEFINITION getDefinition #-} - ``` - -* Builtin type for metavariables - - There is a new builtin type for metavariables used by the new reflection - framework. It is declared as follows and comes with primitive equality, - ordering and show. - - ```agda - postulate Meta : Set - {-# BUILTIN AGDAMETA Meta #-} - primitive primMetaEquality : Meta → Meta → Bool - primitive primMetaLess : Meta → Meta → Bool - primitive primShowMeta : Meta → String - ``` - - There are corresponding new constructors in the `Term` and `Literal` - data types: - - ```agda - data Term : Set where - ... - meta : Meta → List (Arg Term) → Term - - {-# BUILTIN AGDATERMMETA meta #-} - - data Literal : Set where - ... - meta : Meta → Literal - - {-# BUILTIN AGDALITMETA meta #-} - ``` - -* Builtin unit type - - The type checker needs to know about the unit type, which you can - allow by - - ```agda - record ⊤ : Set where - {-# BUILTIN UNIT ⊤ #-} - ``` - -* Changed behaviour of `unquote` - - The `unquote` primitive now expects a type checking computation - instead of a pure term. In particular `unquote e` requires - - ```agda - e : Term → TC ⊤ - ``` - - where the argument is the representation of the hole in which the - result should go. The old `unquote` behaviour (where `unquote` - expected a `Term` argument) can be recovered by - - ```agda - OLD: unquote v - NEW: unquote λ hole → unify hole v - ``` - -* Changed behaviour of `unquoteDecl` - - The `unquoteDecl` primitive now expects a type checking computation - instead of a pure function definition. It is possible to define - multiple (mutually recursive) functions at the same time. More - specifically - - ```agda - unquoteDecl x₁ .. xₙ = m - ``` - - requires `m : TC ⊤` and that `x₁ .. xₙ` are defined (using - `declareDef` and `defineFun`) after executing `m`. As before `x₁ - .. xₙ : QName` in `m`, but have their declared types outside the - `unquoteDecl`. - -* New primitive `unquoteDef` - - There is a new declaration - - ```agda - unquoteDef x₁ .. xₙ = m - ``` - - This works exactly as `unquoteDecl` (see above) with the exception - that `x₁ .. xₙ` are required to already be declared. - - The main advantage of `unquoteDef` over `unquoteDecl` is that - `unquoteDef` is allowed in mutual blocks, allowing mutually - recursion between generated definitions and hand-written - definitions. - -* The reflection interface now exposes the name hint (as a string) - for variables. As before, the actual binding structure is with - de Bruijn indices. The String value is just a hint used as a prefix - to help display the variable. The type `Abs` is a new builtin type used - for the constructors `Term.lam`, `Term.pi`, `Pattern.var` - (bultins `AGDATERMLAM`, `AGDATERMPI` and `AGDAPATVAR`). - - ```agda - data Abs (A : Set) : Set where - abs : (s : String) (x : A) → Abs A - {-# BUILTIN ABS Abs #-} - {-# BUILTIN ABSABS abs #-} - ``` - - Updated constructor types: - - ```agda - Term.lam : Hiding → Abs Term → Term - Term.pi : Arg Type → Abs Type → Term - Pattern.var : String → Pattern - ``` - -* Reflection-based macros - - Macros are functions of type `t1 → t2 → .. → Term → TC ⊤` that are - defined in a `macro` block. Macro application is guided by the type - of the macro, where `Term` arguments desugar into the `quoteTerm` - syntax and `Name` arguments into the `quote` syntax. Arguments of - any other type are preserved as-is. The last `Term` argument is the - hole term given to `unquote` computation (see above). - - For example, the macro application `f u v w` where the macro `f` has - the type `Term → Name → Bool → Term → TC ⊤` desugars into `unquote - (f (quoteTerm u) (quote v) w)` - - Limitations: - - - Macros cannot be recursive. This can be worked around by defining the - recursive function outside the macro block and have the macro call the - recursive function. - - Silly example: - - ```agda - macro - plus-to-times : Term → Term → TC ⊤ - plus-to-times (def (quote _+_) (a ∷ b ∷ [])) hole = unify hole (def (quote _*_) (a ∷ b ∷ [])) - plus-to-times v hole = unify hole v - - thm : (a b : Nat) → plus-to-times (a + b) ≡ a * b - thm a b = refl - ``` - - Macros are most useful when writing tactics, since they let you hide the - reflection machinery. For instance, suppose you have a solver - - ```agda - magic : Type → Term - ``` - - that takes a reflected goal and outputs a proof (when successful). You can - then define the following macro - - ```agda - macro - by-magic : Term → TC ⊤ - by-magic hole = - bindTC (inferType hole) λ goal → - unify hole (magic goal) - ``` - - This lets you apply the magic tactic without any syntactic noise at all: - - ```agda - thm : ¬ P ≡ NP - thm = by-magic - ``` - -### Literals and built-ins - -* Overloaded number literals. - - You can now overload natural number literals using the new builtin - `FROMNAT`: - - ```agda - {-# BUILTIN FROMNAT fromNat #-} - ``` - - The target of the builtin should be a defined name. Typically you would do - something like - - ```agda - record Number (A : Set) : Set where - field fromNat : Nat → A - - open Number {{...}} public - - {-# BUILTIN FROMNAT fromNat #-} - ``` - - This will cause number literals `n` to be desugared to `fromNat n` - before type checking. - -* Negative number literals. - - Number literals can now be negative. For floating point literals it - works as expected. For integer literals there is a new builtin - `FROMNEG` that enables negative integer literals: - - ```agda - {-# BUILTIN FROMNEG fromNeg #-} - ``` - - This causes negative literals `-n` to be desugared to `fromNeg n`. - -* Overloaded string literals. - - String literals can be overladed using the `FROMSTRING` builtin: - - ```agda - {-# BUILTIN FROMSTRING fromString #-} - ``` - - The will cause string literals `s` to be desugared to `fromString s` - before type checking. - -* Change to builtin integers. - - The `INTEGER` builtin now needs to be bound to a datatype with two - constructors that should be bound to the new builtins `INTEGERPOS` - and `INTEGERNEGSUC` as follows: - - ```agda - data Int : Set where - pos : Nat -> Int - negsuc : Nat -> Int - {-# BUILTIN INTEGER Int #-} - {-# BUILTIN INTEGERPOS pos #-} - {-# BUILTIN INTEGERNEGSUC negsuc #-} - ``` - - where `negsuc n` represents the integer `-n - 1`. For instance, `-5` - is represented as `negsuc 4`. All primitive functions on integers - except `primShowInteger` have been removed, since these can be - defined without too much trouble on the above representation using - the corresponding functions on natural numbers. - - The primitives that have been removed are - - ```agda - primIntegerPlus - primIntegerMinus - primIntegerTimes - primIntegerDiv - primIntegerMod - primIntegerEquality - primIntegerLess - primIntegerAbs - primNatToInteger - ``` - -* New primitives for strict evaluation - - ```agda - primitive - primForce : ∀ {a b} {A : Set a} {B : A → Set b} (x : A) → (∀ x → B x) → B x - primForceLemma : ∀ {a b} {A : Set a} {B : A → Set b} (x : A) (f : ∀ x → B x) → primForce x f ≡ f x - ``` - - `primForce x f` evaluates to `f x` if x is in weak head normal form, - and `primForceLemma x f` evaluates to `refl` in the same - situation. The following values are considered to be in weak head - normal form: - - - constructor applications - - literals - - lambda abstractions - - type constructor (data/record types) applications - - function types - - Set a - -### Modules - -* Modules in import directives - - When you use `using`/`hiding`/`renaming` on a name it now - automatically applies to any module of the same name, unless you - explicitly mention the module. For instance, - - ```agda - open M using (D) - ``` - - is equivalent to - - ```agda - open M using (D; module D) - ``` - - if `M` defines a module `D`. This is most useful for record and data - types where you always get a module of the same name as the type. - - With this feature there is no longer useful to be able to qualify a - constructor (or field) by the name of the data type even when it - differs from the name of the corresponding module. The follow - (weird) code used to work, but doesn't work anymore: - - ```agda - module M where - data D where - c : D - open M using (D) renaming (module D to MD) - foo : D - foo = D.c - ``` - - If you want to import only the type name and not the module you have to hide - it explicitly: - - ```agda - open M using (D) hiding (module D) - ``` - - See discussion on - Issue [#836](https://github.com/agda/agda/issues/836). - -* Private definitions of a module are no longer in scope at the Emacs - mode top-level. - - The reason for this change is that `.agdai-files` are stripped of - unused private definitions (which can yield significant performance - improvements for module-heavy code). - - To test private definitions you can create a hole at the bottom of - the module, in which private definitions will be visible. - -### Records - -* New record directives `eta-equality`/`no-eta-equality` - - The keywords `eta-equality`/`no-eta-equality` enable/disable eta - rules for the (inductive) record type being declared. - - ```agda - record Σ (A : Set) (B : A -> Set) : Set where - no-eta-equality - constructor _,_ - field - fst : A - snd : B fst - open Σ - - -- fail : ∀ {A : Set}{B : A -> Set} → (x : Σ A B) → x ≡ (fst x , snd x) - -- fail x = refl - -- - -- x != fst x , snd x of type Σ .A .B - -- when checking that the expression refl has type x ≡ (fst x , snd x) - ``` - -* Building records from modules. - - The `record { }` syntax is now extended to accept module - names as well. Fields are thus defined using the corresponding - definitions from the given module. - - For instance assuming this record type `R` and module `M`: - - ```agda - record R : Set where - field - x : X - y : Y - z : Z - - module M where - x = {! ... !} - y = {! ... !} - - r : R - r = record { M; z = {! ... !} } - ``` - - Previously one had to write `record { x = M.x; y = M.y; z = {! ... !} }`. - - More precisely this construction now supports any combination of explicit - field definitions and applied modules. - - If a field is both given explicitly and available in one of the modules, - then the explicit one takes precedence. - - If a field is available in more than one module then this is ambiguous - and therefore rejected. As a consequence the order of assignments does - not matter. - - The modules can be both applied to arguments and have import directives - such as `hiding`, `using`, and `renaming`. In particular this construct - subsumes the record update construction. - - Here is an example of record update: - - ```agda - -- Record update. Same as: record r { y = {! ... !} } - r2 : R - r2 = record { R r; y = {! ... !} } - ``` - - A contrived example showing the use of `hiding`/`renaming`: - - ```agda - module M2 (a : A) where - w = {! ... !} - z = {! ... !} - - r3 : A → R - r3 a = record { M hiding (y); M2 a renaming (w to y) } - ``` - -* Record patterns are now accepted. - - Examples: - - ```agda - swap : {A B : Set} (p : A × B) → B × A - swap record{ proj₁ = a; proj₂ = b } = record{ proj₁ = b; proj₂ = a } - - thd3 : ... - thd3 record{ proj₂ = record { proj₂ = c }} = c - ``` - -* Record modules now properly hide all their parameters - [Issue [#1759](https://github.com/agda/agda/issues/1759)] - - Previously parameters to parent modules were not hidden in the record - module, resulting in different behaviour between - - ```agda - module M (A : Set) where - record R (B : Set) : Set where - ``` - - and - - ```agda - module M where - record R (A B : Set) : Set where - ``` - - where in the former case, `A` would be an explicit argument to the module - `M.R`, but implicit in the latter case. Now `A` is implicit in both cases. - -### Instance search - -* Performance has been improved, recursive instance search which was - previously exponential in the depth is now only quadratic. - -* Constructors of records and datatypes are not anymore automatically - considered as instances, you have to do so explicitely, for - instance: - - ```agda - -- only [b] is an instance of D - data D : Set where - a : D - instance - b : D - c : D - - -- the constructor is now an instance - record tt : Set where - instance constructor tt - ``` - -* Lambda-bound variables are no longer automatically considered - instances. - - Lambda-bound variables need to be bound as instance arguments to be - considered for instance search. For example, - - ```agda - _==_ : {A : Set} {{_ : Eq A}} → A → A → Bool - - fails : {A : Set} → Eq A → A → Bool - fails eqA x = x == x - - works : {A : Set} {{_ : Eq A}} → A → Bool - works x = x == x - ``` - -* Let-bound variables are no longer automatically considered - instances. - - To make a let-bound variable available as an instance it needs to be - declared with the `instance` keyword, just like top-level - instances. For example, - - ```agda - mkEq : {A : Set} → (A → A → Bool) → Eq A - - fails : {A : Set} → (A → A → Bool) → A → Bool - fails eq x = let eqA = mkEq eq in x == x - - works : {A : Set} → (A → A → Bool) → A → Bool - works eq x = let instance eqA = mkEq eq in x == x - ``` - -* Record fields can be declared instances. - - For example, - - ```agda - record EqSet : Set₁ where - field - set : Set - instance eq : Eq set - ``` - - This causes the projection function `eq : (E : EqSet) → Eq (set E)` - to be considered for instance search. - -* Instance search can now find arguments in variable types (but such - candidates can only be lambda-bound variables, they can’t be - declared as instances) - - ```agda - module _ {A : Set} (P : A → Set) where - - postulate - bla : {x : A} {{_ : P x}} → Set → Set - - -- Works, the instance argument is found in the context - test : {x : A} {{_ : P x}} → Set → Set - test B = bla B - - -- Still forbidden, because [P] could be instantiated later to anything - instance - postulate - forbidden : {x : A} → P x - ``` - -* Instance search now refuses to solve constraints with unconstrained - metavariables, since this can lead to non-termination. - - See [Issue [#1532](https://github.com/agda/agda/issues/1523)] for an - example. - -* Top-level instances are now only considered if they are in - scope. [Issue [#1913](https://github.com/agda/agda/issues/1913)] - - Note that lambda-bound instances need not be in scope. - -### Other changes - -* Unicode ellipsis character is allowed for the ellipsis token `...` - in `with` expressions. - -* `Prop` is no longer a reserved word. - -Type checking -------------- - -* Large indices. - - Force constructor arguments no longer count towards the size of a datatype. - For instance, the definition of equality below is accepted. - - ```agda - data _≡_ {a} {A : Set a} : A → A → Set where - refl : ∀ x → x ≡ x - ``` - - This gets rid of the asymmetry that the version of equality which indexes - only on the second argument could be small, but not the version above which - indexes on both arguments. - -* Detection of datatypes that satisfy K (i.e. sets) - - Agda will now try to detect datatypes that satisfy K when - `--without-K` is enabled. A datatype satisfies K when it follows - these three rules: - - - The types of all non-recursive constructor arguments should satisfy K. - - - All recursive constructor arguments should be first-order. - - - The types of all indices should satisfy K. - - For example, the types `Nat`, `List Nat`, and `x ≡ x` (where `x : - Nat`) are all recognized by Agda as satisfying K. - -* New unifier for case splitting - - The unifier used by Agda for case splitting has been completely - rewritten. The new unifier takes a much more type-directed approach - in order to avoid the problems in issues - [#1406](https://github.com/agda/agda/issues/1406), - [#1408](https://github.com/agda/agda/issues/1408), - [#1427](https://github.com/agda/agda/issues/1427), and - [#1435](https://github.com/agda/agda/issues/1435). - - The new unifier also has eta-equality for record types - built-in. This should avoid unnecessary case splitting on record - constructors and improve the performance of Agda on code that - contains deeply nested record patterns (see issues - [#473](https://github.com/agda/agda/issues/473), - [#635](https://github.com/agda/agda/issues/635), - [#1575](https://github.com/agda/agda/issues/1575), - [#1603](https://github.com/agda/agda/issues/1603), - [#1613](https://github.com/agda/agda/issues/1613), and - [#1645](https://github.com/agda/agda/issues/1645)). - - In some cases, the locations of the dot patterns computed by the - unifier did not correspond to the locations given by the user (see - Issue [#1608](https://github.com/agda/agda/issues/1608)). This has - now been fixed by adding an extra step after case splitting that - checks whether the user-written patterns are compatible with the - computed ones. - - In some rare cases, the new unifier is still too restrictive when - `--without-K` is enabled because it cannot generalize over the - datatype indices (yet). For example, the following code is rejected: - - ```agda - data Bar : Set₁ where - bar : Bar - baz : (A : Set) → Bar - - data Foo : Bar → Set where - foo : Foo bar - - test : foo ≡ foo → Set₁ - test refl = Set - ``` - -* The aggressive behaviour of `with` introduced in 2.4.2.5 has been - rolled back - [Issue [#1692](https://github.com/agda/agda/issues/1692)]. With no - longer abstracts in the types of variables appearing in the - with-expressions. [Issue [#745](https://github.com/agda/agda/issues/745)] - - This means that the following example no longer works: - - ```agda - fails : (f : (x : A) → a ≡ x) (b : A) → b ≡ a - fails f b with a | f b - fails f b | .b | refl = f b - ``` - - The `with` no longer abstracts the type of `f` over `a`, since `f` - appears in the second with-expression `f b`. You can use a nested - `with` to make this example work. - - This example does work again: - - ```agda - test : ∀{A : Set}{a : A}{f : A → A} (p : f a ≡ a) → f (f a) ≡ a - test p rewrite p = p - ``` - - After `rewrite p` the goal has changed to `f a ≡ a`, but the type - of `p` has not been rewritten, thus, the final `p` solves the goal. - - The following, which worked in 2.4.2.5, no longer works: - - ```agda - fails : (f : (x : A) → a ≡ x) (b : A) → b ≡ a - fails f b rewrite f b = f b - ``` - - The rewrite with `f b : a ≡ b` is not applied to `f` as - the latter is part of the rewrite expression `f b`. Thus, - the type of `f` remains untouched, and the changed goal - `b ≡ b` is not solved by `f b`. - -* When using `rewrite` on a term `eq` of type `lhs ≡ rhs`, the `lhs` - is no longer abstracted in `rhs` - [Issue [#520](https://github.com/agda/agda/issues/520)]. This means - that - - ```agda - f pats rewrite eq = body - ``` - - is more than syntactic sugar for - - ```agda - f pats with lhs | eq - f pats | _ | refl = body - ``` - - In particular, the following application of `rewrite` is now - possible - - ```agda - id : Bool → Bool - id true = true - id false = false - - is-id : ∀ x → x ≡ id x - is-id true = refl - is-id false = refl - - postulate - P : Bool → Set - b : Bool - p : P (id b) - - proof : P b - proof rewrite is-id b = p - ``` - - Previously, this was desugared to - - ```agda - proof with b | is-id b - proof | _ | refl = p - ``` - - which did not type check as `refl` does not have type `b ≡ id b`. - Now, Agda gets the task of checking `refl : _ ≡ id b` leading to - instantiation of `_` to `id b`. - -Compiler backends ------------------ - -* Major Bug Fixes: - - - Function clauses with different arities are now always compiled - correctly by the GHC/UHC - backends. (Issue [#727](https://github.com/agda/agda/issues/727)) - -* Co-patterns - - - The GHC/UHC backends now support co-patterns. (Issues - [#1567](https://github.com/agda/agda/issues/1567), - [#1632](https://github.com/agda/agda/issues/1632)) - -* Optimizations - - - Builtin naturals are now represented as arbitrary-precision - Integers. See the user manual, section - "Agda Compilers -> Optimizations" for details. - -* GHC Haskell backend (MAlonzo) - - - Pragmas - - Since builtin naturals are compiled to `Integer` you can no longer - give a `{-# COMPILED_DATA #-}` pragma for `Nat`. The same goes for - builtin booleans, integers, floats, characters and strings which - are now hard-wired to appropriate Haskell types. - -* UHC compiler backend - - A new backend targeting the Utrecht Haskell Compiler (UHC) is - available. It targets the UHC Core language, and it's design is - inspired by the Epic backend. See the user manual, section "Agda - Compilers -> UHC Backend" for installation instructions. - - - FFI - - The UHC backend has a FFI to Haskell similar to MAlonzo's. The - target Haskell code also needs to be compilable using UHC, which - does not support the Haskell base library version 4.*. - - FFI pragmas for the UHC backend are not checked in any way. If the - pragmas are wrong, bad things will happen. - - - Imports - - Additional Haskell modules can be brought into scope with the - `IMPORT_UHC` pragma: - - ```agda - {-# IMPORT_UHC Data.Char #-} - ``` - - The Haskell modules `UHC.Base` and `UHC.Agda.Builtins` are always in - scope and don't need to be imported explicitly. - - - Datatypes - - Agda datatypes can be bound to Haskell datatypes as follows: - - Haskell: - ```haskell - data HsData a = HsCon1 | HsCon2 (HsData a) - ``` - - Agda: - ```agda - data AgdaData (A : Set) : Set where - AgdaCon1 : AgdaData A - AgdaCon2 : AgdaData A -> AgdaData A - {-# COMPILED_DATA_UHC AgdaData HsData HsCon1 HsCon2 #-} - ``` - - The mapping has to cover all constructors of the used Haskell - datatype, else runtime behavior is undefined! - - There are special reserved names to bind Agda datatypes to certain - Haskell datatypes. For example, this binds an Agda datatype to - Haskell's list datatype: - - Agda: - ```agda - data AgdaList (A : Set) : Set where - Nil : AgdaList A - Cons : A -> AgdaList A -> AgdaList A - {-# COMPILED_DATA_UHC AgdaList __LIST__ __NIL__ __CONS__ #-} - ``` - - The following "magic" datatypes are available: - - ``` - HS Datatype | Datatype Pragma | HS Constructor | Constructor Pragma - () __UNIT__ () __UNIT__ - List __LIST__ (:) __CONS__ - [] __NIL__ - Bool __BOOL__ True __TRUE__ - False __FALSE__ - ``` - - - Functions - - Agda postulates can be bound to Haskell functions. Similar as in - MAlonzo, all arguments of type `Set` need to be dropped before - calling Haskell functions. An example calling the return function: - - Agda: - ```agda - postulate hs-return : {A : Set} -> A -> IO A - {-# COMPILED_UHC hs-return (\_ -> UHC.Agda.Builtins.primReturn) #-} - ``` - -Emacs mode and interaction --------------------------- - -* Module contents (`C-c C-o`) now also works for - records. [See Issue [#1926](https://github.com/agda/agda/issues/1926) ] - If you have an inferable expression of record type in an interaction - point, you can invoke `C-c C-o` to see its fields and types. - Example - - ```agda - record R : Set where - field f : A - - test : R → R - test r = {!r!} -- C-c C-o here - ``` - -* Less aggressive error notification. - - Previously Emacs could jump to the position of an error even if the - type-checking process was not initiated in the current buffer. Now - this no longer happens: If the type-checking process was initiated - in another buffer, then the cursor is moved to the position of the - error in the buffer visiting the file (if any) and in every window - displaying the file, but focus should not change from one file to - another. - - In the cases where focus does change from one file to another, one - can now use the go-back functionality to return to the previous - position. - -* Removed the `agda-include-dirs` customization parameter. - - Use `agda-program-args` with `-iDIR` or `-lLIB` instead, or add - libraries to `~/.agda/defaults` - (`C:/Users/USERNAME/AppData/Roaming/agda/defaults` or similar on - Windows). See Library management, above, for more information. - -Tools ------ - -### LaTeX-backend - -* The default font has been changed to XITS (which is part of TeX Live): - - http://www.ctan.org/tex-archive/fonts/xits/ - - This font is more complete with respect to Unicode. - -### agda-ghc-names - -* New tool: The command - - ``` - agda-ghc-names fixprof .prof - ``` - - converts `*.prof` files obtained from profiling runs of - MAlonzo-compiled code to `*.agdaIdents.prof`, with the original Agda - identifiers replacing the MAlonzo-generated Haskell identifiers. - - For usage and more details, see `src/agda-ghc-names/README.txt`. - -Highlighting and textual backends ---------------------------------- - -* Names in import directives are now highlighted and are clickable. - [Issue [#1714](https://github.com/agda/agda/issues/1714)] This leads - also to nicer printing in the LaTeX and html backends. - -Fixed issues ------------- - -See -[bug tracker (milestone 2.5.1)](https://github.com/agda/agda/issues?q=milestone%3A2.5.1+is%3Aclosed) - -Release notes for Agda version 2.4.2.5 -====================================== - -Installation and infrastructure -------------------------------- - -* Added support for GHC 7.10.3. - -* Added `cpphs` Cabal flag - - Turn on/off this flag to choose cpphs/cpp as the C preprocessor. - - This flag is turn on by default. - - (This flag was added in Agda 2.4.2.1 but it was not documented) - -Pragmas and options -------------------- - -* Termination pragmas are no longer allowed inside `where` clauses - [Issue [#1137](https://github.com/agda/agda/issues/1137)]. - -Type checking -------------- - -* `with`-abstraction is more aggressive, abstracts also in types of - variables that are used in the `with`-expressions, unless they are - also used in the types of the - `with`-expressions. [Issue [#1692](https://github.com/agda/agda/issues/1692)] - - Example: - - ```agda - test : (f : (x : A) → a ≡ x) (b : A) → b ≡ a - test f b with a | f b - test f b | .b | refl = f b - ``` - - Previously, `with` would not abstract in types of variables that - appear in the `with`-expressions, in this case, both `f` and `b`, - leaving their types unchanged. Now, it tries to abstract in `f`, as - only `b` appears in the types of the `with`-expressions which are - `A` (of `a`) and `a ≡ b` (of `f b`). As a result, the type of `f` - changes to `(x : A) → b ≡ x` and the type of the goal to `b ≡ b` (as - previously). - - This also affects `rewrite`, which is implemented in terms of - `with`. - - ```agda - test : (f : (x : A) → a ≡ x) (b : A) → b ≡ a - test f b rewrite f b = f b - ``` - - As the new `with` is not fully backwards-compatible, some parts of - your Agda developments using `with` or `rewrite` might need - maintenance. - -Fixed issues ------------- - -See [bug tracker](https://github.com/agda/agda/issues) - -[#1407](https://github.com/agda/agda/issues/1497) - -[#1518](https://github.com/agda/agda/issues/1518) - -[#1670](https://github.com/agda/agda/issues/1670) - -[#1677](https://github.com/agda/agda/issues/1677) - -[#1698](https://github.com/agda/agda/issues/1698) - -[#1701](https://github.com/agda/agda/issues/1701) - -[#1710](https://github.com/agda/agda/issues/1710) - -[#1718](https://github.com/agda/agda/issues/1718) - -Release notes for Agda version 2.4.2.4 -====================================== - -Installation and infrastructure -------------------------------- - -* Removed support for GHC 7.4.2. - -Pragmas and options -------------------- - -* Option `--copatterns` is now on by default. To switch off - parsing of copatterns, use: - - ```agda - {-# OPTIONS --no-copatterns #-} - ``` - -* Option `--rewriting` is now needed to use `REWRITE` pragmas and - rewriting during reduction. Rewriting is not `--safe`. - - To use rewriting, first specify a relation symbol `R` that will - later be used to add rewrite rules. A canonical candidate would be - propositional equality - - ```agda - {-# BUILTIN REWRITE _≡_ #-} - ``` - - but any symbol `R` of type `Δ → A → A → Set i` for some `A` and `i` - is accepted. Then symbols `q` can be added to rewriting provided - their type is of the form `Γ → R ds l r`. This will add a rewrite - rule - - ``` - Γ ⊢ l ↦ r : A[ds/Δ] - ``` - - to the signature, which fires whenever a term is an instance of `l`. - For example, if - - ```agda - plus0 : ∀ x → x + 0 ≡ x - ``` - - (ideally, there is a proof for `plus0`, but it could be a - postulate), then - - ```agda - {-# REWRITE plus0 #-} - ``` - - will prompt Agda to rewrite any well-typed term of the form `t + 0` - to `t`. - - Some caveats: Agda accepts and applies rewrite rules naively, it is - very easy to break consistency and termination of type checking. - Some examples of rewrite rules that should *not* be added: - - ```agda - refl : ∀ x → x ≡ x -- Agda loops - plus-sym : ∀ x y → x + y ≡ y + x -- Agda loops - absurd : true ≡ false -- Breaks consistency - ``` - - Adding only proven equations should at least preserve consistency, - but this is only a conjecture, so know what you are doing! Using - rewriting, you are entering into the wilderness, where you are on - your own! - -Language --------- - -* `forall` / `∀` now parses like `λ`, i.e., the following parses now - [Issue [#1583](https://github.com/agda/agda/issues/1538)]: - - ```agda - ⊤ × ∀ (B : Set) → B → B - ``` - -* The underscore pattern `_` can now also stand for an inaccessible - pattern (dot pattern). This alleviates the need for writing `._`. - [Issue #[1605](https://github.com/agda/agda/issues/1605)] Instead of - - ```agda - transVOld : ∀{A : Set} (a b c : A) → a ≡ b → b ≡ c → a ≡ c - transVOld _ ._ ._ refl refl = refl - ``` - - one can now write - - ```agda - transVNew : ∀{A : Set} (a b c : A) → a ≡ b → b ≡ c → a ≡ c - transVNew _ _ _ refl refl = refl - ``` - - and let Agda decide where to put the dots. This was always possible - by using hidden arguments - - ```agda - transH : ∀{A : Set}{a b c : A} → a ≡ b → b ≡ c → a ≡ c - transH refl refl = refl - ``` - - which is now equivalent to - - ```agda - transHNew : ∀{A : Set}{a b c : A} → a ≡ b → b ≡ c → a ≡ c - transHNew {a = _}{b = _}{c = _} refl refl = refl - ``` - - Before, underscore `_` stood for an unnamed variable that could not - be instantiated by an inaccessible pattern. If one no wants to - prevent Agda from instantiating, one needs to use a variable name - other than underscore (however, in practice this situation seems - unlikely). - -Type checking -------------- - -* Polarity of phantom arguments to data and record types has - changed. [Issue [#1596](https://github.com/agda/agda/issues/1596)] - Polarity of size arguments is Nonvariant (both monotone and - antitone). Polarity of other arguments is Covariant (monotone). - Both were Invariant before (neither monotone nor antitone). - - The following example type-checks now: - - ```agda - open import Common.Size - - -- List should be monotone in both arguments - -- (even when `cons' is missing). - - data List (i : Size) (A : Set) : Set where - [] : List i A - - castLL : ∀{i A} → List i (List i A) → List ∞ (List ∞ A) - castLL x = x - - -- Stream should be antitone in the first and monotone in the second argument - -- (even with field `tail' missing). - - record Stream (i : Size) (A : Set) : Set where - coinductive - field - head : A - - castSS : ∀{i A} → Stream ∞ (Stream ∞ A) → Stream i (Stream i A) - castSS x = x - ``` - -* `SIZELT` lambdas must be consistent - [Issue [#1523](https://github.com/agda/agda/issues/1523), see Abel - and Pientka, ICFP 2013]. When lambda-abstracting over type (`Size< - size`) then `size` must be non-zero, for any valid instantiation of - size variables. - - - The good: - - ```agda - data Nat (i : Size) : Set where - zero : ∀ (j : Size< i) → Nat i - suc : ∀ (j : Size< i) → Nat j → Nat i - - {-# TERMINATING #-} - -- This definition is fine, the termination checker is too strict at the moment. - fix : ∀ {C : Size → Set} - → (∀ i → (∀ (j : Size< i) → Nat j -> C j) → Nat i → C i) - → ∀ i → Nat i → C i - fix t i (zero j) = t i (λ (k : Size< i) → fix t k) (zero j) - fix t i (suc j n) = t i (λ (k : Size< i) → fix t k) (suc j n) - ``` - - The `λ (k : Size< i)` is fine in both cases, as context - - ```agda - i : Size, j : Size< i - ``` - - guarantees that `i` is non-zero. - - - The bad: - - ```agda - record Stream {i : Size} (A : Set) : Set where - coinductive - constructor _∷ˢ_ - field - head : A - tail : ∀ {j : Size< i} → Stream {j} A - open Stream public - - _++ˢ_ : ∀ {i A} → List A → Stream {i} A → Stream {i} A - [] ++ˢ s = s - (a ∷ as) ++ˢ s = a ∷ˢ (as ++ˢ s) - ``` - - This fails, maybe unjustified, at - - ```agda - i : Size, s : Stream {i} A - ⊢ - a ∷ˢ (λ {j : Size< i} → as ++ˢ s) - ``` - - Fixed by defining the constructor by copattern matching: - - ```agda - record Stream {i : Size} (A : Set) : Set where - coinductive - field - head : A - tail : ∀ {j : Size< i} → Stream {j} A - open Stream public - - _∷ˢ_ : ∀ {i A} → A → Stream {i} A → Stream {↑ i} A - head (a ∷ˢ as) = a - tail (a ∷ˢ as) = as - - _++ˢ_ : ∀ {i A} → List A → Stream {i} A → Stream {i} A - [] ++ˢ s = s - (a ∷ as) ++ˢ s = a ∷ˢ (as ++ˢ s) - ``` - - - The ugly: - - ```agda - fix : ∀ {C : Size → Set} - → (∀ i → (∀ (j : Size< i) → C j) → C i) - → ∀ i → C i - fix t i = t i λ (j : Size< i) → fix t j - ``` - - For `i=0`, there is no such `j` at runtime, leading to looping - behavior. - -Interaction ------------ - -* Issue [#635](https://github.com/agda/agda/issues/635) has been - fixed. Case splitting does not spit out implicit record patterns - any more. - - ```agda - record Cont : Set₁ where - constructor _◃_ - field - Sh : Set - Pos : Sh → Set - - open Cont - - data W (C : Cont) : Set where - sup : (s : Sh C) (k : Pos C s → W C) → W C - - bogus : {C : Cont} → W C → Set - bogus w = {!w!} - ``` - - Case splitting on `w` yielded, since the fix of - Issue [#473](https://github.com/agda/agda/issues/473), - - ```agda - bogus {Sh ◃ Pos} (sup s k) = ? - ``` - - Now it gives, as expected, - - ```agda - bogus (sup s k) = ? - ``` - -Performance ------------ - -* As one result of the 21st Agda Implementor's Meeting (AIM XXI), - serialization of the standard library is 50% faster (time reduced by - a third), without using additional disk space for the interface - files. - - -Bug fixes ---------- - -Issues fixed (see [bug tracker](https://github.com/agda/agda/issues)): - -[#1546](https://github.com/agda/agda/issues/1546) (copattern matching -and with-clauses) - -[#1560](https://github.com/agda/agda/issues/1560) (positivity checker -inefficiency) - -[#1584](https://github.com/agda/agda/issues/1548) (let pattern with -trailing implicit) - -Release notes for Agda version 2.4.2.3 -====================================== - -Installation and infrastructure -------------------------------- - -* Added support for GHC 7.10.1. - -* Removed support for GHC 7.0.4. - -Language --------- - -* `_ `is no longer a valid name for a definition. The following fails - now: [Issue [#1465](https://github.com/agda/agda/issues/1465)] - - ```agda - postulate _ : Set - ``` - -* Typed bindings can now contain hiding information - [Issue [#1391](https://github.com/agda/agda/issues/1391)]. This - means you can now write - - ```agda - assoc : (xs {ys zs} : List A) → ((xs ++ ys) ++ zs) ≡ (xs ++ (ys ++ zs)) - ``` - - instead of the longer - - ```agda - assoc : (xs : List A) {ys zs : List A} → ... - ``` - - It also works with irrelevance - - ```agda - .(xs {ys zs} : List A) → ... - ``` - - but of course does not make sense if there is hiding information already. - Thus, this is (still) a parse error: - - ```agda - {xs {ys zs} : List A} → ... - ``` - -* The builtins for sized types no longer need accompanying postulates. - The BUILTIN pragmas for size stuff now also declare the identifiers - they bind to. - - ```agda - {-# BUILTIN SIZEUNIV SizeUniv #-} -- SizeUniv : SizeUniv - {-# BUILTIN SIZE Size #-} -- Size : SizeUniv - {-# BUILTIN SIZELT Size<_ #-} -- Size<_ : ..Size → SizeUniv - {-# BUILTIN SIZESUC ↑_ #-} -- ↑_ : Size → Size - {-# BUILTIN SIZEINF ∞ #-} -- ∞ : Size - ``` - - `Size` and `Size<` now live in the new universe `SizeUniv`. It is - forbidden to build function spaces in this universe, in order to - prevent the malicious assumption of a size predecessor - - ```agda - pred : (i : Size) → Size< i - ``` - - [Issue [#1428](https://github.com/agda/agda/issues/1428)]. - -* Unambiguous notations (coming from syntax declarations) that resolve - to ambiguous names are now parsed unambiguously - [Issue [#1194](https://github.com/agda/agda/issues/1194)]. - -* If only some instances of an overloaded name have a given associated - notation (coming from syntax declarations), then this name can only - be resolved to the given instances of the name, not to other - instances [Issue [#1194](https://github.com/agda/agda/issues/1194)]. - - Previously, if different instances of an overloaded name had - *different* associated notations, then none of the notations could - be used. Now all of them can be used. - - Note that notation identity does not only involve the right-hand - side of the syntax declaration. For instance, the following - notations are not seen as identical, because the implicit argument - names are different: - - ```agda - module A where - - data D : Set where - c : {x y : D} → D - - syntax c {x = a} {y = b} = a ∙ b - - module B where - - data D : Set where - c : {y x : D} → D - - syntax c {y = a} {x = b} = a ∙ b - ``` - -* If an overloaded operator is in scope with at least two distinct - fixities, then it gets the default fixity - [Issue [#1436](https://github.com/agda/agda/issues/1436)]. - - Similarly, if two or more identical notations for a given overloaded - name are in scope, and these notations do not all have the - same fixity, then they get the default fixity. - -Type checking -------------- - -* Functions of varying arity can now have with-clauses and use rewrite. - - Example: - - ```agda - NPred : Nat → Set - NPred 0 = Bool - NPred (suc n) = Nat → NPred n - - const : Bool → ∀{n} → NPred n - const b {0} = b - const b {suc n} m = const b {n} - - allOdd : ∀ n → NPred n - allOdd 0 = true - allOdd (suc n) m with even m - ... | true = const false - ... | false = allOdd n - ``` - -* Function defined by copattern matching can now have `with`-clauses - and use `rewrite`. - - Example: - - ```agda - {-# OPTIONS --copatterns #-} - - record Stream (A : Set) : Set where - coinductive - constructor delay - field - force : A × Stream A - open Stream - - map : ∀{A B} → (A → B) → Stream A → Stream B - force (map f s) with force s - ... | a , as = f a , map f as - - record Bisim {A B} (R : A → B → Set) (s : Stream A) (t : Stream B) : Set where - coinductive - constructor ~delay - field - ~force : let a , as = force s - b , bs = force t - in R a b × Bisim R as bs - open Bisim - - SEq : ∀{A} (s t : Stream A) → Set - SEq = Bisim (_≡_) - - -- Slightly weird definition of symmetry to demonstrate rewrite. - - ~sym' : ∀{A} {s t : Stream A} → SEq s t → SEq t s - ~force (~sym' {s = s} {t} p) with force s | force t | ~force p - ... | a , as | b , bs | r , q rewrite r = refl , ~sym' q - ``` - -* Instances can now be defined by copattern - matching. [Issue [#1413](https://github.com/agda/agda/issues/1413)] - The following example extends the one in - [Abel, Pientka, Thibodeau, Setzer, POPL 2013, Section 2.2]: - - ```agda - {-# OPTIONS --copatterns #-} - - -- The Monad type class - - record Monad (M : Set → Set) : Set1 where - field - return : {A : Set} → A → M A - _>>=_ : {A B : Set} → M A → (A → M B) → M B - open Monad {{...}} - - -- The State newtype - - record State (S A : Set) : Set where - field - runState : S → A × S - open State - - -- State is an instance of Monad - - instance - stateMonad : {S : Set} → Monad (State S) - runState (return {{stateMonad}} a ) s = a , s -- NEW - runState (_>>=_ {{stateMonad}} m k) s₀ = -- NEW - let a , s₁ = runState m s₀ - in runState (k a) s₁ - - -- stateMonad fulfills the monad laws - - leftId : {A B S : Set}(a : A)(k : A → State S B) → - (return a >>= k) ≡ k a - leftId a k = refl - - rightId : {A B S : Set}(m : State S A) → - (m >>= return) ≡ m - rightId m = refl - - assoc : {A B C S : Set}(m : State S A)(k : A → State S B)(l : B → State S C) → - ((m >>= k) >>= l) ≡ (m >>= λ a → k a >>= l) - assoc m k l = refl - ``` - -Emacs mode ----------- - -* The new menu option `Switch to another version of Agda` tries to do - what it says. - -* Changed feature: Interactively split result. - - [ This is as before: ] - Make-case (`C-c C-c`) with no variables given tries to split on the - result to introduce projection patterns. The hole needs to be of - record type, of course. - - ```agda - test : {A B : Set} (a : A) (b : B) → A × B - test a b = ? - ``` - - Result-splitting `?` will produce the new clauses: - - ```agda - proj₁ (test a b) = ? - proj₂ (test a b) = ? - ``` - - [ This has changed: ] - If hole is of function type, `make-case` will introduce only pattern - variables (as much as it can). - - ```agda - testFun : {A B : Set} (a : A) (b : B) → A × B - testFun = ? - ``` - - Result-splitting `?` will produce the new clause: - - ```agda - testFun a b = ? - ``` - - A second invocation of `make-case` will then introduce projection - patterns. - -Error messages --------------- - -* Agda now suggests corrections of misspelled options, e.g. - - ```agda - {-# OPTIONS - --dont-termination-check - --without-k - --senf-gurke - #-} - ``` - - Unrecognized options: - - ``` - --dont-termination-check (did you mean --no-termination-check ?) - --without-k (did you mean --without-K ?) - --senf-gurke - ``` - - Nothing close to `--senf-gurke`, I am afraid. - -Compiler backends ------------------ - -* The Epic backend has been removed - [Issue [#1481](https://github.com/agda/agda/issues/1481)]. - -Bug fixes ---------- - -* Fixed bug with `unquoteDecl` not working in instance blocks - [Issue [#1491](https://github.com/agda/agda/issues/1491)]. - -* Other issues fixed (see - [bug tracker](https://github.com/agda/agda/issues) - - [#1497](https://github.com/agda/agda/issues/1497) - - [#1500](https://github.com/agda/agda/issues/1500) - -Release notes for Agda version 2.4.2.2 -====================================== - -Bug fixes ---------- - -* Compilation on Windows fixed. - -* Other issues fixed (see - [bug tracker](https://github.com/agda/agda/issues)) - - [#1332](https://github.com/agda/agda/issues/1322) - - [#1353](https://github.com/agda/agda/issues/1353) - - [#1360](https://github.com/agda/agda/issues/1360) - - [#1366](https://github.com/agda/agda/issues/1366) - - [#1369](https://github.com/agda/agda/issues/1369) - -Release notes for Agda version 2.4.2.1 -====================================== - -Pragmas and options -------------------- - -* New pragma `{-# TERMINATING #-}` replacing - `{-# NO_TERMINATION_CHECK #-}` - - Complements the existing pragma `{-# NON_TERMINATING #-}`. Skips - termination check for the associated definitions and marks them as - terminating. Thus, it is a replacement for `{-# - NO_TERMINATION_CHECK #-}` with the same semantics. - - You can no longer use pragma `{-# NO_TERMINATION_CHECK #-}` to skip - the termination check, but must label your definitions as either - `{-# TERMINATING #-}` or `{-# NON_TERMINATING #-}` instead. - - Note: `{-# OPTION --no-termination-check #-}` labels all your - definitions as `{-# TERMINATING #-}`, putting you in the danger zone - of a loop in the type checker. - -Language --------- - -* Referring to a local variable shadowed by module opening is now an - error. Previous behavior was preferring the local over the imported - definitions. [Issue [#1266](https://github.com/agda/agda/issues/1266)] - - Note that module parameters are locals as well as variables bound by - λ, dependent function type, patterns, and let. - - Example: - - ```agda - module M where - A = Set1 - - test : (A : Set) → let open M in A - ``` - - The last `A` produces an error, since it could refer to the local - variable `A` or to the definition imported from module `M`. - -* `with` on a variable bound by a module telescope or a pattern of a - parent function is now forbidden. - [Issue [#1342](https://github.com/agda/agda/issues/1342)] - - ```agda - data Unit : Set where - unit : Unit - - id : (A : Set) → A → A - id A a = a - - module M (x : Unit) where - - dx : Unit → Unit - dx unit = x - - g : ∀ u → x ≡ dx u - g with x - g | unit = id (∀ u → unit ≡ dx u) ? - ``` - - Even though this code looks right, Agda complains about the type - expression `∀ u → unit ≡ dx u`. If you ask Agda what should go - there instead, it happily tells you that it wants `∀ u → unit ≡ dx - u`. In fact what you do not see and Agda will never show you is that - the two expressions actually differ in the invisible first argument - to `dx`, which is visible only outside module `M`. What Agda wants - is an invisible `unit` after `dx`, but all you can write is an - invisible `x` (which is inserted behind the scenes). - - To avoid those kinds of paradoxes, `with` is now outlawed on module - parameters. This should ensure that the invisible arguments are - always exactly the module parameters. - - Since a `where` block is desugared as module with pattern variables - of the parent clause as module parameters, the same strikes you for - uses of `with` on pattern variables of the parent function. - - ```agda - f : Unit → Unit - f x = unit - where - dx : Unit → Unit - dx unit = x - - g : ∀ u → x ≡ dx u - g with x - g | unit = id ((u : Unit) → unit ≡ dx u) ? - ``` - - The `with` on pattern variable `x` of the parent clause `f x = unit` - is outlawed now. - -Type checking -------------- - -* Termination check failure is now a proper error. - - We no longer continue type checking after termination check - failures. Use pragmas `{-# NON_TERMINATING #-}` and `{-# - NO_TERMINATION_CHECK #-}` near the offending definitions if you want - to do so. Or switch off the termination checker altogether with - `{-# OPTIONS --no-termination-check #-}` (at your own risk!). - -* (Since Agda 2.4.2): Termination checking `--without-K` restricts - structural descent to arguments ending in data types or `Size`. - Likewise, guardedness is only tracked when result type is data or - record type. - - ```agda - mutual - data WOne : Set where wrap : FOne → WOne - FOne = ⊥ → WOne - - noo : (X : Set) → (WOne ≡ X) → X → ⊥ - noo .WOne refl (wrap f) = noo FOne iso f - ``` - - `noo` is rejected since at type `X` the structural descent - `f < wrap f` is discounted `--without-K`. - - ```agda - data Pandora : Set where - C : ∞ ⊥ → Pandora - - loop : (A : Set) → A ≡ Pandora → A - loop .Pandora refl = C (♯ (loop ⊥ foo)) - ``` - - `loop` is rejected since guardedness is not tracked at type `A` - `--without-K`. - - See issues [#1023](https://github.com/agda/agda/issues/1023), - [#1264](https://github.com/agda/agda/issues/1264), - [#1292](https://github.com/agda/agda/issues/1292). - -Termination checking --------------------- - -* The termination checker can now recognize simple subterms in dot - patterns. - - ```agda - data Subst : (d : Nat) → Set where - c₁ : ∀ {d} → Subst d → Subst d - c₂ : ∀ {d₁ d₂} → Subst d₁ → Subst d₂ → Subst (suc d₁ + d₂) - - postulate - comp : ∀ {d₁ d₂} → Subst d₁ → Subst d₂ → Subst (d₁ + d₂) - - lookup : ∀ d → Nat → Subst d → Set₁ - lookup d zero (c₁ ρ) = Set - lookup d (suc v) (c₁ ρ) = lookup d v ρ - lookup .(suc d₁ + d₂) v (c₂ {d₁} {d₂} ρ σ) = lookup (d₁ + d₂) v (comp ρ σ) - ``` - - The dot pattern here is actually normalized, so it is - - ```agda - suc (d₁ + d₂) - ``` - - and the corresponding recursive call argument is `(d₁ + d₂)`. In - such simple cases, Agda can now recognize that the pattern is - constructor applied to call argument, which is valid descent. - - Note however, that Agda only looks for syntactic equality when - identifying subterms, since it is not allowed to normalize terms on - the rhs during termination checking. - - Actually writing the dot pattern has no effect, this works as well, - and looks pretty magical... ;-) - - ```agda - hidden : ∀{d} → Nat → Subst d → Set₁ - hidden zero (c₁ ρ) = Set - hidden (suc v) (c₁ ρ) = hidden v ρ - hidden v (c₂ ρ σ) = hidden v (comp ρ σ) - ``` - -Tools ------ - -### LaTeX-backend - -* Fixed the issue of identifiers containing operators being typeset with - excessive math spacing. - -Bug fixes ---------- - -* Issue [#1194](https://github.com/agda/agda/issues/1194) - -* Issue [#836](https://github.com/agda/agda/issues/836): Fields and - constructors can be qualified by the record/data *type* as well as - by their record/data module. This now works also for record/data - type imported from parametrized modules: - - ```agda - module M (_ : Set₁) where - - record R : Set₁ where - field - X : Set - - open M Set using (R) -- rather than using (module R) - - X : R → Set - X = R.X - ``` - -Release notes for Agda version 2.4.2 -==================================== - -Pragmas and options -------------------- - -* New option: `--with-K` - - This can be used to override a global `--without-K` in a file, by - adding a pragma `{-# OPTIONS --with-K #-}`. - -* New pragma `{-# NON_TERMINATING #-}` - - This is a safer version of `NO_TERMINATION_CHECK` which doesn't - treat the affected functions as terminating. This means that - `NON_TERMINATING` functions do not reduce during type checking. They - do reduce at run-time and when invoking `C-c C-n` at top-level (but - not in a hole). - -Language --------- - -* Instance search is now more efficient and recursive (see - Issue [#938](https://github.com/agda/agda/issues/938)) (but without - termination check yet). - - A new keyword `instance` has been introduced (in the style of - `abstract` and `private`) which must now be used for every - definition/postulate that has to be taken into account during - instance resolution. For example: - - ```agda - record RawMonoid (A : Set) : Set where - field - nil : A - _++_ : A -> A -> A - - open RawMonoid {{...}} - - instance - rawMonoidList : {A : Set} -> RawMonoid (List A) - rawMonoidList = record { nil = []; _++_ = List._++_ } - - rawMonoidMaybe : {A : Set} {{m : RawMonoid A}} -> RawMonoid (Maybe A) - rawMonoidMaybe {A} = record { nil = nothing ; _++_ = catMaybe } - where - catMaybe : Maybe A -> Maybe A -> Maybe A - catMaybe nothing mb = mb - catMaybe ma nothing = ma - catMaybe (just a) (just b) = just (a ++ b) - ``` - - Moreover, each type of an instance must end in (something that reduces - to) a named type (e.g. a record, a datatype or a postulate). This - allows us to build a simple index structure - - ``` - data/record name --> possible instances - ``` - - that speeds up instance search. - - Instance search takes into account all local bindings and all global - `instance` bindings and the search is recursive. For instance, - searching for - - ```agda - ? : RawMonoid (Maybe (List A)) - ``` - - will consider the candidates {`rawMonoidList`, `rawMonoidMaybe`}, fail to - unify the first one, succeeding with the second one - - ```agda - ? = rawMonoidMaybe {A = List A} {{m = ?m}} : RawMonoid (Maybe (List A)) - ``` - - and continue with goal - - ```agda - ?m : RawMonoid (List A) - ``` - - This will then find - - ```agda - ?m = rawMonoidList {A = A} - ``` - - and putting together we have the solution. - - Be careful that there is no termination check for now, you can - easily make Agda loop by declaring the identity function as an - instance. But it shouldn’t be possible to make Agda loop by only - declaring structurally recursive instances (whatever that means). - - Additionally: - - - Uniqueness of instances is up to definitional equality (see - Issue [#899](https://github.com/agda/agda/issues/899)). - - - Instances of the following form are allowed: - - ```agda - EqSigma : {A : Set} {B : A → Set} {{EqA : Eq A}} - {{EqB : {a : A} → Eq (B a)}} - → Eq (Σ A B) - ``` - - When searching recursively for an instance of type `{a : A} → Eq - (B a)`, a lambda will automatically be introduced and instance - search will search for something of type `Eq (B a)` in the context - extended by `a : A`. When searching for an instance, the `a` - argument does not have to be implicit, but in the definition of - `EqSigma`, instance search will only be able to use `EqB` if `a` - is implicit. - - - There is no longer any attempt to solve irrelevant metas by instance - search. - - - Constructors of records and datatypes are automatically added to the - instance table. - -* You can now use `quote` in patterns. - - For instance, here is a function that unquotes a (closed) natural - number term. - - ```agda - unquoteNat : Term → Maybe Nat - unquoteNat (con (quote Nat.zero) []) = just zero - unquoteNat (con (quote Nat.suc) (arg _ n ∷ [])) = fmap suc (unquoteNat n) - unquoteNat _ = nothing - ``` - -* The builtin constructors `AGDATERMUNSUPPORTED` and - `AGDASORTUNSUPPORTED` are now translated to meta variables when - unquoting. - -* New syntactic sugar `tactic e` and `tactic e | e1 | .. | en`. - - It desugars as follows and makes it less unwieldy to call - reflection-based tactics. - - ```agda - tactic e --> quoteGoal g in unquote (e g) - tactic e | e1 | .. | en --> quoteGoal g in unquote (e g) e1 .. en - ``` - - Note that in the second form the tactic function should generate a - function from a number of new subgoals to the original goal. The - type of `e` should be `Term -> Term` in both cases. - -* New reflection builtins for literals. - - The term data type `AGDATERM` now needs an additional constructor - `AGDATERMLIT` taking a reflected literal defined as follows (with - appropriate builtin bindings for the types `Nat`, `Float`, etc). - - ```agda - data Literal : Set where - nat : Nat → Literal - float : Float → Literal - char : Char → Literal - string : String → Literal - qname : QName → Literal - - {-# BUILTIN AGDALITERAL Literal #-} - {-# BUILTIN AGDALITNAT nat #-} - {-# BUILTIN AGDALITFLOAT float #-} - {-# BUILTIN AGDALITCHAR char #-} - {-# BUILTIN AGDALITSTRING string #-} - {-# BUILTIN AGDALITQNAME qname #-} - ``` - - When quoting (`quoteGoal` or `quoteTerm`) literals will be mapped to - the `AGDATERMLIT` constructor. Previously natural number literals - were quoted to `suc`/`zero` application and other literals were - quoted to `AGDATERMUNSUPPORTED`. - -* New reflection builtins for function definitions. - - `AGDAFUNDEF` should now map to a data type defined as follows - - (with - ```agda - {-# BUILTIN QNAME QName #-} - {-# BUILTIN ARG Arg #-} - {-# BUILTIN AGDATERM Term #-} - {-# BUILTIN AGDATYPE Type #-} - {-# BUILTIN AGDALITERAL Literal #-} - ``` - ). - - ```agda - data Pattern : Set where - con : QName → List (Arg Pattern) → Pattern - dot : Pattern - var : Pattern - lit : Literal → Pattern - proj : QName → Pattern - absurd : Pattern - - {-# BUILTIN AGDAPATTERN Pattern #-} - {-# BUILTIN AGDAPATCON con #-} - {-# BUILTIN AGDAPATDOT dot #-} - {-# BUILTIN AGDAPATVAR var #-} - {-# BUILTIN AGDAPATLIT lit #-} - {-# BUILTIN AGDAPATPROJ proj #-} - {-# BUILTIN AGDAPATABSURD absurd #-} - - data Clause : Set where - clause : List (Arg Pattern) → Term → Clause - absurd-clause : List (Arg Pattern) → Clause - - {-# BUILTIN AGDACLAUSE Clause #-} - {-# BUILTIN AGDACLAUSECLAUSE clause #-} - {-# BUILTIN AGDACLAUSEABSURD absurd-clause #-} - - data FunDef : Set where - fun-def : Type → List Clause → FunDef - - {-# BUILTIN AGDAFUNDEF FunDef #-} - {-# BUILTIN AGDAFUNDEFCON fun-def #-} - ``` - -* New reflection builtins for extended (pattern-matching) lambda. - - The `AGDATERM` data type has been augmented with a constructor - - ```agda - AGDATERMEXTLAM : List AGDACLAUSE → List (ARG AGDATERM) → AGDATERM - ``` - - Absurd lambdas (`λ ()`) are quoted to extended lambdas with an - absurd clause. - -* Unquoting declarations. - - You can now define (recursive) functions by reflection using the new - `unquoteDecl` declaration - - ```agda - unquoteDecl x = e - ``` - - Here e should have type `AGDAFUNDEF` and evaluate to a closed - value. This value is then spliced in as the definition of `x`. In - the body `e`, `x` has type `QNAME` which lets you splice in - recursive definitions. - - Standard modifiers, such as fixity declarations, can be applied to `x` as - expected. - -* Quoted levels - - Universe levels are now quoted properly instead of being quoted to - `AGDASORTUNSUPPORTED`. `Setω` still gets an unsupported sort, - however. - -* Module applicants can now be operator applications. - - Example: - - ```agda - postulate - [_] : A -> B - - module M (b : B) where - - module N (a : A) = M [ a ] - ``` - - [See Issue [#1245](https://github.com/agda/agda/issues/1245)] - -* Minor change in module application - semantics. [Issue [#892](https://github.com/agda/agda/issues/892)] - - Previously re-exported functions were not redefined when - instantiating a module. For instance - - ```agda - module A where f = ... - module B (X : Set) where - open A public - module C = B Nat - ``` - - In this example `C.f` would be an alias for `A.f`, so if both `A` - and `C` were opened `f` would not be ambiguous. However, this - behaviour is not correct when `A` and `B` share some module - parameters - (Issue [#892](https://github.com/agda/agda/issues/892)). To fix this - `C` now defines its own copy of `f` (which evaluates to `A.f`), - which means that opening `A` and `C` results in an ambiguous `f`. - -Type checking -------------- - -* Recursive records need to be declared as either `inductive` or - `coinductive`. `inductive` is no longer default for recursive - records. Examples: - - ```agda - record _×_ (A B : Set) : Set where - constructor _,_ - field - fst : A - snd : B - - record Tree (A : Set) : Set where - inductive - constructor tree - field - elem : A - subtrees : List (Tree A) - - record Stream (A : Set) : Set where - coinductive - constructor _::_ - field - head : A - tail : Stream A - ``` - - If you are using old-style (musical) coinduction, a record may have - to be declared as inductive, paradoxically. - - ```agda - record Stream (A : Set) : Set where - inductive -- YES, THIS IS INTENDED ! - constructor _∷_ - field - head : A - tail : ∞ (Stream A) - ``` - - This is because the "coinduction" happens in the use of `∞` and not - in the use of `record`. - -Tools ------ - -### Emacs mode - -* A new menu option `Display` can be used to display the version of - the running Agda process. - -### LaTeX-backend - -* New experimental option `references` has been added. When specified, - i.e.: - - ```latex - \usepackage[references]{agda} - ``` - - a new command called `\AgdaRef` is provided, which lets you - reference previously typeset commands, e.g.: - - Let us postulate `\AgdaRef{apa}`. - - ```agda - \begin{code} - postulate - apa : Set - \end{code} - ``` - - Above `apa` will be typeset (highlighted) the same in the text as in - the code, provided that the LaTeX output is post-processed using - `src/data/postprocess-latex.pl`, e.g.: - - ``` - cp $(dirname $(dirname $(agda-mode locate)))/postprocess-latex.pl . - agda -i. --latex Example.lagda - cd latex/ - perl ../postprocess-latex.pl Example.tex > Example.processed - mv Example.processed Example.tex - xelatex Example.tex - ``` - - Mix-fix and Unicode should work as expected (Unicode requires - XeLaTeX/LuaLaTeX), but there are limitations: - - - Overloading identifiers should be avoided, if multiples exist - `\AgdaRef` will typeset according to the first it finds. - - - Only the current module is used, should you need to reference - identifiers in other modules then you need to specify which other - module manually, i.e. `\AgdaRef[module]{identifier}`. - -Release notes for Agda 2 version 2.4.0.2 -======================================== - -* The Agda input mode now supports alphabetical super and subscripts, - in addition to the numerical ones that were already present. - [Issue [#1240](https://github.com/agda/agda/issues/1240)] - -* New feature: Interactively split result. - - Make case (`C-c C-c`) with no variables given tries to split on the - result to introduce projection patterns. The hole needs to be of - record type, of course. - - ```agda - test : {A B : Set} (a : A) (b : B) → A × B - test a b = ? - ``` - - Result-splitting `?` will produce the new clauses: - - ```agda - proj₁ (test a b) = ? - proj₂ (test a b) = ? - ``` - - If hole is of function type ending in a record type, the necessary - pattern variables will be introduced before the split. Thus, the - same result can be obtained by starting from: - - ```agda - test : {A B : Set} (a : A) (b : B) → A × B - test = ? - ``` - -* The so far undocumented `ETA` pragma now throws an error if applied to - definitions that are not records. - - `ETA` can be used to force eta-equality at recursive record types, - for which eta is not enabled automatically by Agda. Here is such an - example: - - ```agda - mutual - data Colist (A : Set) : Set where - [] : Colist A - _∷_ : A → ∞Colist A → Colist A - - record ∞Colist (A : Set) : Set where - coinductive - constructor delay - field force : Colist A - - open ∞Colist - - {-# ETA ∞Colist #-} - - test : {A : Set} (x : ∞Colist A) → x ≡ delay (force x) - test x = refl - ``` - - Note: Unsafe use of `ETA` can make Agda loop, e.g. by triggering - infinite eta expansion! - -* Bugs fixed (see [bug tracker](https://github.com/agda/agda/issues)): - - [#1203](https://github.com/agda/agda/issues/1203) - - [#1205](https://github.com/agda/agda/issues/1205) - - [#1209](https://github.com/agda/agda/issues/1209) - - [#1213](https://github.com/agda/agda/issues/1213) - - [#1214](https://github.com/agda/agda/issues/1214) - - [#1216](https://github.com/agda/agda/issues/1216) - - [#1225](https://github.com/agda/agda/issues/1225) - - [#1226](https://github.com/agda/agda/issues/1226) - - [#1231](https://github.com/agda/agda/issues/1231) - - [#1233](https://github.com/agda/agda/issues/1233) - - [#1239](https://github.com/agda/agda/issues/1239) - - [#1241](https://github.com/agda/agda/issues/1241) - - [#1243](https://github.com/agda/agda/issues/1243) - -Release notes for Agda 2 version 2.4.0.1 -======================================== - -* The option `--compile-no-main` has been renamed to `--no-main`. - -* `COMPILED_DATA` pragmas can now be given for records. - -* Various bug fixes. - -Release notes for Agda 2 version 2.4.0 -====================================== - -Installation and infrastructure -------------------------------- - -* A new module called `Agda.Primitive` has been introduced. This - module is available to all users, even if the standard library is - not used. Currently the module contains level primitives and their - representation in Haskell when compiling with MAlonzo: - - ```agda - infixl 6 _⊔_ - - postulate - Level : Set - lzero : Level - lsuc : (ℓ : Level) → Level - _⊔_ : (ℓ₁ ℓ₂ : Level) → Level - - {-# COMPILED_TYPE Level () #-} - {-# COMPILED lzero () #-} - {-# COMPILED lsuc (\_ -> ()) #-} - {-# COMPILED _⊔_ (\_ _ -> ()) #-} - - {-# BUILTIN LEVEL Level #-} - {-# BUILTIN LEVELZERO lzero #-} - {-# BUILTIN LEVELSUC lsuc #-} - {-# BUILTIN LEVELMAX _⊔_ #-} - ``` - - To bring these declarations into scope you can use a declaration - like the following one: - - ```agda - open import Agda.Primitive using (Level; lzero; lsuc; _⊔_) - ``` - - The standard library reexports these primitives (using the names - `zero` and `suc` instead of `lzero` and `lsuc`) from the `Level` - module. - - Existing developments using universe polymorphism might now trigger - the following error message: - - ``` - Duplicate binding for built-in thing LEVEL, previous binding to - .Agda.Primitive.Level - ``` - - To fix this problem, please remove the duplicate bindings. - - Technical details (perhaps relevant to those who build Agda - packages): - - The include path now always contains a directory - `/lib/prim`, and this directory is supposed to contain a - subdirectory Agda containing a file `Primitive.agda`. - - The standard location of `` is system- and - installation-specific. E.g., in a Cabal `--user` installation of - Agda-2.3.4 on a standard single-ghc Linux system it would be - `$HOME/.cabal/share/Agda-2.3.4` or something similar. - - The location of the `` directory can be configured at - compile-time using Cabal flags (`--datadir` and `--datasubdir`). - The location can also be set at run-time, using the `Agda_datadir` - environment variable. - -Pragmas and options -------------------- - -* Pragma `NO_TERMINATION_CHECK` placed within a mutual block is now - applied to the whole mutual block (rather than being discarded - silently). Adding to the uses 1.-4. outlined in the release notes - for 2.3.2 we allow: - - 3a. Skipping an old-style mutual block: Somewhere within `mutual` - block before a type signature or first function clause. - - ```agda - mutual - {-# NO_TERMINATION_CHECK #-} - c : A - c = d - - d : A - d = c - ``` - -* New option `--no-pattern-matching` - - Disables all forms of pattern matching (for the current file). - You can still import files that use pattern matching. - -* New option `-v profile:7` - - Prints some stats on which phases Agda spends how much time. - (Number might not be very reliable, due to garbage collection - interruptions, and maybe due to laziness of Haskell.) - -* New option `--no-sized-types` - - Option `--sized-types` is now default. `--no-sized-types` will turn - off an extra (inexpensive) analysis on data types used for subtyping - of sized types. - -Language --------- - -* Experimental feature: `quoteContext` - - There is a new keyword `quoteContext` that gives users access to the - list of names in the current local context. For instance: - - ```agda - open import Data.Nat - open import Data.List - open import Reflection - - foo : ℕ → ℕ → ℕ - foo 0 m = 0 - foo (suc n) m = quoteContext xs in ? - ``` - - In the remaining goal, the list `xs` will consist of two names, `n` - and `m`, corresponding to the two local variables. At the moment it - is not possible to access let bound variables (this feature may be - added in the future). - -* Experimental feature: Varying arity. - Function clauses may now have different arity, e.g., - - ```agda - Sum : ℕ → Set - Sum 0 = ℕ - Sum (suc n) = ℕ → Sum n - - sum : (n : ℕ) → ℕ → Sum n - sum 0 acc = acc - sum (suc n) acc m = sum n (m + acc) - ``` - - or, - - ```agda - T : Bool → Set - T true = Bool - T false = Bool → Bool - - f : (b : Bool) → T b - f false true = false - f false false = true - f true = true - ``` - - This feature is experimental. Yet unsupported: - - Varying arity and `with`. - - - Compilation of functions with varying arity to Haskell, JS, or Epic. - -* Experimental feature: copatterns. (Activated with option `--copatterns`) - - We can now define a record by explaining what happens if you project - the record. For instance: - - ```agda - {-# OPTIONS --copatterns #-} - - record _×_ (A B : Set) : Set where - constructor _,_ - field - fst : A - snd : B - open _×_ - - pair : {A B : Set} → A → B → A × B - fst (pair a b) = a - snd (pair a b) = b - - swap : {A B : Set} → A × B → B × A - fst (swap p) = snd p - snd (swap p) = fst p - - swap3 : {A B C : Set} → A × (B × C) → C × (B × A) - fst (swap3 t) = snd (snd t) - fst (snd (swap3 t)) = fst (snd t) - snd (snd (swap3 t)) = fst t - ``` - - Taking a projection on the left hand side (lhs) is called a - projection pattern, applying to a pattern is called an application - pattern. (Alternative terms: projection/application copattern.) - - In the first example, the symbol `pair`, if applied to variable - patterns `a` and `b` and then projected via `fst`, reduces to - `a`. `pair` by itself does not reduce. - - A typical application are coinductive records such as streams: - - ```agda - record Stream (A : Set) : Set where - coinductive - field - head : A - tail : Stream A - open Stream - - repeat : {A : Set} (a : A) -> Stream A - head (repeat a) = a - tail (repeat a) = repeat a - ``` - - Again, `repeat a` by itself will not reduce, but you can take a - projection (head or tail) and then it will reduce to the respective - rhs. This way, we get the lazy reduction behavior necessary to - avoid looping corecursive programs. - - Application patterns do not need to be trivial (i.e., variable - patterns), if we mix with projection patterns. E.g., we can have - - ```agda - nats : Nat -> Stream Nat - head (nats zero) = zero - tail (nats zero) = nats zero - head (nats (suc x)) = x - tail (nats (suc x)) = nats x - ``` - - Here is an example (not involving coinduction) which demostrates - records with fields of function type: - - ```agda - -- The State monad - - record State (S A : Set) : Set where - constructor state - field - runState : S → A × S - open State - - -- The Monad type class - - record Monad (M : Set → Set) : Set1 where - constructor monad - field - return : {A : Set} → A → M A - _>>=_ : {A B : Set} → M A → (A → M B) → M B - - - -- State is an instance of Monad - -- Demonstrates the interleaving of projection and application patterns - - stateMonad : {S : Set} → Monad (State S) - runState (Monad.return stateMonad a ) s = a , s - runState (Monad._>>=_ stateMonad m k) s₀ = - let a , s₁ = runState m s₀ - in runState (k a) s₁ - - module MonadLawsForState {S : Set} where - - open Monad (stateMonad {S}) - - leftId : {A B : Set}(a : A)(k : A → State S B) → - (return a >>= k) ≡ k a - leftId a k = refl - - rightId : {A B : Set}(m : State S A) → - (m >>= return) ≡ m - rightId m = refl - - assoc : {A B C : Set}(m : State S A)(k : A → State S B)(l : B → State S C) → - ((m >>= k) >>= l) ≡ (m >>= λ a → (k a >>= l)) - assoc m k l = refl - ``` - - Copatterns are yet experimental and the following does not work: - - - Copatterns and `with` clauses. - - - Compilation of copatterns to Haskell, JS, or Epic. - - - Projections generated by - - ```agda - open R {{...}} - ``` - - are not handled properly on lhss yet. - - - Conversion checking is slower in the presence of copatterns, since - stuck definitions of record type do no longer count as neutral, - since they can become unstuck by applying a projection. Thus, - comparing two neutrals currently requires comparing all they - projections, which repeats a lot of work. - -* Top-level module no longer required. - - The top-level module can be omitted from an Agda file. The module - name is then inferred from the file name by dropping the path and - the `.agda` extension. So, a module defined in `/A/B/C.agda` would get - the name `C`. - - You can also suppress only the module name of the top-level module - by writing - - ```agda - module _ where - ``` - - This works also for parameterised modules. - -* Module parameters are now always hidden arguments in projections. - For instance: - - ```agda - module M (A : Set) where - - record Prod (B : Set) : Set where - constructor _,_ - field - fst : A - snd : B - open Prod public - - open M - ``` - - Now, the types of `fst` and `snd` are - - ```agda - fst : {A : Set}{B : Set} → Prod A B → A - snd : {A : Set}{B : Set} → Prod A B → B - ``` - - Until 2.3.2, they were - - ```agda - fst : (A : Set){B : Set} → Prod A B → A - snd : (A : Set){B : Set} → Prod A B → B - ``` - - This change is a step towards symmetry of constructors and projections. - (Constructors always took the module parameters as hidden arguments). - -* Telescoping lets: Local bindings are now accepted in telescopes - of modules, function types, and lambda-abstractions. - - The syntax of telescopes as been extended to support `let`: - - ```agda - id : (let ★ = Set) (A : ★) → A → A - id A x = x - ``` - - In particular one can now `open` modules inside telescopes: - - ```agda - module Star where - ★ : Set₁ - ★ = Set - - - module MEndo (let open Star) (A : ★) where - Endo : ★ - Endo = A → A - ``` - - Finally a shortcut is provided for opening modules: - - ```agda - module N (open Star) (A : ★) (open MEndo A) (f : Endo) where - ... - ``` - - The semantics of the latter is - - ```agda - module _ where - open Star - module _ (A : ★) where - open MEndo A - module N (f : Endo) where - ... - ``` - - The semantics of telescoping lets in function types and lambda - abstractions is just expanding them into ordinary lets. - -* More liberal left-hand sides in lets - [Issue [#1028](https://github.com/agda/agda/issues/1028)]: - - You can now write left-hand sides with arguments also for let - bindings without a type signature. For instance, - - ```agda - let f x = suc x in f zero - ``` - - Let bound functions still can't do pattern matching though. - -* Ambiguous names in patterns are now optimistically resolved in favor - of constructors. [Issue [#822](https://github.com/agda/agda/issues/822)] - In particular, the following succeeds now: - - ```agda - module M where - - data D : Set₁ where - [_] : Set → D - - postulate [_] : Set → Set - - open M - - Foo : _ → Set - Foo [ A ] = A - ``` - -* Anonymous `where`-modules are opened - public. [Issue [#848](https://github.com/agda/agda/issues/848)] - - ``` - - f args = rhs - module _ telescope where - body - - ``` - - means the following (not proper Agda code, since you cannot put a - module in-between clauses) - - ``` - - module _ {arg-telescope} telescope where - body - - f args = rhs - - ``` - - Example: - - ```agda - A : Set1 - A = B module _ where - B : Set1 - B = Set - - C : Set1 - C = B - ``` - -* Builtin `ZERO` and `SUC` have been merged with `NATURAL`. - - When binding the `NATURAL` builtin, `ZERO` and `SUC` are bound to - the appropriate constructors automatically. This means that instead - of writing - - ```agda - {-# BUILTIN NATURAL Nat #-} - {-# BUILTIN ZERO zero #-} - {-# BUILTIN SUC suc #-} - ``` - - you just write - - ```agda - {-# BUILTIN NATURAL Nat #-} - ``` - -* Pattern synonym can now have implicit - arguments. [Issue [#860](https://github.com/agda/agda/issues/860)] - - For example, - - ```agda - pattern tail=_ {x} xs = x ∷ xs - - len : ∀ {A} → List A → Nat - len [] = 0 - len (tail= xs) = 1 + len xs - ``` - -* Syntax declarations can now have implicit - arguments. [Issue [#400](https://github.com/agda/agda/issues/400)] - - For example - - ```agda - id : ∀ {a}{A : Set a} -> A -> A - id x = x - - syntax id {A} x = x ∈ A - ``` - -* Minor syntax changes - - - `-}` is now parsed as end-comment even if no comment was begun. As - a consequence, the following definition gives a parse error - - ```agda - f : {A- : Set} -> Set - f {A-} = A- - ``` - - because Agda now sees `ID(f) LBRACE ID(A) END-COMMENT`, and no - longer `ID(f) LBRACE ID(A-) RBRACE`. - - The rational is that the previous lexing was to context-sensitive, - attempting to comment-out `f` using `{-` and `-}` lead to a parse - error. - - - Fixities (binding strengths) can now be negative numbers as - well. [Issue [#1109](https://github.com/agda/agda/issues/1109)] - - ```agda - infix -1 _myop_ - ``` - - - Postulates are now allowed in mutual - blocks. [Issue [#977](https://github.com/agda/agda/issues/977)] - - - Empty where blocks are now - allowed. [Issue [#947](https://github.com/agda/agda/issues/947)] - - - Pattern synonyms are now allowed in parameterised - modules. [Issue [#941](https://github.com/agda/agda/issues/941)] - - - Empty hiding and renaming lists in module directives are now allowed. - - - Module directives `using`, `hiding`, `renaming` and `public` can - now appear in arbitrary order. Multiple - `using`/`hiding`/`renaming` directives are allowed, but you still - cannot have both using and `hiding` (because that doesn't make - sense). [Issue [#493](https://github.com/agda/agda/issues/493)] - -Goal and error display ----------------------- - -* The error message `Refuse to construct infinite term` has been - removed, instead one gets unsolved meta variables. Reason: the - error was thrown over-eagerly. - [Issue [#795](https://github.com/agda/agda/issues/795)] - -* If an interactive case split fails with message - - ``` - Since goal is solved, further case distinction is not supported; - try `Solve constraints' instead - ``` - - then the associated interaction meta is assigned to a solution. - Press `C-c C-=` (Show constraints) to view the solution and `C-c - C-s` (Solve constraints) to apply it. - [Issue [#289](https://github.com/agda/agda/issues/289)] - -Type checking -------------- - -* [ Issue [#376](https://github.com/agda/agda/issues/376) ] - Implemented expansion of bound record variables during meta - assignment. Now Agda can solve for metas X that are applied to - projected variables, e.g.: - - ```agda - X (fst z) (snd z) = z - - X (fst z) = fst z - ``` - - Technically, this is realized by substituting `(x , y)` for `z` with fresh - bound variables `x` and `y`. Here the full code for the examples: - - ```agda - record Sigma (A : Set)(B : A -> Set) : Set where - constructor _,_ - field - fst : A - snd : B fst - open Sigma - - test : (A : Set) (B : A -> Set) -> - let X : (x : A) (y : B x) -> Sigma A B - X = _ - in (z : Sigma A B) -> X (fst z) (snd z) ≡ z - test A B z = refl - - test' : (A : Set) (B : A -> Set) -> - let X : A -> A - X = _ - in (z : Sigma A B) -> X (fst z) ≡ fst z - test' A B z = refl - ``` - - The fresh bound variables are named `fst(z)` and `snd(z)` and can appear - in error messages, e.g.: - - ```agda - fail : (A : Set) (B : A -> Set) -> - let X : A -> Sigma A B - X = _ - in (z : Sigma A B) -> X (fst z) ≡ z - fail A B z = refl - ``` - - results in error: - - ``` - Cannot instantiate the metavariable _7 to solution fst(z) , snd(z) - since it contains the variable snd(z) which is not in scope of the - metavariable or irrelevant in the metavariable but relevant in the - solution - when checking that the expression refl has type _7 A B (fst z) ≡ z - ``` - -* Dependent record types and definitions by copatterns require - reduction with previous function clauses while checking the current - clause. [Issue [#907](https://github.com/agda/agda/issues/907)] - - For a simple example, consider - - ```agda - test : ∀ {A} → Σ Nat λ n → Vec A n - proj₁ test = zero - proj₂ test = [] - ``` - - For the second clause, the lhs and rhs are typed as - - ```agda - proj₂ test : Vec A (proj₁ test) - [] : Vec A zero - ``` - - In order for these types to match, we have to reduce the lhs type - with the first function clause. - - Note that termination checking comes after type checking, so be - careful to avoid non-termination! Otherwise, the type checker - might get into an infinite loop. - -* The implementation of the primitive `primTrustMe` has changed. It - now only reduces to `REFL` if the two arguments `x` and `y` have the - same computational normal form. Before, it reduced when `x` and `y` - were definitionally equal, which included type-directed equality - laws such as eta-equality. Yet because reduction is untyped, - calling conversion from reduction lead to Agda crashes - [Issue [#882](https://github.com/agda/agda/issues/882)]. - - The amended description of `primTrustMe` is (cf. release notes - for 2.2.6): - - ```agda - primTrustMe : {A : Set} {x y : A} → x ≡ y - ``` - - Here `_≡_` is the builtin equality (see BUILTIN hooks for equality, - above). - - If `x` and `y` have the same computational normal form, then - `primTrustMe {x = x} {y = y}` reduces to `refl`. - - A note on `primTrustMe`'s runtime behavior: The MAlonzo compiler - replaces all uses of `primTrustMe` with the `REFL` builtin, without - any check for definitional equality. Incorrect uses of `primTrustMe` - can potentially lead to segfaults or similar problems of the - compiled code. - -* Implicit patterns of record type are now only eta-expanded if there - is a record constructor. - [Issues [#473](https://github.com/agda/agda/issues/473), - [#635](https://github.com/agda/agda/issues/635)] - - ```agda - data D : Set where - d : D - - data P : D → Set where - p : P d - - record Rc : Set where - constructor c - field f : D - - works : {r : Rc} → P (Rc.f r) → Set - works p = D - ``` - - This works since the implicit pattern `r` is eta-expanded to `c x` - which allows the type of `p` to reduce to `P x` and `x` to be - unified with `d`. The corresponding explicit version is: - - ```agda - works' : (r : Rc) → P (Rc.f r) → Set - works' (c .d) p = D - ``` - - However, if the record constructor is removed, the same example will - fail: - - ```agda - record R : Set where - field f : D - - fails : {r : R} → P (R.f r) → Set - fails p = D - - -- d != R.f r of type D - -- when checking that the pattern p has type P (R.f r) - ``` - - The error is justified since there is no pattern we could write down - for `r`. It would have to look like - - ```agda - record { f = .d } - ``` - - but anonymous record patterns are not part of the language. - -* Absurd lambdas at different source locations are no longer - different. [Issue [#857](https://github.com/agda/agda/issues/857)] - In particular, the following code type-checks now: - - ```agda - absurd-equality : _≡_ {A = ⊥ → ⊥} (λ()) λ() - absurd-equality = refl - ``` - - Which is a good thing! - -* Printing of named implicit function types. - - When printing terms in a context with bound variables Agda renames - new bindings to avoid clashes with the previously bound names. For - instance, if `A` is in scope, the type `(A : Set) → A` is printed as - `(A₁ : Set) → A₁`. However, for implicit function types the name of - the binding matters, since it can be used when giving implicit - arguments. - - For this situation, the following new syntax has been introduced: - `{x = y : A} → B` is an implicit function type whose bound variable - (in scope in `B`) is `y`, but where the name of the argument is `x` - for the purposes of giving it explicitly. For instance, with `A` in - scope, the type `{A : Set} → A` is now printed as `{A = A₁ : Set} → - A₁`. - - This syntax is only used when printing and is currently not being parsed. - -* Changed the semantics of `--without-K`. - [Issue [#712](https://github.com/agda/agda/issues/712), - Issue [#865](https://github.com/agda/agda/issues/865), - Issue [#1025](https://github.com/agda/agda/issues/1025)] - - New specification of `--without-K`: - - When `--without-K` is enabled, the unification of indices for - pattern matching is restricted in two ways: - - 1. Reflexive equations of the form `x == x` are no longer solved, - instead Agda gives an error when such an equation is encountered. - - 2. When unifying two same-headed constructor forms `c us` and `c vs` - of type `D pars ixs`, the datatype indices `ixs` (but not the - parameters) have to be *self-unifiable*, i.e. unification of - `ixs` with itself should succeed positively. This is a nontrivial - requirement because of point 1. - - Examples: - - - The J rule is accepted. - - ```agda - J : {A : Set} (P : {x y : A} → x ≡ y → Set) → - (∀ x → P (refl x)) → - ∀ {x y} (x≡y : x ≡ y) → P x≡y - J P p (refl x) = p x - ```agda - - This definition is accepted since unification of `x` with `y` - doesn't require deletion or injectivity. - - - The K rule is rejected. - - ```agda - K : {A : Set} (P : {x : A} → x ≡ x → Set) → - (∀ x → P (refl {x = x})) → - ∀ {x} (x≡x : x ≡ x) → P x≡x - K P p refl = p _ - ``` - - Definition is rejected with the following error: - - ``` - Cannot eliminate reflexive equation x = x of type A because K has - been disabled. - when checking that the pattern refl has type x ≡ x - ``` - - - Symmetry of the new criterion. - - ```agda - test₁ : {k l m : ℕ} → k + l ≡ m → ℕ - test₁ refl = zero - - test₂ : {k l m : ℕ} → k ≡ l + m → ℕ - test₂ refl = zero - ``` - - Both versions are now accepted (previously only the first one was). - - - Handling of parameters. - - ```agda - cons-injective : {A : Set} (x y : A) → (x ∷ []) ≡ (y ∷ []) → x ≡ y - cons-injective x .x refl = refl - ``` - - Parameters are not unified, so they are ignored by the new criterion. - - - A larger example: antisymmetry of ≤. - - ```agda - data _≤_ : ℕ → ℕ → Set where - lz : (n : ℕ) → zero ≤ n - ls : (m n : ℕ) → m ≤ n → suc m ≤ suc n - - ≤-antisym : (m n : ℕ) → m ≤ n → n ≤ m → m ≡ n - ≤-antisym .zero .zero (lz .zero) (lz .zero) = refl - ≤-antisym .(suc m) .(suc n) (ls m n p) (ls .n .m q) = - cong suc (≤-antisym m n p q) - ``` - - - [ Issue [#1025](https://github.com/agda/agda/issues/1025) ] - - ```agda - postulate mySpace : Set - postulate myPoint : mySpace - - data Foo : myPoint ≡ myPoint → Set where - foo : Foo refl - - test : (i : foo ≡ foo) → i ≡ refl - test refl = {!!} - ``` - - When applying injectivity to the equation `foo ≡ foo` of type `Foo - refl`, it is checked that the index `refl` of type `myPoint ≡ - myPoint` is self-unifiable. The equation `refl ≡ refl` again - requires injectivity, so now the index `myPoint` is checked for - self-unifiability, hence the error: - - ``` - Cannot eliminate reflexive equation myPoint = myPoint of type - mySpace because K has been disabled. - when checking that the pattern refl has type foo ≡ foo - ``` - -Termination checking --------------------- - -* A buggy facility coined "matrix-shaped orders" that supported - uncurried functions (which take tuples of arguments instead of one - argument after another) has been removed from the termination - checker. [Issue [#787](https://github.com/agda/agda/issues/787)] - -* Definitions which fail the termination checker are not unfolded any - longer to avoid loops or stack overflows in Agda. However, the - termination checker for a mutual block is only invoked after - type-checking, so there can still be loops if you define a - non-terminating function. But termination checking now happens - before the other supplementary checks: positivity, polarity, - injectivity and projection-likeness. Note that with the pragma `{-# - NO_TERMINATION_CHECK #-}` you can make Agda treat any function as - terminating. - -* Termination checking of functions defined by `with` has been improved. - - Cases which previously required `--termination-depth` to pass the - termination checker (due to use of `with`) no longer need the - flag. For example - - ```agda - merge : List A → List A → List A - merge [] ys = ys - merge xs [] = xs - merge (x ∷ xs) (y ∷ ys) with x ≤ y - merge (x ∷ xs) (y ∷ ys) | false = y ∷ merge (x ∷ xs) ys - merge (x ∷ xs) (y ∷ ys) | true = x ∷ merge xs (y ∷ ys) - ``` - - This failed to termination check previously, since the `with` - expands to an auxiliary function `merge-aux`: - - ```agda - merge-aux x y xs ys false = y ∷ merge (x ∷ xs) ys - merge-aux x y xs ys true = x ∷ merge xs (y ∷ ys) - ``` - - This function makes a call to `merge` in which the size of one of - the arguments is increasing. To make this pass the termination - checker now inlines the definition of `merge-aux` before checking, - thus effectively termination checking the original source program. - - As a result of this transformation doing `with` on a variable no longer - preserves termination. For instance, this does not termination check: - - ```agda - bad : Nat → Nat - bad n with n - ... | zero = zero - ... | suc m = bad m - ``` - -* The performance of the termination checker has been improved. For - higher `--termination-depth` the improvement is significant. While - the default `--termination-depth` is still 1, checking with higher - `--termination-depth` should now be feasible. - -Compiler backends ------------------ - -* The MAlonzo compiler backend now has support for compiling modules - that are not full programs (i.e. don't have a main function). The - goal is that you can write part of a program in Agda and the rest in - Haskell, and invoke the Agda functions from the Haskell code. The - following features were added for this reason: - - - A new command-line option `--compile-no-main`: the command - - ``` - agda --compile-no-main Test.agda - ``` - - will compile `Test.agda` and all its dependencies to Haskell and - compile the resulting Haskell files with `--make`, but (unlike - `--compile`) not tell GHC to treat `Test.hs` as the main - module. This type of compilation can be invoked from Emacs by - customizing the `agda2-backend` variable to value `MAlonzoNoMain` and - then calling `C-c C-x C-c` as before. - - - A new pragma `COMPILED_EXPORT` was added as part of the MAlonzo - FFI. If we have an Agda file containing the following: - - ```agda - module A.B where - - test : SomeType - test = someImplementation - - {-# COMPILED_EXPORT test someHaskellId #-} - ``` - - then test will be compiled to a Haskell function called - `someHaskellId` in module `MAlonzo.Code.A.B` that can be invoked - from other Haskell code. Its type will be translated according to - the normal MAlonzo rules. - -Tools ------ - -### Emacs mode - -* A new goal command `Helper Function Type` (`C-c C-h`) has been added. - - If you write an application of an undefined function in a goal, the - `Helper Function Type` command will print the type that the function - needs to have in order for it to fit the goal. The type is also - added to the Emacs kill-ring and can be pasted into the buffer using - `C-y`. - - The application must be of the form `f args` where `f` is the name of the - helper function you want to create. The arguments can use all the normal - features like named implicits or instance arguments. - - Example: - - Here's a start on a naive reverse on vectors: - - ```agda - reverse : ∀ {A n} → Vec A n → Vec A n - reverse [] = [] - reverse (x ∷ xs) = {!snoc (reverse xs) x!} - ``` - - Calling `C-c C-h` in the goal prints - - ```agda - snoc : ∀ {A} {n} → Vec A n → A → Vec A (suc n) - ``` - -* A new command `Explain why a particular name is in scope` (`C-c - C-w`) has been added. - [Issue [#207](https://github.com/agda/agda/issues/207)] - - This command can be called from a goal or from the top-level and will as the - name suggests explain why a particular name is in scope. - - For each definition or module that the given name can refer to a trace is - printed of all open statements and module applications leading back to the - original definition of the name. - - For example, given - - ```agda - module A (X : Set₁) where - data Foo : Set where - mkFoo : Foo - module B (Y : Set₁) where - open A Y public - module C = B Set - open C - ``` - - Calling `C-c C-w` on `mkFoo` at the top-level prints - - ``` - mkFoo is in scope as - * a constructor Issue207.C._.Foo.mkFoo brought into scope by - - the opening of C at Issue207.agda:13,6-7 - - the application of B at Issue207.agda:11,12-13 - - the application of A at Issue207.agda:9,8-9 - - its definition at Issue207.agda:6,5-10 - ``` - - This command is useful if Agda complains about an ambiguous name and - you need to figure out how to hide the undesired interpretations. - -* Improvements to the `make case` command (`C-c C-c`) - - - One can now also split on hidden variables, using the name - (starting with `.`) with which they are printed. Use `C-c C-`, to - see all variables in context. - - - Concerning the printing of generated clauses: - - * Uses named implicit arguments to improve readability. - - * Picks explicit occurrences over implicit ones when there is a - choice of binding site for a variable. - - * Avoids binding variables in implicit positions by replacing dot - patterns that uses them by wildcards (`._`). - -* Key bindings for lots of "mathematical" characters (examples: 𝐴𝑨𝒜𝓐𝔄) - have been added to the Agda input method. Example: type - `\MiA\MIA\McA\MCA\MfA` to get 𝐴𝑨𝒜𝓐𝔄. - - Note: `\McB` does not exist in Unicode (as well as others in that style), - but the `\MC` (bold) alphabet is complete. - -* Key bindings for "blackboard bold" B (𝔹) and 0-9 (𝟘-𝟡) have been - added to the Agda input method (`\bb` and `\b[0-9]`). - -* Key bindings for controlling simplification/normalisation: - - Commands like `Goal type and context` (`C-c C-,`) could previously - be invoked in two ways. By default the output was normalised, but if - a prefix argument was used (for instance via `C-u C-c C-,`), then no - explicit normalisation was performed. Now there are three options: - - - By default (`C-c C-,`) the output is simplified. - - - If `C-u` is used exactly once (`C-u C-c C-,`), then the result is - neither (explicitly) normalised nor simplified. - - - If `C-u` is used twice (`C-u C-u C-c C-,`), then the result is - normalised. - -### LaTeX-backend - -* Two new color scheme options were added to `agda.sty`: - - `\usepackage[bw]{agda}`, which highlights in black and white; - `\usepackage[conor]{agda}`, which highlights using Conor's colors. - - The default (no options passed) is to use the standard colors. - -* If `agda.sty` cannot be found by the LateX environment, it is now - copied into the LateX output directory (`latex` by default) instead - of the working directory. This means that the commands needed to - produce a PDF now is - - ``` - agda --latex -i . .lagda - cd latex - pdflatex .tex - ``` - -* The LaTeX-backend has been made more tool agnostic, in particular - XeLaTeX and LuaLaTeX should now work. Here is a small example - (`test/LaTeXAndHTML/succeed/UnicodeInput.lagda`): - - ```latex - \documentclass{article} - \usepackage{agda} - \begin{document} - - \begin{code} - data αβγδεζθικλμνξρστυφχψω : Set₁ where - - postulate - →⇒⇛⇉⇄↦⇨↠⇀⇁ : Set - \end{code} - - \[ - ∀X [ ∅ ∉ X ⇒ ∃f:X ⟶ ⋃ X\ ∀A ∈ X (f(A) ∈ A) ] - \] - \end{document} - ``` - - Compiled as follows, it should produce a nice looking PDF (tested with - TeX Live 2012): - - ``` - agda --latex .lagda - cd latex - xelatex .tex (or lualatex .tex) - ``` - - If symbols are missing or XeLaTeX/LuaLaTeX complains about the font - missing, try setting a different font using: - - ```latex - \setmathfont{} - ``` - - Use the `fc-list` tool to list available fonts. - -* Add experimental support for hyperlinks to identifiers - - If the `hyperref` LateX package is loaded before the Agda package - and the links option is passed to the Agda package, then the Agda - package provides a function called `\AgdaTarget`. Identifiers which - have been declared targets, by the user, will become clickable - hyperlinks in the rest of the document. Here is a small example - (`test/LaTeXAndHTML/succeed/Links.lagda`): - - ```latex - \documentclass{article} - \usepackage{hyperref} - \usepackage[links]{agda} - \begin{document} - - \AgdaTarget{ℕ} - \AgdaTarget{zero} - \begin{code} - data ℕ : Set where - zero : ℕ - suc : ℕ → ℕ - \end{code} - - See next page for how to define \AgdaFunction{two} (doesn't turn into a - link because the target hasn't been defined yet). We could do it - manually though; \hyperlink{two}{\AgdaDatatype{two}}. - - \newpage - - \AgdaTarget{two} - \hypertarget{two}{} - \begin{code} - two : ℕ - two = suc (suc zero) - \end{code} - - \AgdaInductiveConstructor{zero} is of type - \AgdaDatatype{ℕ}. \AgdaInductiveConstructor{suc} has not been defined to - be a target so it doesn't turn into a link. - - \newpage - - Now that the target for \AgdaFunction{two} has been defined the link - works automatically. - - \begin{code} - data Bool : Set where - true false : Bool - \end{code} - - The AgdaTarget command takes a list as input, enabling several - targets to be specified as follows: - - \AgdaTarget{if, then, else, if\_then\_else\_} - \begin{code} - if_then_else_ : {A : Set} → Bool → A → A → A - if true then t else f = t - if false then t else f = f - \end{code} - - \newpage - - Mixfix identifier need their underscores escaped: - \AgdaFunction{if\_then\_else\_}. - - \end{document} - ``` - - The boarders around the links can be suppressed using hyperref's - hidelinks option: - - ```latex - \usepackage[hidelinks]{hyperref} - ``` - - Note that the current approach to links does not keep track of scoping - or types, and hence overloaded names might create links which point to - the wrong place. Therefore it is recommended to not overload names - when using the links option at the moment, this might get fixed in the - future. - -Release notes for Agda 2 version 2.3.2.2 -======================================== - -* Fixed a bug that sometimes made it tricky to use the Emacs mode on - Windows [Issue [#757](https://github.com/agda/agda/issues/757)]. - -* Made Agda build with newer versions of some libraries. - -* Fixed a bug that caused ambiguous parse error messages - [Issue [#147](https://github.com/agda/agda/issues/147)]. - -Release notes for Agda 2 version 2.3.2.1 -======================================== - -Installation ------------- - -* Made it possible to compile Agda with more recent versions of - hashable, QuickCheck and Win32. - -* Excluded mtl-2.1. - -Type checking -------------- - -* Fixed bug in the termination checker - (Issue [#754](https://github.com/agda/agda/issues/754)). - -Release notes for Agda 2 version 2.3.2 -====================================== - -Installation ------------- - -* The Agda-executable package has been removed. - - The executable is now provided as part of the Agda package. - -* The Emacs mode no longer depends on haskell-mode or GHCi. - -* Compilation of Emacs mode Lisp files. - - You can now compile the Emacs mode Lisp files by running `agda-mode - compile`. This command is run by `make install`. - - Compilation can, in some cases, give a noticeable speedup. - - WARNING: If you reinstall the Agda mode without recompiling the - Emacs Lisp files, then Emacs may continue using the old, compiled - files. - -Pragmas and options -------------------- - -* The `--without-K` check now reconstructs constructor parameters. - - New specification of `--without-K`: - - If the flag is activated, then Agda only accepts certain - case-splits. If the type of the variable to be split is - `D pars ixs`, where `D` is a data (or record) type, `pars` stands - for the parameters, and `ixs` the indices, then the following - requirements must be satisfied: - - - The indices `ixs` must be applications of constructors (or - literals) to distinct variables. Constructors are usually not - applied to parameters, but for the purposes of this check - constructor parameters are treated as other arguments. - - - These distinct variables must not be free in pars. - -* Irrelevant arguments are printed as `_` by default now. To turn on - printing of irrelevant arguments, use option - - ``` - --show-irrelevant - ``` - -* New: Pragma `NO_TERMINATION_CHECK` to switch off termination checker - for individual function definitions and mutual blocks. - - The pragma must precede a function definition or a mutual block. - Examples (see `test/Succeed/NoTerminationCheck.agda`): - - 1. Skipping a single definition: before type signature. - - ```agda - {-# NO_TERMINATION_CHECK #-} - a : A - a = a - ``` - - 2. Skipping a single definition: before first clause. - - ```agda - b : A - {-# NO_TERMINATION_CHECK #-} - b = b - ``` - - 3. Skipping an old-style mutual block: Before `mutual` keyword. - - ```agda - {-# NO_TERMINATION_CHECK #-} - mutual - c : A - c = d - - d : A - d = c - ``` - - 4. Skipping a new-style mutual block: Anywhere before a type - signature or first function clause in the block - - ```agda - i : A - j : A - - i = j - {-# NO_TERMINATION_CHECK #-} - j = i - ``` - - The pragma cannot be used in `--safe` mode. - -Language --------- - -* Let binding record patterns - - ```agda - record _×_ (A B : Set) : Set where - constructor _,_ - field - fst : A - snd : B - open _×_ - - let (x , (y , z)) = t - in u - ``` - - will now be interpreted as - - ```agda - let x = fst t - y = fst (snd t) - z = snd (snd t) - in u - ``` - - Note that the type of `t` needs to be inferable. If you need to - provide a type signature, you can write the following: - - ```agda - let a : ... - a = t - (x , (y , z)) = a - in u - ``` - -* Pattern synonyms - - A pattern synonym is a declaration that can be used on the left hand - side (when pattern matching) as well as the right hand side (in - expressions). For example: - - ```agda - pattern z = zero - pattern ss x = suc (suc x) - - f : ℕ -> ℕ - f z = z - f (suc z) = ss z - f (ss n) = n - ``` - - Pattern synonyms are implemented by substitution on the abstract - syntax, so definitions are scope-checked but not type-checked. They - are particularly useful for universe constructions. - -* Qualified mixfix operators - - It is now possible to use a qualified mixfix operator by qualifying - the first part of the name. For instance - - ```agda - import Data.Nat as Nat - import Data.Bool as Bool - - two = Bool.if true then 1 Nat.+ 1 else 0 - ``` - -* Sections [Issue [#735](https://github.com/agda/agda/issues/735)]. - Agda now parses anonymous modules as sections: - - ```agda - module _ {a} (A : Set a) where - - data List : Set a where - [] : List - _∷_ : (x : A) (xs : List) → List - - module _ {a} {A : Set a} where - - _++_ : List A → List A → List A - [] ++ ys = ys - (x ∷ xs) ++ ys = x ∷ (xs ++ ys) - - test : List Nat - test = (5 ∷ []) ++ (3 ∷ []) - ``` - - In general, now the syntax - - ```agda - module _ parameters where - declarations - ``` - - is accepted and has the same effect as - - ```agda - private - module M parameters where - declarations - open M public - ``` - - for a fresh name `M`. - -* Instantiating a module in an open import statement - [Issue [#481](https://github.com/agda/agda/issues/481)]. Now - accepted: - - ```agda - open import Path.Module args [using/hiding/renaming (...)] - ``` - - This only brings the imported identifiers from `Path.Module` into scope, - not the module itself! Consequently, the following is pointless, and raises - an error: - - ```agda - import Path.Module args [using/hiding/renaming (...)] - ``` - - You can give a private name `M` to the instantiated module via - - ```agda - import Path.Module args as M [using/hiding/renaming (...)] - open import Path.Module args as M [using/hiding/renaming (...)] - ``` - - Try to avoid `as` as part of the arguments. `as` is not a keyword; - the following can be legal, although slightly obfuscated Agda code: - - ```agda - open import as as as as as as - ``` - -* Implicit module parameters can be given by name. E.g. - - ```agda - open M {namedArg = bla} - ``` - - This feature has been introduced in Agda 2.3.0 already. - -* Multiple type signatures sharing a same type can now be written as a single - type signature. - - ```agda - one two : ℕ - one = suc zero - two = suc one - ``` - -Goal and error display ----------------------- - -* Meta-variables that were introduced by hidden argument `arg` are now - printed as `_arg_number` instead of just `_number`. - [Issue [#526](https://github.com/agda/agda/issues/526)] - -* Agda expands identifiers in anonymous modules when printing. Should - make some goals nicer to read. - [Issue [#721](https://github.com/agda/agda/issues/721)] - -* When a module identifier is ambiguous, Agda tells you if one of them - is a data type module. - [Issues [#318](https://github.com/agda/agda/issues/318), - [#705](https://github.com/agda/agda/issues/705)] - -Type checking -------------- - -* Improved coverage checker. The coverage checker splits on arguments - that have constructor or literal pattern, committing to the - left-most split that makes progress. Consider the lookup function - for vectors: - - ```agda - data Fin : Nat → Set where - zero : {n : Nat} → Fin (suc n) - suc : {n : Nat} → Fin n → Fin (suc n) - - data Vec (A : Set) : Nat → Set where - [] : Vec A zero - _∷_ : {n : Nat} → A → Vec A n → Vec A (suc n) - - _!!_ : {A : Set}{n : Nat} → Vec A n → Fin n → A - (x ∷ xs) !! zero = x - (x ∷ xs) !! suc i = xs !! i - ``` - - In Agda up to 2.3.0, this definition is rejected unless we add - an absurd clause - - ```agda - [] !! () - ``` - - This is because the coverage checker committed on splitting on the - vector argument, even though this inevitably lead to failed - coverage, because a case for the empty vector `[]` is missing. - - The improvement to the coverage checker consists on committing only - on splits that have a chance of covering, since all possible - constructor patterns are present. Thus, Agda will now split first - on the `Fin` argument, since cases for both `zero` and `suc` are - present. Then, it can split on the `Vec` argument, since the empty - vector is already ruled out by instantiating `n` to a `suc _`. - -* Instance arguments resolution will now consider candidates which - still expect hidden arguments. For example: - - ```agda - record Eq (A : Set) : Set where - field eq : A → A → Bool - - open Eq {{...}} - - eqFin : {n : ℕ} → Eq (Fin n) - eqFin = record { eq = primEqFin } - - testFin : Bool - testFin = eq fin1 fin2 - ``` - - The type-checker will now resolve the instance argument of the `eq` - function to `eqFin {_}`. This is only done for hidden arguments, not - instance arguments, so that the instance search stays non-recursive. - -* Constraint solving: Upgraded Miller patterns to record patterns. - [Issue [#456](https://github.com/agda/agda/issues/456)] - - Agda now solves meta-variables that are applied to record patterns. - A typical (but here, artificial) case is: - - ```agda - record Sigma (A : Set)(B : A -> Set) : Set where - constructor _,_ - field - fst : A - snd : B fst - - test : (A : Set)(B : A -> Set) -> - let X : Sigma A B -> Sigma A B - X = _ - in (x : A)(y : B x) -> X (x , y) ≡ (x , y) - test A B x y = refl - ``` - - This yields a constraint of the form - - ``` - _X A B (x , y) := t[x,y] - ``` - - (with `t[x,y] = (x, y)`) which is not a Miller pattern. - However, Agda now solves this as - - ``` - _X A B z := t[fst z,snd z]. - ``` - -* Changed: solving recursive constraints. - [Issue [#585](https://github.com/agda/agda/issues/585)] - - Until 2.3.0, Agda sometimes inferred values that did not pass the - termination checker later, or would even make Agda loop. To prevent - this, the occurs check now also looks into the definitions of the - current mutual block, to avoid constructing recursive solutions. As - a consequence, also terminating recursive solutions are no longer - found automatically. - - This effects a programming pattern where the recursively computed - type of a recursive function is left to Agda to solve. - - ```agda - mutual - - T : D -> Set - T pattern1 = _ - T pattern2 = _ - - f : (d : D) -> T d - f pattern1 = rhs1 - f pattern2 = rhs2 - ``` - - This might no longer work from now on. See examples - `test/Fail/Issue585*.agda`. - -* Less eager introduction of implicit parameters. - [Issue [#679](https://github.com/agda/agda/issues/679)] - - Until Agda 2.3.0, trailing hidden parameters were introduced eagerly - on the left hand side of a definition. For instance, one could not - write - - ```agda - test : {A : Set} -> Set - test = \ {A} -> A - ``` - - because internally, the hidden argument `{A : Set}` was added to the - left-hand side, yielding - - ```agda - test {_} = \ {A} -> A - ``` - - which raised a type error. Now, Agda only introduces the trailing - implicit parameters it has to, in order to maintain uniform function - arity. For instance, in - - ```agda - test : Bool -> {A B C : Set} -> Set - test true {A} = A - test false {B = B} = B - ``` - - Agda will introduce parameters `A` and `B` in all clauses, but not - `C`, resulting in - - ```agda - test : Bool -> {A B C : Set} -> Set - test true {A} {_} = A - test false {_} {B = B} = B - ``` - - Note that for checking `where`-clauses, still all hidden trailing - parameters are in scope. For instance: - - ```agda - id : {i : Level}{A : Set i} -> A -> A - id = myId - where myId : forall {A} -> A -> A - myId x = x - ``` - - To be able to fill in the meta variable `_1` in - - ```agda - myId : {A : Set _1} -> A -> A - ``` - - the hidden parameter `{i : Level}` needs to be in scope. - - As a result of this more lazy introduction of implicit parameters, - the following code now passes. - - ```agda - data Unit : Set where - unit : Unit - - T : Unit → Set - T unit = {u : Unit} → Unit - - test : (u : Unit) → T u - test unit with unit - ... | _ = λ {v} → v - ``` - - Before, Agda would eagerly introduce the hidden parameter `{v}` as - unnamed left-hand side parameter, leaving no way to refer to it. - - The related Issue [#655](https://github.com/agda/agda/issues/655) - has also been addressed. It is now possible to make `synonym' - definitions - - ``` - name = expression - ``` - - even when the type of expression begins with a hidden quantifier. - Simple example: - - ``` - id2 = id - ``` - - That resulted in unsolved metas until 2.3.0. - -* Agda detects unused arguments and ignores them during equality - checking. [Issue [#691](https://github.com/agda/agda/issues/691), - solves also Issue [#44](https://github.com/agda/agda/issues/44)] - - Agda's polarity checker now assigns 'Nonvariant' to arguments that - are not actually used (except for absurd matches). If `f`'s first - argument is Nonvariant, then `f x` is definitionally equal to `f y` - regardless of `x` and `y`. It is similar to irrelevance, but does - not require user annotation. - - For instance, unused module parameters do no longer get in the way: - - ```agda - module M (x : Bool) where - - not : Bool → Bool - not true = false - not false = true - - open M true - open M false renaming (not to not′) - - test : (y : Bool) → not y ≡ not′ y - test y = refl - ``` - - Matching against record or absurd patterns does not count as `use', - so we get some form of proof irrelevance: - - ```agda - data ⊥ : Set where - record ⊤ : Set where - constructor trivial - - data Bool : Set where - true false : Bool - - True : Bool → Set - True true = ⊤ - True false = ⊥ - - fun : (b : Bool) → True b → Bool - fun true trivial = true - fun false () - - test : (b : Bool) → (x y : True b) → fun b x ≡ fun b y - test b x y = refl - ``` - - More examples in `test/Succeed/NonvariantPolarity.agda`. - - Phantom arguments: Parameters of record and data types are considered - `used' even if they are not actually used. Consider: - - ```agda - False : Nat → Set - False zero = ⊥ - False (suc n) = False n - - module Invariant where - record Bla (n : Nat)(p : False n) : Set where - - module Nonvariant where - Bla : (n : Nat) → False n → Set - Bla n p = ⊤ - ``` - - Even though record `Bla` does not use its parameters `n` and `p`, - they are considered as used, allowing "phantom type" techniques. - - In contrast, the arguments of function `Bla` are recognized as - unused. The following code type-checks if we open `Invariant` but - leaves unsolved metas if we open `Nonvariant`. - - ```agda - drop-suc : {n : Nat}{p : False n} → Bla (suc n) p → Bla n p - drop-suc _ = _ - - bla : (n : Nat) → {p : False n} → Bla n p → ⊥ - bla zero {()} b - bla (suc n) b = bla n (drop-suc b) - ``` - - If `Bla` is considered invariant, the hidden argument in the - recursive call can be inferred to be `p`. If it is considered - non-variant, then `Bla n X = Bla n p` does not entail `X = p` and - the hidden argument remains unsolved. Since `bla` does not actually - use its hidden argument, its value is not important and it could be - searched for. Unfortunately, polarity analysis of `bla` happens - only after type checking, thus, the information that `bla` is - non-variant in `p` is not available yet when meta-variables are - solved. (See - `test/Fail/BrokenInferenceDueToNonvariantPolarity.agda`) - -* Agda now expands simple definitions (one clause, terminating) to - check whether a function is constructor - headed. [Issue [#747](https://github.com/agda/agda/issues/747)] For - instance, the following now also works: - - ```agda - MyPair : Set -> Set -> Set - MyPair A B = Pair A B - - Vec : Set -> Nat -> Set - Vec A zero = Unit - Vec A (suc n) = MyPair A (Vec A n) - ``` - - Here, `Unit` and `Pair` are data or record types. - -Compiler backends ------------------ - -* `-Werror` is now overridable. - - To enable compilation of Haskell modules containing warnings, the - `-Werror` flag for the MAlonzo backend has been made - overridable. If, for example, `--ghc-flag=-Wwarn` is passed when - compiling, one can get away with things like: - - ```agda - data PartialBool : Set where - true : PartialBool - - {-# COMPILED_DATA PartialBool Bool True #-} - ``` - - The default behavior remains as it used to be and rejects the above - program. - -Tools ------ - -### Emacs mode - -* Asynchronous Emacs mode. - - One can now use Emacs while a buffer is type-checked. If the buffer - is edited while the type-checker runs, then syntax highlighting will - not be updated when type-checking is complete. - -* Interactive syntax highlighting. - - The syntax highlighting is updated while a buffer is type-checked: - - - At first the buffer is highlighted in a somewhat crude way - (without go-to-definition information for overloaded - constructors). - - - If the highlighting level is "interactive", then the piece of code - that is currently being type-checked is highlighted as such. (The - default is "non-interactive".) - - - When a mutual block has been type-checked it is highlighted - properly (this highlighting includes warnings for potential - non-termination). - - The highlighting level can be controlled via the new configuration - variable `agda2-highlight-level`. - -* Multiple case-splits can now be performed in one go. - - Consider the following example: - - ```agda - _==_ : Bool → Bool → Bool - b₁ == b₂ = {!!} - ``` - - If you split on `b₁ b₂`, then you get the following code: - - ```agda - _==_ : Bool → Bool → Bool - true == true = {!!} - true == false = {!!} - false == true = {!!} - false == false = {!!} - ``` - - The order of the variables matters. Consider the following code: - - ```agda - lookup : ∀ {a n} {A : Set a} → Vec A n → Fin n → A - lookup xs i = {!!} - ``` - - If you split on `xs i`, then you get the following code: - - ```agda - lookup : ∀ {a n} {A : Set a} → Vec A n → Fin n → A - lookup [] () - lookup (x ∷ xs) zero = {!!} - lookup (x ∷ xs) (suc i) = {!!} - ``` - - However, if you split on `i xs`, then you get the following code - instead: - - ```agda - lookup : ∀ {a n} {A : Set a} → Vec A n → Fin n → A - lookup (x ∷ xs) zero = ? - lookup (x ∷ xs) (suc i) = ? - ``` - - This code is rejected by Agda 2.3.0, but accepted by 2.3.2 thanks - to improved coverage checking (see above). - -* The Emacs mode now presents information about which module is - currently being type-checked. - -* New global menu entry: `Information about the character at point`. - - If this entry is selected, then information about the character at - point is displayed, including (in many cases) information about how - to type the character. - -* Commenting/uncommenting the rest of the buffer. - - One can now comment or uncomment the rest of the buffer by typing - `C-c C-x M-;` or by selecting the menu entry `Comment/uncomment` the - rest of the buffer". - -* The Emacs mode now uses the Agda executable instead of GHCi. - - The `*ghci*` buffer has been renamed to `*agda2*`. - - A new configuration variable has been introduced: - `agda2-program-name`, the name of the Agda executable (by default - `agda`). - - The variable `agda2-ghci-options` has been replaced by - `agda2-program-args`: extra arguments given to the Agda executable - (by default `none`). - - If you want to limit Agda's memory consumption you can add some - arguments to `agda2-program-args`, for instance `+RTS -M1.5G -RTS`. - -* The Emacs mode no longer depends on haskell-mode. - - Users who have customised certain haskell-mode variables (such as - `haskell-ghci-program-args`) may want to update their configuration. - -### LaTeX-backend - -An experimental LaTeX-backend which does precise highlighting a la the -HTML-backend and code alignment a la lhs2TeX has been added. - -Here is a sample input literate Agda file: - - ```latex - \documentclass{article} - - \usepackage{agda} - - \begin{document} - - The following module declaration will be hidden in the output. - - \AgdaHide{ - \begin{code} - module M where - \end{code} - } - - Two or more spaces can be used to make the backend align stuff. - - \begin{code} - data ℕ : Set where - zero : ℕ - suc : ℕ → ℕ - - _+_ : ℕ → ℕ → ℕ - zero + n = n - suc m + n = suc (m + n) - \end{code} - - \end{document} - ``` - -To produce an output PDF issue the following commands: - - ``` - agda --latex -i . .lagda - pdflatex latex/.tex - ``` - -Only the top-most module is processed, like with lhs2tex and unlike -with the HTML-backend. If you want to process imported modules you -have to call `agda --latex` manually on each of those modules. - -There are still issues related to formatting, see the bug tracker for -more information: - - https://code.google.com/p/agda/issues/detail?id=697 - -The default `agda.sty` might therefore change in backwards-incompatible -ways, as work proceeds in trying to resolve those problems. - -Implemented features: - -* Two or more spaces can be used to force alignment of things, like - with lhs2tex. See example above. - -* The highlighting information produced by the type checker is used to - generate the output. For example, the data declaration in the - example above, produces: - - ```agda - \AgdaKeyword{data} \AgdaDatatype{ℕ} \AgdaSymbol{:} - \AgdaPrimitiveType{Set} \AgdaKeyword{where} - ``` - - These LaTeX commands are defined in `agda.sty` (which is imported by - `\usepackage{agda}`) and cause the highlighting. - -* The LaTeX-backend checks if `agda.sty` is found by the LaTeX - environment, if it isn't a default `agda.sty` is copied from Agda's - `data-dir` into the working directory (and thus made available to - the LaTeX environment). - - If the default `agda.sty` isn't satisfactory (colors, fonts, - spacing, etc) then the user can modify it and make put it somewhere - where the LaTeX environment can find it. Hopefully most aspects - should be modifiable via `agda.sty` rather than having to tweak the - implementation. - -* `--latex-dir` can be used to change the default output directory. - -Release notes for Agda 2 version 2.3.0 -====================================== - -Language --------- - -* New more liberal syntax for mutually recursive definitions. - - It is no longer necessary to use the `mutual` keyword to define - mutually recursive functions or datatypes. Instead, it is enough to - declare things before they are used. Instead of - - ```agda - mutual - f : A - f = a[f, g] - - g : B[f] - g = b[f, g] - ``` - - you can now write - - ```agda - f : A - g : B[f] - f = a[f, g] - g = b[f, g]. - ``` - - With the new style you have more freedom in choosing the order in - which things are type checked (previously type signatures were - always checked before definitions). Furthermore you can mix - arbitrary declarations, such as modules and postulates, with - mutually recursive definitions. - - For data types and records the following new syntax is used to - separate the declaration from the definition: - - ```agda - -- Declaration. - data Vec (A : Set) : Nat → Set -- Note the absence of 'where'. - - -- Definition. - data Vec A where - [] : Vec A zero - _::_ : {n : Nat} → A → Vec A n → Vec A (suc n) - - -- Declaration. - record Sigma (A : Set) (B : A → Set) : Set - - -- Definition. - record Sigma A B where - constructor _,_ - field fst : A - snd : B fst - ``` - - When making separated declarations/definitions private or abstract - you should attach the `private` keyword to the declaration and the - `abstract` keyword to the definition. For instance, a private, - abstract function can be defined as - - ```agda - private - f : A - abstract - f = e - ``` - - Finally it may be worth noting that the old style of mutually - recursive definitions is still supported (it basically desugars into - the new style). - -* Pattern matching lambdas. - - Anonymous pattern matching functions can be defined using the syntax - - ``` - \ { p11 .. p1n -> e1 ; ... ; pm1 .. pmn -> em } - ``` - - (where, as usual, `\` and `->` can be replaced by `λ` and - `→`). Internally this is translated into a function definition of - the following form: - - ``` - .extlam p11 .. p1n = e1 - ... - .extlam pm1 .. pmn = em - ``` - - This means that anonymous pattern matching functions are generative. - For instance, `refl` will not be accepted as an inhabitant of the type - - ```agda - (λ { true → true ; false → false }) ≡ - (λ { true → true ; false → false }), - ``` - - because this is equivalent to `extlam1 ≡ extlam2` for some distinct - fresh names `extlam1` and `extlam2`. - - Currently the `where` and `with` constructions are not allowed in - (the top-level clauses of) anonymous pattern matching functions. - - Examples: - - ```agda - and : Bool → Bool → Bool - and = λ { true x → x ; false _ → false } - - xor : Bool → Bool → Bool - xor = λ { true true → false - ; false false → false - ; _ _ → true - } - - fst : {A : Set} {B : A → Set} → Σ A B → A - fst = λ { (a , b) → a } - - snd : {A : Set} {B : A → Set} (p : Σ A B) → B (fst p) - snd = λ { (a , b) → b } - ``` - -* Record update syntax. - - Assume that we have a record type and a corresponding value: - - ```agda - record MyRecord : Set where - field - a b c : ℕ - - old : MyRecord - old = record { a = 1; b = 2; c = 3 } - ``` - - Then we can update (some of) the record value's fields in the - following way: - - ```agda - new : MyRecord - new = record old { a = 0; c = 5 } - ``` - - Here new normalises to `record { a = 0; b = 2; c = 5 }`. Any - expression yielding a value of type `MyRecord` can be used instead of - old. - - Record updating is not allowed to change types: the resulting value - must have the same type as the original one, including the record - parameters. Thus, the type of a record update can be inferred if the - type of the original record can be inferred. - - The record update syntax is expanded before type checking. When the - expression - - ```agda - record old { upd-fields } - ``` - - is checked against a record type `R`, it is expanded to - - ```agda - let r = old in record { new-fields }, - ``` - - where old is required to have type `R` and new-fields is defined as - follows: for each field `x` in `R`, - - - if `x = e` is contained in `upd-fields` then `x = e` is included in - `new-fields`, and otherwise - - - if `x` is an explicit field then `x = R.x r` is included in - `new-fields`, and - - - if `x` is an implicit or instance field, then it is omitted from - `new-fields`. - - (Instance arguments are explained below.) The reason for treating - implicit and instance fields specially is to allow code like the - following: - - ```agda - record R : Set where - field - {length} : ℕ - vec : Vec ℕ length - -- More fields… - - xs : R - xs = record { vec = 0 ∷ 1 ∷ 2 ∷ [] } - - ys = record xs { vec = 0 ∷ [] } - ``` - - Without the special treatment the last expression would need to - include a new binding for length (for instance `length = _`). - -* Record patterns which do not contain data type patterns, but which - do contain dot patterns, are no longer rejected. - -* When the `--without-K` flag is used literals are now treated as - constructors. - -* Under-applied functions can now reduce. - - Consider the following definition: - - ```agda - id : {A : Set} → A → A - id x = x - ``` - - Previously the expression `id` would not reduce. This has been - changed so that it now reduces to `λ x → x`. Usually this makes - little difference, but it can be important in conjunction with - `with`. See Issue [#365](https://github.com/agda/agda/issues/365) - for an example. - -* Unused AgdaLight legacy syntax `(x y : A; z v : B)` for telescopes - has been removed. - -### Universe polymorphism - -* Universe polymorphism is now enabled by default. Use - `--no-universe-polymorphism` to disable it. - -* Universe levels are no longer defined as a data type. - - The basic level combinators can be introduced in the following way: - - ```agda - postulate - Level : Set - zero : Level - suc : Level → Level - max : Level → Level → Level - - {-# BUILTIN LEVEL Level #-} - {-# BUILTIN LEVELZERO zero #-} - {-# BUILTIN LEVELSUC suc #-} - {-# BUILTIN LEVELMAX max #-} - ``` - -* The BUILTIN equality is now required to be universe-polymorphic. - -* `trustMe` is now universe-polymorphic. - -### Meta-variables and unification - -* Unsolved meta-variables are now frozen after every mutual block. - This means that they cannot be instantiated by subsequent code. For - instance, - - ```agda - one : Nat - one = _ - - bla : one ≡ suc zero - bla = refl - ``` - - leads to an error now, whereas previously it lead to the - instantiation of `_` with `suc zero`. If you want to make use of the - old behaviour, put the two definitions in a mutual block. - - All meta-variables are unfrozen during interactive editing, so that - the user can fill holes interactively. Note that type-checking of - interactively given terms is not perfect: Agda sometimes refuses to - load a file, even though no complaints were raised during the - interactive construction of the file. This is because certain checks - (for instance, positivity) are only invoked when a file is loaded. - -* Record types can now be inferred. - - If there is a unique known record type with fields matching the - fields in a record expression, then the type of the expression will - be inferred to be the record type applied to unknown parameters. - - If there is no known record type with the given fields the type - checker will give an error instead of producing lots of unsolved - meta-variables. - - Note that "known record type" refers to any record type in any - imported module, not just types which are in scope. - -* The occurrence checker distinguishes rigid and strongly rigid - occurrences [Reed, LFMTP 2009; Abel & Pientka, TLCA 2011]. - - The completeness checker now accepts the following code: - - ```agda - h : (n : Nat) → n ≡ suc n → Nat - h n () - ``` - - Internally this generates a constraint `_n = suc _n` where the - meta-variable `_n` occurs strongly rigidly, i.e. on a constructor - path from the root, in its own defining term tree. This is never - solvable. - - Weakly rigid recursive occurrences may have a solution [Jason Reed's - PhD thesis, page 106]: - - ```agda - test : (k : Nat) → - let X : (Nat → Nat) → Nat - X = _ - in - (f : Nat → Nat) → X f ≡ suc (f (X (λ x → k))) - test k f = refl - ``` - - The constraint `_X k f = suc (f (_X k (λ x → k)))` has the solution - `_X k f = suc (f (suc k))`, despite the recursive occurrence of - `_X`. Here `_X` is not strongly rigid, because it occurs under the - bound variable `f`. Previously Agda rejected this code; now it instead - complains about an unsolved meta-variable. - -* Equation constraints involving the same meta-variable in the head - now trigger pruning [Pientka, PhD, Sec. 3.1.2; Abel & Pientka, TLCA - 2011]. Example: - - ```agda - same : let X : A → A → A → A × A - X = _ - in {x y z : A} → X x y y ≡ (x , y) - × X x x y ≡ X x y y - same = refl , refl - ``` - - The second equation implies that `X` cannot depend on its second - argument. After pruning the first equation is linear and can be - solved. - -* Instance arguments. - - A new type of hidden function arguments has been added: instance - arguments. This new feature is based on influences from Scala's - implicits and Agda's existing implicit arguments. - - Plain implicit arguments are marked by single braces: `{…}`. Instance - arguments are instead marked by double braces: `{{…}}`. Example: - - ```agda - postulate - A : Set - B : A → Set - a : A - f : {{a : A}} → B a - ``` - - Instead of the double braces you can use the symbols `⦃` and `⦄`, - but these symbols must in many cases be surrounded by - whitespace. (If you are using Emacs and the Agda input method, then - you can conjure up the symbols by typing `\{{` and `\}}`, - respectively.) - - Instance arguments behave as ordinary implicit arguments, except for - one important aspect: resolution of arguments which are not provided - explicitly. For instance, consider the following code: - - ```agda - test = f - ``` - - Here Agda will notice that `f`'s instance argument was not provided - explicitly, and try to infer it. All definitions in scope at `f`'s - call site, as well as all variables in the context, are considered. - If exactly one of these names has the required type `A`, then the - instance argument will be instantiated to this name. - - This feature can be used as an alternative to Haskell type classes. - If we define - - ```agda - record Eq (A : Set) : Set where - field equal : A → A → Bool, - ``` - - then we can define the following projection: - - ```agda - equal : {A : Set} {{eq : Eq A}} → A → A → Bool - equal {{eq}} = Eq.equal eq - ``` - - Now consider the following expression: - - ```agda - equal false false ∨ equal 3 4 - ``` - - If the following `Eq` "instances" for `Bool` and `ℕ` are in scope, and no - others, then the expression is accepted: - - ```agda - eq-Bool : Eq Bool - eq-Bool = record { equal = … } - - eq-ℕ : Eq ℕ - eq-ℕ = record { equal = … } - ``` - - A shorthand notation is provided to avoid the need to define - projection functions manually: - - ```agda - module Eq-with-implicits = Eq {{...}} - ``` - - This notation creates a variant of `Eq`'s record module, where the - main `Eq` argument is an instance argument instead of an explicit one. - It is equivalent to the following definition: - - ```agda - module Eq-with-implicits {A : Set} {{eq : Eq A}} = Eq eq - ``` - - Note that the short-hand notation allows you to avoid naming the - "-with-implicits" module: - - ```agda - open Eq {{...}} - ``` - - Instance argument resolution is not recursive. As an example, - consider the following "parametrised instance": - - ```agda - eq-List : {A : Set} → Eq A → Eq (List A) - eq-List {A} eq = record { equal = eq-List-A } - where - eq-List-A : List A → List A → Bool - eq-List-A [] [] = true - eq-List-A (a ∷ as) (b ∷ bs) = equal a b ∧ eq-List-A as bs - eq-List-A _ _ = false - ``` - - Assume that the only `Eq` instances in scope are `eq-List` and - `eq-ℕ`. Then the following code does not type-check: - - ```agda - test = equal (1 ∷ 2 ∷ []) (3 ∷ 4 ∷ []) - ``` - - However, we can make the code work by constructing a suitable - instance manually: - - ```agda - test′ = equal (1 ∷ 2 ∷ []) (3 ∷ 4 ∷ []) - where eq-List-ℕ = eq-List eq-ℕ - ``` - - By restricting the "instance search" to be non-recursive we avoid - introducing a new, compile-time-only evaluation model to Agda. - - For more information about instance arguments, see Devriese & - Piessens [ICFP 2011]. Some examples are also available in the - examples/instance-arguments subdirectory of the Agda distribution. - -### Irrelevance - -* Dependent irrelevant function types. - - Some examples illustrating the syntax of dependent irrelevant - function types: - - ``` - .(x y : A) → B .{x y z : A} → B - ∀ x .y → B ∀ x .{y} {z} .v → B - ``` - - The declaration - - ``` - f : .(x : A) → B[x] - f x = t[x] - ``` - - requires that `x` is irrelevant both in `t[x]` and in `B[x]`. This - is possible if, for instance, `B[x] = B′ x`, with `B′ : .A → Set`. - - Dependent irrelevance allows us to define the eliminator for the - `Squash` type: - - ```agda - record Squash (A : Set) : Set where - constructor squash - field - .proof : A - - elim-Squash : {A : Set} (P : Squash A → Set) - (ih : .(a : A) → P (squash a)) → - (a⁻ : Squash A) → P a⁻ - elim-Squash P ih (squash a) = ih a - ``` - - Note that this would not type-check with - - ```agda - (ih : (a : A) -> P (squash a)). - ``` - -* Records with only irrelevant fields. - - The following now works: - - ```agda - record IsEquivalence {A : Set} (_≈_ : A → A → Set) : Set where - field - .refl : Reflexive _≈_ - .sym : Symmetric _≈_ - .trans : Transitive _≈_ - - record Setoid : Set₁ where - infix 4 _≈_ - field - Carrier : Set - _≈_ : Carrier → Carrier → Set - .isEquivalence : IsEquivalence _≈_ - - open IsEquivalence isEquivalence public - ``` - - Previously Agda complained about the application - `IsEquivalence isEquivalence`, because `isEquivalence` is irrelevant - and the `IsEquivalence` module expected a relevant argument. Now, - when record modules are generated for records consisting solely of - irrelevant arguments, the record parameter is made irrelevant: - - ```agda - module IsEquivalence {A : Set} {_≈_ : A → A → Set} - .(r : IsEquivalence {A = A} _≈_) where - … - ``` - -* Irrelevant things are no longer erased internally. This means that - they are printed as ordinary terms, not as `_` as before. - -* The new flag `--experimental-irrelevance` enables irrelevant - universe levels and matching on irrelevant data when only one - constructor is available. These features are very experimental and - likely to change or disappear. - -### Reflection - -* The reflection API has been extended to mirror features like - irrelevance, instance arguments and universe polymorphism, and to - give (limited) access to definitions. For completeness all the - builtins and primitives are listed below: - - ```agda - -- Names. - - postulate Name : Set - - {-# BUILTIN QNAME Name #-} - - primitive - -- Equality of names. - primQNameEquality : Name → Name → Bool - - -- Is the argument visible (explicit), hidden (implicit), or an - -- instance argument? - - data Visibility : Set where - visible hidden instance : Visibility - - {-# BUILTIN HIDING Visibility #-} - {-# BUILTIN VISIBLE visible #-} - {-# BUILTIN HIDDEN hidden #-} - {-# BUILTIN INSTANCE instance #-} - - -- Arguments can be relevant or irrelevant. - - data Relevance : Set where - relevant irrelevant : Relevance - - {-# BUILTIN RELEVANCE Relevance #-} - {-# BUILTIN RELEVANT relevant #-} - {-# BUILTIN IRRELEVANT irrelevant #-} - - -- Arguments. - - data Arg A : Set where - arg : (v : Visibility) (r : Relevance) (x : A) → Arg A - - {-# BUILTIN ARG Arg #-} - {-# BUILTIN ARGARG arg #-} - - -- Terms. - - mutual - data Term : Set where - -- Variable applied to arguments. - var : (x : ℕ) (args : List (Arg Term)) → Term - -- Constructor applied to arguments. - con : (c : Name) (args : List (Arg Term)) → Term - -- Identifier applied to arguments. - def : (f : Name) (args : List (Arg Term)) → Term - -- Different kinds of λ-abstraction. - lam : (v : Visibility) (t : Term) → Term - -- Pi-type. - pi : (t₁ : Arg Type) (t₂ : Type) → Term - -- A sort. - sort : Sort → Term - -- Anything else. - unknown : Term - - data Type : Set where - el : (s : Sort) (t : Term) → Type - - data Sort : Set where - -- A Set of a given (possibly neutral) level. - set : (t : Term) → Sort - -- A Set of a given concrete level. - lit : (n : ℕ) → Sort - -- Anything else. - unknown : Sort - - {-# BUILTIN AGDASORT Sort #-} - {-# BUILTIN AGDATYPE Type #-} - {-# BUILTIN AGDATERM Term #-} - {-# BUILTIN AGDATERMVAR var #-} - {-# BUILTIN AGDATERMCON con #-} - {-# BUILTIN AGDATERMDEF def #-} - {-# BUILTIN AGDATERMLAM lam #-} - {-# BUILTIN AGDATERMPI pi #-} - {-# BUILTIN AGDATERMSORT sort #-} - {-# BUILTIN AGDATERMUNSUPPORTED unknown #-} - {-# BUILTIN AGDATYPEEL el #-} - {-# BUILTIN AGDASORTSET set #-} - {-# BUILTIN AGDASORTLIT lit #-} - {-# BUILTIN AGDASORTUNSUPPORTED unknown #-} - - postulate - -- Function definition. - Function : Set - -- Data type definition. - Data-type : Set - -- Record type definition. - Record : Set - - {-# BUILTIN AGDAFUNDEF Function #-} - {-# BUILTIN AGDADATADEF Data-type #-} - {-# BUILTIN AGDARECORDDEF Record #-} - - -- Definitions. - - data Definition : Set where - function : Function → Definition - data-type : Data-type → Definition - record′ : Record → Definition - constructor′ : Definition - axiom : Definition - primitive′ : Definition - - {-# BUILTIN AGDADEFINITION Definition #-} - {-# BUILTIN AGDADEFINITIONFUNDEF function #-} - {-# BUILTIN AGDADEFINITIONDATADEF data-type #-} - {-# BUILTIN AGDADEFINITIONRECORDDEF record′ #-} - {-# BUILTIN AGDADEFINITIONDATACONSTRUCTOR constructor′ #-} - {-# BUILTIN AGDADEFINITIONPOSTULATE axiom #-} - {-# BUILTIN AGDADEFINITIONPRIMITIVE primitive′ #-} - - primitive - -- The type of the thing with the given name. - primQNameType : Name → Type - -- The definition of the thing with the given name. - primQNameDefinition : Name → Definition - -- The constructors of the given data type. - primDataConstructors : Data-type → List Name - ``` - - As an example the expression - - ```agda - primQNameType (quote zero) - ``` - - is definitionally equal to - - ```agda - el (lit 0) (def (quote ℕ) []) - ``` - - (if `zero` is a constructor of the data type `ℕ`). - -* New keyword: `unquote`. - - The construction `unquote t` converts a representation of an Agda term - to actual Agda code in the following way: - - 1. The argument `t` must have type `Term` (see the reflection API above). - - 2. The argument is normalised. - - 3. The entire construction is replaced by the normal form, which is - treated as syntax written by the user and type-checked in the - usual way. - - Examples: - - ```agda - test : unquote (def (quote ℕ) []) ≡ ℕ - test = refl - - id : (A : Set) → A → A - id = unquote (lam visible (lam visible (var 0 []))) - - id-ok : id ≡ (λ A (x : A) → x) - id-ok = refl - ``` - -* New keyword: `quoteTerm`. - - The construction `quoteTerm t` is similar to `quote n`, but whereas - `quote` is restricted to names `n`, `quoteTerm` accepts terms - `t`. The construction is handled in the following way: - - 1. The type of `t` is inferred. The term `t` must be type-correct. - - 2. The term `t` is normalised. - - 3. The construction is replaced by the Term representation (see the - reflection API above) of the normal form. Any unsolved metavariables - in the term are represented by the `unknown` term constructor. - - Examples: - - ```agda - test₁ : quoteTerm (λ {A : Set} (x : A) → x) ≡ - lam hidden (lam visible (var 0 [])) - test₁ = refl - - -- Local variables are represented as de Bruijn indices. - test₂ : (λ {A : Set} (x : A) → quoteTerm x) ≡ (λ x → var 0 []) - test₂ = refl - - -- Terms are normalised before being quoted. - test₃ : quoteTerm (0 + 0) ≡ con (quote zero) [] - test₃ = refl - ``` - -Compiler backends ------------------ - -### MAlonzo - -* The MAlonzo backend's FFI now handles universe polymorphism in a - better way. - - The translation of Agda types and kinds into Haskell now supports - universe-polymorphic postulates. The core changes are that the - translation of function types has been changed from - - ``` - T[[ Pi (x : A) B ]] = - if A has a Haskell kind then - forall x. () -> T[[ B ]] - else if x in fv B then - undef - else - T[[ A ]] -> T[[ B ]] - ``` - - into - - ``` - T[[ Pi (x : A) B ]] = - if x in fv B then - forall x. T[[ A ]] -> T[[ B ]] -- Note: T[[A]] not Unit. - else - T[[ A ]] -> T[[ B ]], - ``` - - and that the translation of constants (postulates, constructors and - literals) has been changed from - - ``` - T[[ k As ]] = - if COMPILED_TYPE k T then - T T[[ As ]] - else - undef - ``` - - into - - ``` - T[[ k As ]] = - if COMPILED_TYPE k T then - T T[[ As ]] - else if COMPILED k E then - () - else - undef. - ``` - - For instance, assuming a Haskell definition - - ```haskell - type AgdaIO a b = IO b, - ``` - - we can set up universe-polymorphic `IO` in the following way: - - ```agda - postulate - IO : ∀ {ℓ} → Set ℓ → Set ℓ - return : ∀ {a} {A : Set a} → A → IO A - _>>=_ : ∀ {a b} {A : Set a} {B : Set b} → - IO A → (A → IO B) → IO B - - {-# COMPILED_TYPE IO AgdaIO #-} - {-# COMPILED return (\_ _ -> return) #-} - {-# COMPILED _>>=_ (\_ _ _ _ -> (>>=)) #-} - ``` - - This is accepted because (assuming that the universe level type is - translated to the Haskell unit type `()`) - - ```haskell - (\_ _ -> return) - : forall a. () -> forall b. () -> b -> AgdaIO a b - = T [[ ∀ {a} {A : Set a} → A → IO A ]] - ``` - - and - - ```haskell - (\_ _ _ _ -> (>>=)) - : forall a. () -> forall b. () -> - forall c. () -> forall d. () -> - AgdaIO a c -> (c -> AgdaIO b d) -> AgdaIO b d - = T [[ ∀ {a b} {A : Set a} {B : Set b} → - IO A → (A → IO B) → IO B ]]. - ``` - -### Epic - -* New Epic backend pragma: `STATIC`. - - In the Epic backend, functions marked with the `STATIC` pragma will be - normalised before compilation. Example usage: - - ``` - {-# STATIC power #-} - - power : ℕ → ℕ → ℕ - power 0 x = 1 - power 1 x = x - power (suc n) x = power n x * x - ``` - - Occurrences of `power 4 x` will be replaced by `((x * x) * x) * x`. - -* Some new optimisations have been implemented in the Epic backend: - - - Removal of unused arguments. - - A worker/wrapper transformation is performed so that unused - arguments can be removed by Epic's inliner. For instance, the map - function is transformed in the following way: - - ```agda - map_wrap : (A B : Set) → (A → B) → List A → List B - map_wrap A B f xs = map_work f xs - - map_work f [] = [] - map_work f (x ∷ xs) = f x ∷ map_work f xs - ``` - - If `map_wrap` is inlined (which it will be in any saturated call), - then `A` and `B` disappear in the generated code. - - Unused arguments are found using abstract interpretation. The bodies - of all functions in a module are inspected to decide which variables - are used. The behaviour of postulates is approximated based on their - types. Consider `return`, for instance: - - ```agda - postulate return : {A : Set} → A → IO A - ``` - - The first argument of `return` can be removed, because it is of type - Set and thus cannot affect the outcome of a program at runtime. - - - Injection detection. - - At runtime many functions may turn out to be inefficient variants of - the identity function. This is especially true after forcing. - Injection detection replaces some of these functions with more - efficient versions. Example: - - ```agda - inject : {n : ℕ} → Fin n → Fin (1 + n) - inject {suc n} zero = zero - inject {suc n} (suc i) = suc (inject {n} i) - ``` - - Forcing removes the `Fin` constructors' `ℕ` arguments, so this - function is an inefficient identity function that can be replaced by - the following one: - - ```agda - inject {_} x = x - ``` - - To actually find this function, we make the induction hypothesis - that inject is an identity function in its second argument and look - at the branches of the function to decide if this holds. - - Injection detection also works over data type barriers. Example: - - ```agda - forget : {A : Set} {n : ℕ} → Vec A n → List A - forget [] = [] - forget (x ∷ xs) = x ∷ forget xs - ``` - - Given that the constructor tags (in the compiled Epic code) for - `Vec.[]` and `List.[]` are the same, and that the tags for `Vec._∷_` - and `List._∷_` are also the same, this is also an identity - function. We can hence replace the definition with the following - one: - - ```agda - forget {_} xs = xs - ``` - - To get this to apply as often as possible, constructor tags are - chosen *after* injection detection has been run, in a way to make as - many functions as possible injections. - - Constructor tags are chosen once per source file, so it may be - advantageous to define conversion functions like forget in the same - module as one of the data types. For instance, if `Vec.agda` imports - `List.agda`, then the forget function should be put in `Vec.agda` to - ensure that vectors and lists get the same tags (unless some other - injection function, which puts different constraints on the tags, is - prioritised). - - - Smashing. - - This optimisation finds types whose values are inferable at runtime: - - * A data type with only one constructor where all fields are - inferable is itself inferable. - - * `Set ℓ` is inferable (as it has no runtime representation). - - A function returning an inferable data type can be smashed, which - means that it is replaced by a function which simply returns the - inferred value. - - An important example of an inferable type is the usual propositional - equality type (`_≡_`). Any function returning a propositional - equality can simply return the reflexivity constructor directly - without computing anything. - - This optimisation makes more arguments unused. It also makes the - Epic code size smaller, which in turn speeds up compilation. - -### JavaScript - -* ECMAScript compiler backend. - - A new compiler backend is being implemented, targetting ECMAScript - (also known as JavaScript), with the goal of allowing Agda programs - to be run in browsers or other ECMAScript environments. - - The backend is still at an experimental stage: the core language is - implemented, but many features are still missing. - - The ECMAScript compiler can be invoked from the command line using - the flag `--js`: - - ``` - agda --js --compile-dir= .agda - ``` - - Each source `.agda` is compiled into an ECMAScript target - `/jAgda..js`. The compiler can also be - invoked using the Emacs mode (the variable `agda2-backend` controls - which backend is used). - - Note that ECMAScript is a strict rather than lazy language. Since - Agda programs are total, this should not impact program semantics, - but it may impact their space or time usage. - - ECMAScript does not support algebraic datatypes or pattern-matching. - These features are translated to a use of the visitor pattern. For - instance, the standard library's `List` data type and `null` - function are translated into the following code: - - ```javascript - exports["List"] = {}; - exports["List"]["[]"] = function (x0) { - return x0["[]"](); - }; - exports["List"]["_∷_"] = function (x0) { - return function (x1) { - return function (x2) { - return x2["_∷_"](x0, x1); - }; - }; - }; - - exports["null"] = function (x0) { - return function (x1) { - return function (x2) { - return x2({ - "[]": function () { - return jAgda_Data_Bool["Bool"]["true"]; - }, - "_∷_": function (x3, x4) { - return jAgda_Data_Bool["Bool"]["false"]; - } - }); - }; - }; - }; - ``` - - Agda records are translated to ECMAScript objects, preserving field - names. - - Top-level Agda modules are translated to ECMAScript modules, - following the `common.js` module specification. A top-level Agda - module `Foo.Bar` is translated to an ECMAScript module - `jAgda.Foo.Bar`. - - The ECMAScript compiler does not compile to Haskell, so the pragmas - related to the Haskell FFI (`IMPORT`, `COMPILED_DATA` and - `COMPILED`) are not used by the ECMAScript backend. Instead, there - is a `COMPILED_JS` pragma which may be applied to any - declaration. For postulates, primitives, functions and values, it - gives the ECMAScript code to be emitted by the compiler. For data - types, it gives a function which is applied to a value of that type, - and a visitor object. For instance, a binding of natural numbers to - ECMAScript integers (ignoring overflow errors) is: - - ```agda - data ℕ : Set where - zero : ℕ - suc : ℕ → ℕ - - {-# COMPILED_JS ℕ function (x,v) { - if (x < 1) { return v.zero(); } else { return v.suc(x-1); } - } #-} - {-# COMPILED_JS zero 0 #-} - {-# COMPILED_JS suc function (x) { return x+1; } #-} - - _+_ : ℕ → ℕ → ℕ - zero + n = n - suc m + n = suc (m + n) - - {-# COMPILED_JS _+_ function (x) { return function (y) { - return x+y; }; - } #-} - ``` - - To allow FFI code to be optimised, the ECMAScript in a `COMPILED_JS` - declaration is parsed, using a simple parser that recognises a pure - functional subset of ECMAScript, consisting of functions, function - applications, return, if-statements, if-expressions, - side-effect-free binary operators (no precedence, left associative), - side-effect-free prefix operators, objects (where all member names - are quoted), field accesses, and string and integer literals. - Modules may be imported using the require (``) syntax: any - impure code, or code outside the supported fragment, can be placed - in a module and imported. - -Tools ------ - -* New flag `--safe`, which can be used to type-check untrusted code. - - This flag disables postulates, `primTrustMe`, and "unsafe" OPTION - pragmas, some of which are known to make Agda inconsistent. - - Rejected pragmas: - - ``` - --allow-unsolved-metas - --experimental-irrelevance - --guardedness-preserving-type-construtors - --injective-type-constructors - --no-coverage-check - --no-positivity-check - --no-termination-check - --sized-types - --type-in-type - ``` - - Note that, at the moment, it is not possible to define the universe - level or coinduction primitives when `--safe` is used (because they - must be introduced as postulates). This can be worked around by - type-checking trusted files in a first pass, without using `--safe`, - and then using `--saf`e in a second pass. Modules which have already - been type-checked are not re-type-checked just because `--safe` is - used. - -* Dependency graphs. - - The new flag `--dependency-graph=FILE` can be used to generate a DOT - file containing a module dependency graph. The generated file (FILE) - can be rendered using a tool like dot. - -* The `--no-unreachable-check` flag has been removed. - -* Projection functions are highlighted as functions instead of as - fields. Field names (in record definitions and record values) are - still highlighted as fields. - -* Support for jumping to positions mentioned in the information - buffer has been added. - -* The `make install` command no longer installs Agda globally (by - default). - -Release notes for Agda 2 version 2.2.10 -======================================= - -Language --------- - -* New flag: `--without-K`. - - This flag makes pattern matching more restricted. If the flag is - activated, then Agda only accepts certain case-splits. If the type - of the variable to be split is `D pars ixs`, where `D` is a data (or - record) type, pars stands for the parameters, and `ixs` the indices, - then the following requirements must be satisfied: - - - The indices `ixs` must be applications of constructors to distinct - variables. - - - These variables must not be free in pars. - - The intended purpose of `--without-K` is to enable experiments with - a propositional equality without the K rule. Let us define - propositional equality as follows: - - ```agda - data _≡_ {A : Set} : A → A → Set where - refl : ∀ x → x ≡ x - ``` - - Then the obvious implementation of the J rule is accepted: - - ```agda - J : {A : Set} (P : {x y : A} → x ≡ y → Set) → - (∀ x → P (refl x)) → - ∀ {x y} (x≡y : x ≡ y) → P x≡y - J P p (refl x) = p x - ``` - - The same applies to Christine Paulin-Mohring's version of the J rule: - - ```agda - J′ : {A : Set} {x : A} (P : {y : A} → x ≡ y → Set) → - P (refl x) → - ∀ {y} (x≡y : x ≡ y) → P x≡y - J′ P p (refl x) = p - ``` - - On the other hand, the obvious implementation of the K rule is not - accepted: - - ```agda - K : {A : Set} (P : {x : A} → x ≡ x → Set) → - (∀ x → P (refl x)) → - ∀ {x} (x≡x : x ≡ x) → P x≡x - K P p (refl x) = p x - ``` - - However, we have *not* proved that activation of `--without-K` - ensures that the K rule cannot be proved in some other way. - -* Irrelevant declarations. - - Postulates and functions can be marked as irrelevant by prefixing - the name with a dot when the name is declared. Example: - - ```agda - postulate - .irrelevant : {A : Set} → .A → A - ``` - - Irrelevant names may only be used in irrelevant positions or in - definitions of things which have been declared irrelevant. - - The axiom irrelevant above can be used to define a projection from - an irrelevant record field: - - ```agda - data Subset (A : Set) (P : A → Set) : Set where - _#_ : (a : A) → .(P a) → Subset A P - - elem : ∀ {A P} → Subset A P → A - elem (a # p) = a - - .certificate : ∀ {A P} (x : Subset A P) → P (elem x) - certificate (a # p) = irrelevant p - ``` - - The right-hand side of certificate is relevant, so we cannot define - - ```agda - certificate (a # p) = p - ``` - - (because `p` is irrelevant). However, certificate is declared to be - irrelevant, so it can use the axiom irrelevant. Furthermore the - first argument of the axiom is irrelevant, which means that - irrelevant `p` is well-formed. - - As shown above the axiom irrelevant justifies irrelevant - projections. Previously no projections were generated for irrelevant - record fields, such as the field certificate in the following - record type: - - ```agda - record Subset (A : Set) (P : A → Set) : Set where - constructor _#_ - field - elem : A - .certificate : P elem - ``` - - Now projections are generated automatically for irrelevant fields - (unless the flag `--no-irrelevant-projections` is used). Note that - irrelevant projections are highly experimental. - -* Termination checker recognises projections. - - Projections now preserve sizes, both in patterns and expressions. - Example: - - ```agda - record Wrap (A : Set) : Set where - constructor wrap - field - unwrap : A - - open Wrap public - - data WNat : Set where - zero : WNat - suc : Wrap WNat → WNat - - id : WNat → WNat - id zero = zero - id (suc w) = suc (wrap (id (unwrap w))) - ``` - - In the structural ordering `unwrap w` ≤ `w`. This means that - - ```agda - unwrap w ≤ w < suc w, - ``` - - and hence the recursive call to id is accepted. - - Projections also preserve guardedness. - -Tools ------ - -* Hyperlinks for top-level module names now point to the start of the - module rather than to the declaration of the module name. This - applies both to the Emacs mode and to the output of `agda --html`. - -* Most occurrences of record field names are now highlighted as - "fields". Previously many occurrences were highlighted as - "functions". - -* Emacs mode: It is no longer possible to change the behaviour of the - `TAB` key by customising `agda2-indentation`. - -* Epic compiler backend. - - A new compiler backend is being implemented. This backend makes use - of Edwin Brady's language Epic - (http://www.cs.st-andrews.ac.uk/~eb/epic.php) and its compiler. The - backend should handle most Agda code, but is still at an - experimental stage: more testing is needed, and some things written - below may not be entirely true. - - The Epic compiler can be invoked from the command line using the - flag `--epic`: - - ``` - agda --epic --epic-flag= --compile-dir= .agda - ``` - - The `--epic-flag` flag can be given multiple times; each flag is - given verbatim to the Epic compiler (in the given order). The - resulting executable is named after the main module and placed in - the directory specified by the `--compile-dir` flag (default: the - project root). Intermediate files are placed in a subdirectory - called `Epic`. - - The backend requires that there is a definition named main. This - definition should be a value of type `IO Unit`, but at the moment - this is not checked (so it is easy to produce a program which - segfaults). Currently the backend represents actions of type `IO A` - as functions from `Unit` to `A`, and main is applied to the unit - value. - - The Epic compiler compiles via C, not Haskell, so the pragmas - related to the Haskell FFI (`IMPORT`, `COMPILED_DATA` and - `COMPILED`) are not used by the Epic backend. Instead there is a new - pragma `COMPILED_EPIC`. This pragma is used to give Epic code for - postulated definitions (Epic code can in turn call C code). The form - of the pragma is `{-# COMPILED_EPIC def code #-}`, where `def` is - the name of an Agda postulate and `code` is some Epic code which - should include the function arguments, return type and function - body. As an example the `IO` monad can be defined as follows: - - ```agda - postulate - IO : Set → Set - return : ∀ {A} → A → IO A - _>>=_ : ∀ {A B} → IO A → (A → IO B) → IO B - - {-# COMPILED_EPIC return (u : Unit, a : Any) -> Any = - ioreturn(a) #-} - {-# COMPILED_EPIC - _>>=_ (u1 : Unit, u2 : Unit, x : Any, f : Any) -> Any = - iobind(x,f) #-} - ``` - - Here `ioreturn` and `iobind` are Epic functions which are defined in - the file `AgdaPrelude.e` which is always included. - - By default the backend will remove so-called forced constructor - arguments (and case-splitting on forced variables will be - rewritten). This optimisation can be disabled by using the flag - `--no-forcing`. - - All data types which look like unary natural numbers after forced - constructor arguments have been removed (i.e. types with two - constructors, one nullary and one with a single recursive argument) - will be represented as "BigInts". This applies to the standard `Fin` - type, for instance. - - The backend supports Agda's primitive functions and the BUILTIN - pragmas. If the BUILTIN pragmas for unary natural numbers are used, - then some operations, like addition and multiplication, will use - more efficient "BigInt" operations. - - If you want to make use of the Epic backend you need to install some - dependencies, see the README. - -* The Emacs mode can compile using either the MAlonzo or the Epic - backend. The variable `agda2-backend` controls which backend is - used. - -Release notes for Agda 2 version 2.2.8 -====================================== - -Language --------- - -* Record pattern matching. - - It is now possible to pattern match on named record constructors. - Example: - - ```agda - record Σ (A : Set) (B : A → Set) : Set where - constructor _,_ - field - proj₁ : A - proj₂ : B proj₁ - - map : {A B : Set} {P : A → Set} {Q : B → Set} - (f : A → B) → (∀ {x} → P x → Q (f x)) → - Σ A P → Σ B Q - map f g (x , y) = (f x , g y) - ``` - - The clause above is internally translated into the following one: - - ```agda - map f g p = (f (Σ.proj₁ p) , g (Σ.proj₂ p)) - ``` - - Record patterns containing data type patterns are not translated. - Example: - - ```agda - add : ℕ × ℕ → ℕ - add (zero , n) = n - add (suc m , n) = suc (add (m , n)) - ``` - - Record patterns which do not contain data type patterns, but which - do contain dot patterns, are currently rejected. Example: - - ```agda - Foo : {A : Set} (p₁ p₂ : A × A) → proj₁ p₁ ≡ proj₁ p₂ → Set₁ - Foo (x , y) (.x , y′) refl = Set - ``` - -* Proof irrelevant function types. - - Agda now supports irrelevant non-dependent function types: - - ```agda - f : .A → B - ``` - - This type implies that `f` does not depend computationally on its - argument. One intended use case is data structures with embedded - proofs, like sorted lists: - - ```agda - postulate - _≤_ : ℕ → ℕ → Set - p₁ : 0 ≤ 1 - p₂ : 0 ≤ 1 - - data SList (bound : ℕ) : Set where - [] : SList bound - scons : (head : ℕ) → - .(head ≤ bound) → - (tail : SList head) → - SList bound - ``` - - The effect of the irrelevant type in the signature of `scons` is - that `scons`'s second argument is never inspected after Agda has - ensured that it has the right type. It is even thrown away, leading - to smaller term sizes and hopefully some gain in efficiency. The - type-checker ignores irrelevant arguments when checking equality, so - two lists can be equal even if they contain different proofs: - - ```agda - l₁ : SList 1 - l₁ = scons 0 p₁ [] - - l₂ : SList 1 - l₂ = scons 0 p₂ [] - - l₁≡l₂ : l₁ ≡ l₂ - l₁≡l₂ = refl - ``` - - Irrelevant arguments can only be used in irrelevant contexts. - Consider the following subset type: - - ```agda - data Subset (A : Set) (P : A → Set) : Set where - _#_ : (elem : A) → .(P elem) → Subset A P - ``` - - The following two uses are fine: - - ```agda - elimSubset : ∀ {A C : Set} {P} → - Subset A P → ((a : A) → .(P a) → C) → C - elimSubset (a # p) k = k a p - - elem : {A : Set} {P : A → Set} → Subset A P → A - elem (x # p) = x - ``` - - However, if we try to project out the proof component, then Agda - complains that `variable p is declared irrelevant, so it cannot be - used here`: - - ```agda - prjProof : ∀ {A P} (x : Subset A P) → P (elem x) - prjProof (a # p) = p - ``` - - Matching against irrelevant arguments is also forbidden, except in - the case of irrefutable matches (record constructor patterns which - have been translated away). For instance, the match against the - pattern `(p , q)` here is accepted: - - ```agda - elim₂ : ∀ {A C : Set} {P Q : A → Set} → - Subset A (λ x → Σ (P x) (λ _ → Q x)) → - ((a : A) → .(P a) → .(Q a) → C) → C - elim₂ (a # (p , q)) k = k a p q - ``` - - Absurd matches `()` are also allowed. - - Note that record fields can also be irrelevant. Example: - - ```agda - record Subset (A : Set) (P : A → Set) : Set where - constructor _#_ - field - elem : A - .proof : P elem - ``` - - Irrelevant fields are never in scope, neither inside nor outside the - record. This means that no record field can depend on an irrelevant - field, and furthermore projections are not defined for such fields. - Irrelevant fields can only be accessed using pattern matching, as in - `elimSubset` above. - - Irrelevant function types were added very recently, and have not - been subjected to much experimentation yet, so do not be surprised - if something is changed before the next release. For instance, - dependent irrelevant function spaces (`.(x : A) → B`) might be added - in the future. - -* Mixfix binders. - - It is now possible to declare user-defined syntax that binds - identifiers. Example: - - ```agda - postulate - State : Set → Set → Set - put : ∀ {S} → S → State S ⊤ - get : ∀ {S} → State S S - return : ∀ {A S} → A → State S A - bind : ∀ {A B S} → State S B → (B → State S A) → State S A - - syntax bind e₁ (λ x → e₂) = x ← e₁ , e₂ - - increment : State ℕ ⊤ - increment = x ← get , - put (1 + x) - ``` - - The syntax declaration for `bind` implies that `x` is in scope in - `e₂`, but not in `e₁`. - - You can give fixity declarations along with syntax declarations: - - ```agda - infixr 40 bind - syntax bind e₁ (λ x → e₂) = x ← e₁ , e₂ - ``` - - The fixity applies to the syntax, not the name; syntax declarations - are also restricted to ordinary, non-operator names. The following - declaration is disallowed: - - ```agda - syntax _==_ x y = x === y - ```agda - - Syntax declarations must also be linear; the following declaration - is disallowed: - - ```agda - syntax wrong x = x + x - ``` - - Syntax declarations were added very recently, and have not been - subjected to much experimentation yet, so do not be surprised if - something is changed before the next release. - -* `Prop` has been removed from the language. - - The experimental sort `Prop` has been disabled. Any program using - `Prop` should typecheck if `Prop` is replaced by `Set₀`. Note that - `Prop` is still a keyword. - -* Injective type constructors off by default. - - Automatic injectivity of type constructors has been disabled (by - default). To enable it, use the flag - `--injective-type-constructors`, either on the command line or in an - OPTIONS pragma. Note that this flag makes Agda anti-classical and - possibly inconsistent: - - Agda with excluded middle is inconsistent - http://thread.gmane.org/gmane.comp.lang.agda/1367 - - See `test/Succeed/InjectiveTypeConstructors.agda` for an example. - -* Termination checker can count. - - There is a new flag `--termination-depth=N` accepting values `N >= - 1` (with `N = 1` being the default) which influences the behavior of - the termination checker. So far, the termination checker has only - distinguished three cases when comparing the argument of a recursive - call with the formal parameter of the callee. - - `<`: the argument is structurally smaller than the parameter - - `=`: they are equal - - `?`: the argument is bigger or unrelated to the parameter - - This behavior, which is still the default (`N = 1`), will not - recognise the following functions as terminating. - - ```agda - mutual - - f : ℕ → ℕ - f zero = zero - f (suc zero) = zero - f (suc (suc n)) = aux n - - aux : ℕ → ℕ - aux m = f (suc m) - ``` - - The call graph - - ``` - f --(<)--> aux --(?)--> f - ``` - - yields a recursive call from `f` to `f` via `aux` where the relation - of call argument to callee parameter is computed as "unrelated" - (composition of `<` and `?`). - - Setting `N >= 2` allows a finer analysis: `n` has two constructors - less than `suc (suc n)`, and `suc m` has one more than `m`, so we get the - call graph: - - ``` - f --(-2)--> aux --(+1)--> f - ``` - - The indirect call `f --> f` is now labeled with `(-1)`, and the - termination checker can recognise that the call argument is - decreasing on this path. - - Setting the termination depth to `N` means that the termination - checker counts decrease up to `N` and increase up to `N-1`. The - default, `N=1`, means that no increase is counted, every increase - turns to "unrelated". - - In practice, examples like the one above sometimes arise when `with` - is used. As an example, the program - - ```agda - f : ℕ → ℕ - f zero = zero - f (suc zero) = zero - f (suc (suc n)) with zero - ... | _ = f (suc n) - ``` - - is internally represented as - - ```agda - mutual - - f : ℕ → ℕ - f zero = zero - f (suc zero) = zero - f (suc (suc n)) = aux n zero - - aux : ℕ → ℕ → ℕ - aux m k = f (suc m) - ``` - - Thus, by default, the definition of `f` using `with` is not accepted - by the termination checker, even though it looks structural (`suc n` - is a subterm of `suc suc n`). Now, the termination checker is - satisfied if the option `--termination-depth=2` is used. - - Caveats: - - - This is an experimental feature, hopefully being replaced by - something smarter in the near future. - - - Increasing the termination depth will quickly lead to very long - termination checking times. So, use with care. Setting termination - depth to `100` by habit, just to be on the safe side, is not a good - idea! - - - Increasing termination depth only makes sense for linear data - types such as `ℕ` and `Size`. For other types, increase cannot be - recognised. For instance, consider a similar example with lists. - - ```agda - data List : Set where - nil : List - cons : ℕ → List → List - - mutual - f : List → List - f nil = nil - f (cons x nil) = nil - f (cons x (cons y ys)) = aux y ys - - aux : ℕ → List → List - aux z zs = f (cons z zs) - ``` - - Here the termination checker compares `cons z zs` to `z` and also - to `zs`. In both cases, the result will be "unrelated", no matter - how high we set the termination depth. This is because when - comparing `cons z zs` to `zs`, for instance, `z` is unrelated to - `zs`, thus, `cons z zs` is also unrelated to `zs`. We cannot say - it is just "one larger" since `z` could be a very large term. Note - that this points to a weakness of untyped termination checking. - - To regain the benefit of increased termination depth, we need to - index our lists by a linear type such as `ℕ` or `Size`. With - termination depth `2`, the above example is accepted for vectors - instead of lists. - -* The `codata` keyword has been removed. To use coinduction, use the - following new builtins: `INFINITY`, `SHARP` and `FLAT`. Example: - - ```agda - {-# OPTIONS --universe-polymorphism #-} - - module Coinduction where - - open import Level - - infix 1000 ♯_ - - postulate - ∞ : ∀ {a} (A : Set a) → Set a - ♯_ : ∀ {a} {A : Set a} → A → ∞ A - ♭ : ∀ {a} {A : Set a} → ∞ A → A - - {-# BUILTIN INFINITY ∞ #-} - {-# BUILTIN SHARP ♯_ #-} - {-# BUILTIN FLAT ♭ #-} - ``` - - Note that (non-dependent) pattern matching on `SHARP` is no longer - allowed. - - Note also that strange things might happen if you try to combine the - pragmas above with `COMPILED_TYPE`, `COMPILED_DATA` or `COMPILED` - pragmas, or if the pragmas do not occur right after the postulates. - - The compiler compiles the `INFINITY` builtin to nothing (more or - less), so that the use of coinduction does not get in the way of FFI - declarations: - - ```agda - data Colist (A : Set) : Set where - [] : Colist A - _∷_ : (x : A) (xs : ∞ (Colist A)) → Colist A - - {-# COMPILED_DATA Colist [] [] (:) #-} - ``` - -* Infinite types. - - If the new flag `--guardedness-preserving-type-constructors` is - used, then type constructors are treated as inductive constructors - when we check productivity (but only in parameters, and only if they - are used strictly positively or not at all). This makes examples - such as the following possible: - - ```agda - data Rec (A : ∞ Set) : Set where - fold : ♭ A → Rec A - - -- Σ cannot be a record type below. - - data Σ (A : Set) (B : A → Set) : Set where - _,_ : (x : A) → B x → Σ A B - - syntax Σ A (λ x → B) = Σ[ x ∶ A ] B - - -- Corecursive definition of the W-type. - - W : (A : Set) → (A → Set) → Set - W A B = Rec (♯ (Σ[ x ∶ A ] (B x → W A B))) - - syntax W A (λ x → B) = W[ x ∶ A ] B - - sup : {A : Set} {B : A → Set} (x : A) (f : B x → W A B) → W A B - sup x f = fold (x , f) - - W-rec : {A : Set} {B : A → Set} - (P : W A B → Set) → - (∀ {x} {f : B x → W A B} → (∀ y → P (f y)) → P (sup x f)) → - ∀ x → P x - W-rec P h (fold (x , f)) = h (λ y → W-rec P h (f y)) - - -- Induction-recursion encoded as corecursion-recursion. - - data Label : Set where - ′0 ′1 ′2 ′σ ′π ′w : Label - - mutual - - U : Set - U = Σ Label U′ - - U′ : Label → Set - U′ ′0 = ⊤ - U′ ′1 = ⊤ - U′ ′2 = ⊤ - U′ ′σ = Rec (♯ (Σ[ a ∶ U ] (El a → U))) - U′ ′π = Rec (♯ (Σ[ a ∶ U ] (El a → U))) - U′ ′w = Rec (♯ (Σ[ a ∶ U ] (El a → U))) - - El : U → Set - El (′0 , _) = ⊥ - El (′1 , _) = ⊤ - El (′2 , _) = Bool - El (′σ , fold (a , b)) = Σ[ x ∶ El a ] El (b x) - El (′π , fold (a , b)) = (x : El a) → El (b x) - El (′w , fold (a , b)) = W[ x ∶ El a ] El (b x) - - U-rec : (P : ∀ u → El u → Set) → - P (′1 , _) tt → - P (′2 , _) true → - P (′2 , _) false → - (∀ {a b x y} → - P a x → P (b x) y → P (′σ , fold (a , b)) (x , y)) → - (∀ {a b f} → - (∀ x → P (b x) (f x)) → P (′π , fold (a , b)) f) → - (∀ {a b x f} → - (∀ y → P (′w , fold (a , b)) (f y)) → - P (′w , fold (a , b)) (sup x f)) → - ∀ u (x : El u) → P u x - U-rec P P1 P2t P2f Pσ Pπ Pw = rec - where - rec : ∀ u (x : El u) → P u x - rec (′0 , _) () - rec (′1 , _) _ = P1 - rec (′2 , _) true = P2t - rec (′2 , _) false = P2f - rec (′σ , fold (a , b)) (x , y) = Pσ (rec _ x) (rec _ y) - rec (′π , fold (a , b)) f = Pπ (λ x → rec _ (f x)) - rec (′w , fold (a , b)) (fold (x , f)) = Pw (λ y → rec _ (f y)) - ``` - - The `--guardedness-preserving-type-constructors` extension is based - on a rather operational understanding of `∞`/`♯_`; it's not yet - clear if this extension is consistent. - -* Qualified constructors. - - Constructors can now be referred to qualified by their data type. - For instance, given - - ```agda - data Nat : Set where - zero : Nat - suc : Nat → Nat - - data Fin : Nat → Set where - zero : ∀ {n} → Fin (suc n) - suc : ∀ {n} → Fin n → Fin (suc n) - ``` - - you can refer to the constructors unambiguously as `Nat.zero`, - `Nat.suc`, `Fin.zero`, and `Fin.suc` (`Nat` and `Fin` are modules - containing the respective constructors). Example: - - ```agda - inj : (n m : Nat) → Nat.suc n ≡ suc m → n ≡ m - inj .m m refl = refl - ``` - - Previously you had to write something like - - ```agda - inj : (n m : Nat) → _≡_ {Nat} (suc n) (suc m) → n ≡ m - ``` - - to make the type checker able to figure out that you wanted the - natural number suc in this case. - -* Reflection. - - There are two new constructs for reflection: - - - `quoteGoal x in e` - - In `e` the value of `x` will be a representation of the goal type - (the type expected of the whole expression) as an element in a - datatype of Agda terms (see below). For instance, - - ```agda - example : ℕ - example = quoteGoal x in {! at this point x = def (quote ℕ) [] !} - ``` - - - `quote x : Name` - - If `x` is the name of a definition (function, datatype, record, - or a constructor), `quote x` gives you the representation of `x` - as a value in the primitive type `Name` (see below). - - Quoted terms use the following BUILTINs and primitives (available - from the standard library module `Reflection`): - - ```agda - -- The type of Agda names. - - postulate Name : Set - - {-# BUILTIN QNAME Name #-} - - primitive primQNameEquality : Name → Name → Bool - - -- Arguments. - - Explicit? = Bool - - data Arg A : Set where - arg : Explicit? → A → Arg A - - {-# BUILTIN ARG Arg #-} - {-# BUILTIN ARGARG arg #-} - - -- The type of Agda terms. - - data Term : Set where - var : ℕ → List (Arg Term) → Term - con : Name → List (Arg Term) → Term - def : Name → List (Arg Term) → Term - lam : Explicit? → Term → Term - pi : Arg Term → Term → Term - sort : Term - unknown : Term - - {-# BUILTIN AGDATERM Term #-} - {-# BUILTIN AGDATERMVAR var #-} - {-# BUILTIN AGDATERMCON con #-} - {-# BUILTIN AGDATERMDEF def #-} - {-# BUILTIN AGDATERMLAM lam #-} - {-# BUILTIN AGDATERMPI pi #-} - {-# BUILTIN AGDATERMSORT sort #-} - {-# BUILTIN AGDATERMUNSUPPORTED unknown #-} - ``` - - Reflection may be useful when working with internal decision - procedures, such as the standard library's ring solver. - -* Minor record definition improvement. - - The definition of a record type is now available when type checking - record module definitions. This means that you can define things - like the following: - - ```agda - record Cat : Set₁ where - field - Obj : Set - _=>_ : Obj → Obj → Set - -- ... - - -- not possible before: - op : Cat - op = record { Obj = Obj; _=>_ = λ A B → B => A } - ``` - -Tools ------ - -* The `Goal type and context` command now shows the goal type before - the context, and the context is shown in reverse order. The `Goal - type, context and inferred type` command has been modified in a - similar way. - -* Show module contents command. - - Given a module name `M` the Emacs mode can now display all the - top-level modules and names inside `M`, along with types for the - names. The command is activated using `C-c C-o` or the menus. - -* Auto command. - - A command which searches for type inhabitants has been added. The - command is invoked by pressing `C-C C-a` (or using the goal menu). - There are several flags and parameters, e.g. `-c` which enables - case-splitting in the search. For further information, see the Agda - wiki: - - http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Main.Auto - -* HTML generation is now possible for a module with unsolved - meta-variables, provided that the `--allow-unsolved-metas` flag is - used. - -Release notes for Agda 2 version 2.2.6 -====================================== - -Language --------- - -* Universe polymorphism (experimental extension). - - To enable universe polymorphism give the flag - `--universe-polymorphism` on the command line or (recommended) as an - OPTIONS pragma. - - When universe polymorphism is enabled `Set` takes an argument which is - the universe level. For instance, the type of universe polymorphic - identity is - - ```agda - id : {a : Level} {A : Set a} → A → A. - ``` - - The type Level is isomorphic to the unary natural numbers and should - be specified using the BUILTINs `LEVEL`, `LEVELZERO`, and - `LEVELSUC`: - - ```agda - data Level : Set where - zero : Level - suc : Level → Level - - {-# BUILTIN LEVEL Level #-} - {-# BUILTIN LEVELZERO zero #-} - {-# BUILTIN LEVELSUC suc #-} - ``` - - There is an additional BUILTIN `LEVELMAX` for taking the maximum of two - levels: - - ```agda - max : Level → Level → Level - max zero m = m - max (suc n) zero = suc n - max (suc n) (suc m) = suc (max n m) - - {-# BUILTIN LEVELMAX max #-} - ``` - - The non-polymorphic universe levels `Set`, `Set₁` and so on are - sugar for `Set zero`, `Set (suc zero)`, etc. - - At present there is no automatic lifting of types from one level to - another. It can still be done (rather clumsily) by defining types - like the following one: - - ```agda - data Lifted {a} (A : Set a) : Set (suc a) where - lift : A → Lifted A - ``` - - However, it is likely that automatic lifting is introduced at some - point in the future. - -* Multiple constructors, record fields, postulates or primitives can - be declared using a single type signature: - - ```agda - data Bool : Set where - false true : Bool - - postulate - A B : Set - ``` - -* Record fields can be implicit: - - ```agda - record R : Set₁ where - field - {A} : Set - f : A → A - {B C} D {E} : Set - g : B → C → E - ``` - - By default implicit fields are not printed. - -* Record constructors can be defined: - - ```agda - record Σ (A : Set) (B : A → Set) : Set where - constructor _,_ - field - proj₁ : A - proj₂ : B proj₁ - ``` - - In this example `_,_` gets the type - - ```agda - (proj₁ : A) → B proj₁ → Σ A B. - ``` - - For implicit fields the corresponding constructor arguments become - implicit. - - Note that the constructor is defined in the *outer* scope, so any - fixity declaration has to be given outside the record definition. - The constructor is not in scope inside the record module. - - Note also that pattern matching for records has not been implemented - yet. - -* BUILTIN hooks for equality. - - The data type - - ```agda - data _≡_ {A : Set} (x : A) : A → Set where - refl : x ≡ x - ``` - - can be specified as the builtin equality type using the following - pragmas: - - ```agda - {-# BUILTIN EQUALITY _≡_ #-} - {-# BUILTIN REFL refl #-} - ``` - - The builtin equality is used for the new rewrite construct and - the `primTrustMe` primitive described below. - -* New `rewrite` construct. - - If `eqn : a ≡ b`, where `_≡_` is the builtin equality (see above) you - can now write - - ```agda - f ps rewrite eqn = rhs - ``` - - instead of - - ```agda - f ps with a | eqn - ... | ._ | refl = rhs - ``` - - The `rewrite` construct has the effect of rewriting the goal and the - context by the given equation (left to right). - - You can rewrite using several equations (in sequence) by separating - them with vertical bars (|): - - ```agda - f ps rewrite eqn₁ | eqn₂ | … = rhs - ``` - - It is also possible to add `with`-clauses after rewriting: - - ```agda - f ps rewrite eqns with e - ... | p = rhs - ``` - - Note that pattern matching happens before rewriting—if you want to - rewrite and then do pattern matching you can use a with after the - rewrite. - - See `test/Succeed/Rewrite.agda` for some examples. - -* A new primitive, `primTrustMe`, has been added: - - ```agda - primTrustMe : {A : Set} {x y : A} → x ≡ y - ``` - - Here `_≡_` is the builtin equality (see BUILTIN hooks for equality, - above). - - If `x` and `y` are definitionally equal, then - `primTrustMe {x = x} {y = y}` reduces to `refl`. - - Note that the compiler replaces all uses of `primTrustMe` with the - `REFL` builtin, without any check for definitional - equality. Incorrect uses of `primTrustMe` can potentially lead to - segfaults or similar problems. - - For an example of the use of `primTrustMe`, see `Data.String` in - version 0.3 of the standard library, where it is used to implement - decidable equality on strings using the primitive boolean equality. - -* Changes to the syntax and semantics of IMPORT pragmas, which are - used by the Haskell FFI. Such pragmas must now have the following - form: - - ```agda - {-# IMPORT #-} - ``` - - These pragmas are interpreted as *qualified* imports, so Haskell - names need to be given qualified (unless they come from the Haskell - prelude). - -* The horizontal tab character (U+0009) is no longer treated as white - space. - -* Line pragmas are no longer supported. - -* The `--include-path` flag can no longer be used as a pragma. - -* The experimental and incomplete support for proof irrelevance has - been disabled. - -Tools ------ - -* New `intro` command in the Emacs mode. When there is a canonical way - of building something of the goal type (for instance, if the goal - type is a pair), the goal can be refined in this way. The command - works for the following goal types: - - - A data type where only one of its constructors can be used to - construct an element of the goal type. (For instance, if the - goal is a non-empty vector, a `cons` will be introduced.) - - - A record type. A record value will be introduced. Implicit - fields will not be included unless showing of implicit arguments - is switched on. - - - A function type. A lambda binding as many variables as possible - will be introduced. The variable names will be chosen from the - goal type if its normal form is a dependent function type, - otherwise they will be variations on `x`. Implicit lambdas will - only be inserted if showing of implicit arguments is switched - on. - - This command can be invoked by using the `refine` command - (`C-c C-r`) when the goal is empty. (The old behaviour of the refine - command in this situation was to ask for an expression using the - minibuffer.) - -* The Emacs mode displays `Checked` in the mode line if the current - file type checked successfully without any warnings. - -* If a file `F` is loaded, and this file defines the module `M`, it is - an error if `F` is not the file which defines `M` according to the - include path. - - Note that the command-line tool and the Emacs mode define the - meaning of relative include paths differently: the command-line tool - interprets them relative to the current working directory, whereas - the Emacs mode interprets them relative to the root directory of the - current project. (As an example, if the module `A.B.C` is loaded - from the file `/A/B/C.agda`, then the root directory is - ``.) - -* It is an error if there are several files on the include path which - match a given module name. - -* Interface files are relocatable. You can move around source trees as - long as the include path is updated in a corresponding way. Note - that a module `M` may be re-typechecked if its time stamp is - strictly newer than that of the corresponding interface file - (`M.agdai`). - -* Type-checking is no longer done when an up-to-date interface exists. - (Previously the initial module was always type-checked.) - -* Syntax highlighting files for Emacs (`.agda.el`) are no longer used. - The `--emacs` flag has been removed. (Syntax highlighting - information is cached in the interface files.) - -* The Agate and Alonzo compilers have been retired. The options - `--agate`, `--alonzo` and `--malonzo` have been removed. - -* The default directory for MAlonzo output is the project's root - directory. The `--malonzo-dir` flag has been renamed to - `--compile-dir`. - -* Emacs mode: `C-c C-x C-d` no longer resets the type checking state. - `C-c C-x C-r` can be used for a more complete reset. `C-c C-x C-s` - (which used to reload the syntax highlighting information) has been - removed. `C-c C-l` can be used instead. - -* The Emacs mode used to define some "abbrevs", unless the user - explicitly turned this feature off. The new default is *not* to add - any abbrevs. The old default can be obtained by customising - `agda2-mode-abbrevs-use-defaults` (a customisation buffer can be - obtained by typing `M-x customize-group agda2 RET` after an Agda - file has been loaded). - -Release notes for Agda 2 version 2.2.4 -====================================== - -Important changes since 2.2.2: - -* Change to the semantics of `open import` and `open module`. The - declaration - - ```agda - open import M - ``` - - now translates to - - ```agda - import A - open A - ``` - - instead of - - ```agda - import A - open A - ``` - - The same translation is used for `open module M = E …`. Declarations - involving the keywords as or public are changed in a corresponding - way (`as` always goes with import, and `public` always with open). - - This change means that import directives do not affect the qualified - names when open import/module is used. To get the old behaviour you - can use the expanded version above. - -* Names opened publicly in parameterised modules no longer inherit the - module parameters. Example: - - ```agda - module A where - postulate X : Set - - module B (Y : Set) where - open A public - ``` - - In Agda 2.2.2 `B.X` has type `(Y : Set) → Set`, whereas in - Agda 2.2.4 `B.X` has type Set. - -* Previously it was not possible to export a given constructor name - through two different `open public` statements in the same module. - This is now possible. - -* Unicode subscript digits are now allowed for the hierarchy of - universes (`Set₀`, `Set₁`, …): `Set₁` is equivalent to `Set1`. - -Release notes for Agda 2 version 2.2.2 -====================================== - -Tools ------ - -* The `--malonzodir` option has been renamed to `--malonzo-dir`. - -* The output of `agda --html` is by default placed in a directory - called `html`. - -Infrastructure --------------- - -* The Emacs mode is included in the Agda Cabal package, and installed - by `cabal install`. The recommended way to enable the Emacs mode is - to include the following code in `.emacs`: - - ```elisp - (load-file (let ((coding-system-for-read 'utf-8)) - (shell-command-to-string "agda-mode locate"))) - ``` - -Release notes for Agda 2 version 2.2.0 -====================================== - -Important changes since 2.1.2 (which was released 2007-08-16): - -Language --------- - -* Exhaustive pattern checking. Agda complains if there are missing - clauses in a function definition. - -* Coinductive types are supported. This feature is under - development/evaluation, and may change. - - http://wiki.portal.chalmers.se/agda/agda.php?n=ReferenceManual.Codatatypes - -* Another experimental feature: Sized types, which can make it easier - to explain why your code is terminating. - -* Improved constraint solving for functions with constructor headed - right hand sides. - - http://wiki.portal.chalmers.se/agda/agda.php?n=ReferenceManual.FindingTheValuesOfImplicitArguments - -* A simple, well-typed foreign function interface, which allows use of - Haskell functions in Agda code. - - http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Docs.FFI - -* The tokens `forall`, `->` and `\` can be written as `∀`, `→` and - `λ`. - -* Absurd lambdas: `λ ()` and `λ {}`. - - http://thread.gmane.org/gmane.comp.lang.agda/440 - -* Record fields whose values can be inferred can be omitted. - -* Agda complains if it spots an unreachable clause, or if a pattern - variable "shadows" a hidden constructor of matching type. - - http://thread.gmane.org/gmane.comp.lang.agda/720 - -Tools ------ - -* Case-split: The user interface can replace a pattern variable with - the corresponding constructor patterns. You get one new left-hand - side for every possible constructor. - - http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Main.QuickGuideToEditingTypeCheckingAndCompilingAgdaCode - -* The MAlonzo compiler. - - http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Docs.MAlonzo - -* A new Emacs input method, which contains bindings for many Unicode - symbols, is by default activated in the Emacs mode. - - http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Docs.UnicodeInput - -* Highlighted, hyperlinked HTML can be generated from Agda source - code. - - http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Main.HowToGenerateWebPagesFromSourceCode - -* The command-line interactive mode (`agda -I`) is no longer - supported, but should still work. - - http://thread.gmane.org/gmane.comp.lang.agda/245 - -* Reload times when working on large projects are now considerably - better. - - http://thread.gmane.org/gmane.comp.lang.agda/551 - -Libraries ---------- - -* A standard library is under development. - - http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Libraries.StandardLibrary - -Documentation -------------- - -* The Agda wiki is better organised. It should be easier for a - newcomer to find relevant information now. - - http://wiki.portal.chalmers.se/agda/ - -Infrastructure --------------- - -* Easy-to-install packages for Windows and Debian/Ubuntu have been - prepared. - - http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Main.Download - -* Agda 2.2.0 is available from Hackage. - - http://hackage.haskell.org/ +Release notes for Agda version 2.6.1 +==================================== + +General +------- + +* Agda now has an official logo: ![The official Agda + logo](doc/user-manual/agda.svg) + (https://github.com/agda/agda/blob/master/doc/user-manual/agda.svg). The + logo was chosen by the Agda community from a list of candidates. The winning design was submitted by Miëtek Bak. The list of candidates and the outcome of the poll can be consulted [here](https://civs.cs.cornell.edu/cgi-bin/results.pl?id=E_ce6fe5e2a518ac98). + +Installation and infrastructure +------------------------------- + +* Added support for GHC 8.8.2 + [Issue [#4285](https://github.com/agda/agda/issues/4285)]. + +* Removed support for GHC 7.10.3. + +* Interface files are now written in directory `_build/VERSION/agda/` at + the project root (the closest enclosing directory where an `.agda-lib` + file is present). If there is no project root then the interface file + is written alongside the module it corresponds to. + The flag `--local-interfaces` forces Agda to revert back to storing + interface files alongside module files no matter what. + +* Agda now uses the default RTS options `-M3.5G -I0`. If + you run Agda on a 32-bit system or a system with less than 8GB of + RAM, it is recommended to set the RTS options explicitly to a lower + value by running `agda` with option `+RTS -M1.2G -RTS` + (for example) or by setting the GHCRTS enviroment variable. See the + [GHC User's Guide](https://downloads.haskell.org/~ghc/latest/docs/html/users_guide/runtime_control.html#setting-rts-options) + for more information. + +* If Agda is compiled using GHC 8.4 or later, then one can expect to + see substantially lower memory consumption + [Issues [#4457](https://github.com/agda/agda/issues/4457) + and [#4316](https://github.com/agda/agda/issues/4316)]. + + This is due to the use of ["compact + regions"](https://hackage.haskell.org/package/ghc-compact-0.1.0.0/docs/GHC-Compact.html). + +* The `CHANGELOG.md` was split. Changes to previous versions of Agda + are in the directory `doc/release-notes`. + +Pragmas and options +------------------- + +* New pragma `WARNING_ON_IMPORT` to let module authors raise a warning + when a module is imported. This can be use to tell users deprecations. + +* New option `--confluence-check` (off by default) enables confluence + checking of user-defined rewrite rules (this only has an effect when + `--rewriting` is also enabled). + +* New option `--no-projection-like` to turn off the analysis whether a + type signature likens that of a projection. + Projection-likeness is an optimization that reduces the size of + terms by dropping parameter-like reconstructible function arguments. + Thus, it is advisable to leave this optimization on, the flag is + meant for debugging Agda. + +* Option `--no-forcing` is now a pragma option, i.e., the forcing analysis + can be switched off on a per-file basis via + + ```agda + {-# OPTIONS --no-forcing #-} + ``` + + at the beginning of the file + [Issue [#3872](https://github.com/agda/agda/issues/3872)]. + +* New pragma option `--no-flat-split` disables pattern matching on `@♭` arguments. + +* New pragma option `--allow-incomplete-matches`. It is similar to + `--allow-unsolved-metas`: modules containing partial function definitions + can be imported. Its local equivalent is the `NON_COVERING` pragma to + be placed before the function (or the block of mutually defined functions) + which the user knows to be partial. + +* Option `--interaction-json` now brings more information about goals, + unsolved metas, warnings, errors. + It also displays pretty-printed terms. + +* New pragma option `--keep-pattern-variables` to prevent case + splitting from replacing variables with dot patterns. + +* Pragma `{-# ETA #-}` is no longer considered `--safe`. + See [Issue [#4450](https://github.com/agda/agda/issues/4450)]. + +* New pragma options `--subtyping` and `--no-subtyping` (default) to + turn on/off subtyping rules globally [see + Issue_[#4474](https://github.com/agda/agda/issues/4474)]. Currently, + this includes subtyping for irrelevance, erasure, and flat + modalities. Additionally, `--subtyping` is implied by + `--cumulativity` (see below). `--subtyping` is currently NOT implied + by `--sized-types`, and subtyping for sized types is used even when + `--subtyping` is not enabled. + +* New profiling options to measure time spent per module or top-level + definition. + + - `-v profile.modules:10` prints a breakdown per top-level module + - `-v profile.definitions:10` prints a breakdown per top-level + definition + +Language +-------- + +### Syntax + +* Fractional precedence levels are now supported, see + Issue [#3991](https://github.com/agda/agda/issues/3991). Example: + + ```agda + infix 3.14 _<_ + ``` + Note that this includes a respective change in the reflected Agda syntax. + +* Fixities can now be changed during import in a `renaming` directive, + see + Issue [#1346](https://github.com/agda/agda/issues/1346). Example: + + ```agda + open M using (_∙_) + open M renaming (_∙_ to infixl 10 _*_) + ``` + After this, `_∙_` is in scope with its original fixity, and as `_*_` as left + associative operator of precedence 10. + +* Implicit non-dependent function spaces `{A} → B` and `{{A}} → B` are now supported. + +* Idiom brackets + + Idiom brackets can accommodate none or multiple applications separated by a vertical bar `|` + if there are two additional operations + ```agda + empty : ∀ {A} → F A + _<|>_ : ∀ {A} → F A → F A → F A + ``` + i.e. an Alternative type class in Haskell. + As usual, the new idiom brackets desugar before scope checking. + + Idiom brackets with multiple applications + ```agda + (| e₁ a₁ .. aₙ | e₂ a₁ .. aₘ | .. | eₖ a₁ .. aₗ |) + ``` + expand to (assuming right associative `_<|>_`) + ```agda + (pure e₁ <*> a₁ <*> .. <*> aₙ) <|> ((pure e₂ <*> a₁ <*> .. <*> aₘ) <|> (pure eₖ <*> a₁ <*> .. <*> aₗ)) + ``` + Idiom brackets with no application `(|)` or `⦇⦈` are equivalent to `empty`. + + +* Irrefutable With + + Users can now match on irrefutable patterns on the LHS using a + pattern-matching `with`. An expression of the form: + + ```agda + f xs with p1 <- e1 | ... | pn <- en + with q1 <- f1 | ... | qm <- fm = rhs + ``` + + is translated to nested `with` clauses, essentially equivalent to: + + ```agda + f xs with e1 | ... | en + ... | p1 | ... | pn + with f1 | ... | fm + ... | q1 | ... | qm = rhs + ``` + +* Record patterns in telescopes + + Users can now use record patterns in telescope and lambda abstractions. + The type of the second projection from a dependent pair is the prototypical + example It can be defined as follows: + + ```agda + snd : ((a , _) : Σ A B) → B a + ``` + + And this second projection can be implemented with a lamba-abstraction using + one of these irrefutable patterns: + + ```agda + snd = λ (a , b) → b + ``` + + Using an as-pattern, users can get a name for the value as well as for its + subparts. We can for instance prove that any pair is equal to the pairing + of its first and second projections: + + ```agda + eta : (p@(a , b) : Σ A B) → p ≡ (a , b) + eta p = refl + ``` + +* Absurd match in a do block + The last expression in a do block can now also be an absurd match `() <- f`. + +* Named `where` modules are now in scope in the rhs of the clause (see + Issue [#4050](https://github.com/agda/agda/issues/4050)). Example: + + ```agda + record Wrap : Set₂ where + field wrapped : Set₁ + + test : Wrap + test = record { M } + module M where + wrapped : Set₁ + wrapped = Set + ``` + +* `{{-` is now lexed as `{ {-` rather than `{{ -`, + see Issue [#3962](https://github.com/agda/agda/issues/3962). + +* Syntax for large numbers: you can now separate groups of 3 digits using `_`. + e.g. write `1_000_000` instead of `1000000`. + +* `quoteGoal` and `quoteContext` are no longer keywords. + +* Record constructors can no longer be qualified by the record module. + (See Issue [#4189](https://github.com/agda/agda/issues/4189).) + + ```agda + record Foo : Set where + constructor foo + + works = foo + fails = Foo.foo + ``` + +* `codata` definitions have been removed from the concrete syntax + Previously they got accepted syntactically, but resulted in errors. + +* Imports can now be anonymous. + (See Issue_[#3727](https://github.com/agda/agda/issues/3727).) + For example, the following will **not** bring `Agda.Builtin.Unit` into scope: + ```agda + open import Agda.Builtin.Unit as _ + blah :: ⊤ + blah = tt + ``` + +### Type checking + +* Type inference for record expressions no longer considers record types from + modules that have not been imported (Issue [#4267](https://github.com/agda/agda/issues/4267)). + + For instance, + ```agda + -- A.agda + module A where + record R : Set₁ where + field f : Set + ``` + ```agda + -- B.agda + module B where + import A + ``` + ```agda + -- C.agda + module C where + import B + fails : Set → _ + fails X = record {f = X} -- import A required to infer record type R + ``` + +* The fix of issue [#3903](https://github.com/agda/agda/issues/3903) changes + the algorithm computing the order of case splits, which in some cases may + lead to unsolved metavariables in previously working code. See issue + [#4353](https://github.com/agda/agda/issues/4353). + +### Modalities + +* New Flat Modality + + New modality `@♭/@flat` (previously only available in the branch "flat"). + An idempotent comonadic modality modeled after spatial/crisp type theory. + See [Flat Modality](https://agda.readthedocs.io/en/v2.6.1/language/flat.html) + in the documentation for more. + +* New run-time erasure modality (`@0` / `@erased`). + Terms marked as erased cannot influence computations and are erased + at run time + [Issue [#3855](https://github.com/agda/agda/issues/3855)]. See + [Run-time + Irrelevance](https://agda.readthedocs.io/en/v2.6.1/language/runtime-irrelevance.html) + in the documentation for more information. + + Note that this feature can cause previously solved metavariables to become + unsolved even in code that doesn't use run-time erasure (see issue + [#4174](https://github.com/agda/agda/issues/4174)). + +* Subtyping rules for modalities are by default no longer used (see + Issue_[#4390](https://github.com/agda/agda/issues/4390)). For + example, if `f : .A → A`, Agda no longer accepts `f` at type `A → + A`. Instead, Agda accepts `λ x → f x : A → A`. The same holds for + erasure (`@0`) and flat (`@♭`) modalities. Consequently, it may be + required to eta-expand certain functions in order to make old code + work with Agda 2.6.1. Alternatively, enabling the new `--subtyping` + flag will restore the old behaviour but might negatively impact + typechecking performance. + +### Universe levels + +* New (experimental) option `--cumulativity` + + When the ``--cumulativity`` flag is enabled, Agda uses the subtyping + rule ``Set i =< Set j`` whenever ``i =< j``. For example, in + addition to its usual type ``Set``, ``Nat`` also has the type + ``Set₁`` and even ``Set i`` for any ``i : Level``. More information + about this new option can be found in section + [Cumulativity](https://agda.readthedocs.io/en/v2.6.1/language/cumulativity.html) + of the user manual. + +### Termination checking + +* The "with inlining" feature of the termination checker has been + removed. As a consequence, some functions defined using `with` are + no longer accepted as terminating. See + Issue [#59](https://github.com/agda/agda/issues/59) for why this + feature was originally introduced and + [#3604](https://github.com/agda/agda/issues/3604) for why it had to + be removed. + + The easiest way to fix termination problems caused by `with` is to abstract + over the offending recursive call before any other `with`s. For example + + ```agda + data D : Set where + [_] : Nat → D + + fails : D → Nat + fails [ zero ] = zero + fails [ suc n ] with some-stuff + ... | _ = fails [ n ] + ``` + + This fails termination because the relation between `[ suc n ]` and `[ n ]` + is lost since the generated with-function only gets passed `n`. To fix it we + can abstract over the recursive call: + + ```agda + fixed : D → Nat + fixed [ zero ] = zero + fixed [ suc n ] with fixed [ n ] | some-stuff + ... | rec | _ = rec + ``` + + If the function takes more arguments you might need to abstract over a + partial application to just the structurally recursive argument. For instance, + + ```agda + fails : Nat → D → Nat + fails _ [ zero ] = zero + fails _ [ suc n ] with some-stuff + ... | m = fails m [ n ] + + fixed : Nat → D → Nat + fixed _ [ zero ] = zero + fixed _ [ suc n ] with (λ m → fixed m [ n ]) | some-stuff + ... | rec | m = rec m + ``` + + A possible complication is that later `with`-abstractions might change the + type of the abstracted recursive call: + + ```agda + T : D → Set + suc-T : ∀ {n} → T [ n ] → T [ suc n ] + zero-T : T [ zero ] + + fails : (d : D) → T d + fails [ zero ] = zero-T + fails [ suc n ] with some-stuff + ... | _ with [ n ] + ... | z = suc-T (fails [ n ]) + + still-fails : (d : D) → T d + still-fails [ zero ] = zero-T + still-fails [ suc n ] with still-fails [ n ] | some-stuff + ... | rec | _ with [ n ] + ... | z = suc-T rec -- Type error because rec : T z + ``` + + To solve this problem you can add `rec` to the with-abstraction messing up + its type. This will prevent it from having its type changed: + + ```agda + fixed : (d : D) → T d + fixed [ zero ] = zero-T + fixed [ suc n ] with fixed [ n ] | some-stuff + ... | rec | _ with rec | [ n ] + ... | _ | z = suc-T rec + ``` + +* The termination checker will now try to dispose of recursive calls + by reducing with the non-recursive function clauses. + This eliminates false positives common for definitions by copatterns + using dependent types, + see Issue [#906](https://github.com/agda/agda/issues/906). + + For example, consider the following example using a dependent + coinductive record `Tree`: + ```agda + data Fin : Nat → Set where + fzero : ∀ n → Fin (suc n) + fsuc : ∀ n (i : Fin n) → Fin (suc n) + + toNat : ∀ n → Fin n → Nat + toNat .(suc n) (fzero n) = zero + toNat .(suc n) (fsuc n i) = suc (toNat n i) + + record Tree : Set where + coinductive + field label : Nat + child : Fin label → Tree + open Tree + + tree : Nat → Tree + tree n .label = n + tree n .child i = tree (n + toNat _ i) + ``` + Agda solves the underscore by `tree n .label`, which is a corecursive + call in a non-guarded position, violating the guardedness criterion. + This lead to a complaint of the termination checker. + Now this call is reduced to `n` first using the non-recursive clause + `tree n .label = n`, which leaves us only with the guarded call + `tree (n + toNat n i)`, and the termination checker is happy. + + Note: Similar false positives arose already for non-recursive dependent + records, e.g., when trying to define an inhabitant of the Σ-type by + copattern matching on the projects. + See Issue_[#2068](https://github.com/agda/agda/issues/2068) for a + non-recursive example. + +### Irrelevance and Prop + +* Agda will no longer reduce irrelevant definitions and definitions + with a type in `Prop`. This does not have an effect on the + semantics, but should lead to improved performance (see Issues + [#4115](https://github.com/agda/agda/issues/4115), + [#4118](https://github.com/agda/agda/issues/4118), + [#4120](https://github.com/agda/agda/issues/4120), + [#4122](https://github.com/agda/agda/issues/4122)). + +* Terms of a type in `Prop` are now printed as `_`. To show the actual + term, you can use the `--show-irrelevant` flag (see + Issue [#3337](https://github.com/agda/agda/issues/3337). + +### Rewrite rules + +* Rewrite rules (option `--rewriting`) with data or record types as + the head symbol are no longer allowed (see + Issue [#3846](https://github.com/agda/agda/issues/3846)). + +### Tactics & Reflection + +* Implicit arguments solved by user-defined tactics + + You can declare tactics to be used to solve a particular implicit argument + using the following syntax: + + ```agda + example : {@(tactic f) x : A} → B + ``` + + where `f : Term → TC ⊤`. At calls to `example`, `f` is called on the + metavariable inserted for `x`. `f` can be an arbitrary term and may depend on + previous arguments to the function. For instance, + + ```agda + example₂ : (depth : Nat) {@(tactic search depth) x : A} → B + ``` + + Record fields can also be annotated with a tactic, allowing them to be + omitted in constructor applications, record constructions and co-pattern + matches: + + ```agda + record Example : Set where + constructor mkExample + field x : A + @(tactic solveP x) {y} : P x + ``` + + where `solveP : (x : A) → Term → TC ⊤` is a tactic that tries to + prove `P x` + [Issue [#4124](https://github.com/agda/agda/issues/4124)]. + +* The legacy reflection framework using `quoteGoal` and `quoteContext` has been + removed. + +### Builtins + +* New primitives + + ```agda + primWord64ToNatInjective : ∀ a b → primWord64ToNat a ≡ primWord64ToNat b → a ≡ b + + primFloatToWord64 : Float → Word64 + primFloatToWord64Injective : ∀ a b → primFloatToWord64 a ≡ primFloatToWord64 b → a ≡ b + + primMetaToNat : Meta → Nat + primMetaToNatInjective : ∀ a b → primMetaToNat a ≡ primMetaToNat b → a ≡ b + + primQNameToWord64s : Name → Word64 × Word64 + primQNameToWord64sInjective : ∀ a b → primQNameToWord64s a ≡ primQNameToWord64s b → a ≡ b + ``` + + These can be used to define safe decidable propositional equality, see Issue [agda-stdlib#698](https://github.com/agda/agda-stdlib/issues/698). + +* New Primitive for showing Natural numbers: + + ```agda + primShowNat : Nat → String + ``` + + placed in Agda.Builtin.String. + +* The builtin `IO` has been declared strictly positive in both its + level and type argument. + +### Warnings + +* New warning for a variable shadowing another in a telescope. If the two + variables are introduced in different telescopes then the warning is not + raised. + + ```agda + f : {a : Level} {A : Set a} (a : A) → A -- warning raised: repeated a + g : {a : Level} {A : Set a} → (a : A) → A -- warning not raised: two distinct telescopes + ``` + + Note that this warning is turned off by default (you can use + `-WShadowingInTelescope` or `--warning ShadowingInTelescope` to turn + it on, `-Wall` would also naturally work). + + +Emacs mode +---------- + +* Agda input method: new key bindings `\ G h` and `\ G H` for `η` and + `H` (capital η) + [Issue [#3856](https://github.com/agda/agda/issues/3856)]. + +* Syntax highlighting: in literate modes, the pure texts + (other than Agda code and the code-text separators) are no longer highlighted + (it was highlighted as comments before). + This somehow provides more information about how Agda lexes literate files. + +* Agda now also displays the values of let-bound variables in the + context instead of just their types + [Issue [#4199](https://github.com/agda/agda/issues/4199)]. + +* Agda will now try to preserve the ellipsis (`...`) during case + splitting when possible. To manually expand the ellipsis, you may + ask Agda to case split on the special identifier `.`. + +* Agda will now also show variables named `_` in the context if they + are instance arguments (see + [#4307](https://github.com/agda/agda/issues/4307)). Instance + arguments are now also marked as `(instance)` in the context. Example: + + ```agda + f : {{_ : A}} → A + f = ? + ``` + + Agda will now display the goal as follows: + + ``` + Goal: A + ———————————————————————————————————————————————————————————— + _ : A (instance) + ``` + +* It is now possible to ask Agda to terminate itself after any + previously invoked commands have completed, by giving a prefix + argument to `agda2-term`. + +* The command `agda2-measure-load-time` has been removed. + +GHC Backend +----------- + +* Types which have a COMPILE GHC pragma are no longer erased + [Issue [#3732](https://github.com/agda/agda/issues/3732)]. + + ```agda + data I : Set where + bar : I + + {-# FOREIGN GHC data I = Bar #-} + {-# COMPILE GHC I = data I (Bar) #-} + + data S : Set where + foo : I → S + + {-# FOREIGN GHC data S = Foo I #-} + {-# COMPILE GHC S = data S (Foo) #-} + ``` + Previously [Issue [#2921](https://github.com/agda/agda/issues/2921)], + the last binding was incorrect, since the argument of + singleton type `I` was erased from the constructor `foo` during + compilation. The required shape of `S` was previously + ``` + {-# FOREIGN GHC data S = Foo #-} + ``` + i.e., constructor `Foo` had to have no arguments. + + For the sake of transparency, Haskell constructors bound to + Agda constructors now take the same arguments. + This is especially important if Haskell bindings are to be + produced automatically by third party tool. + +LaTeX backend +------------- + +* Now the code environment complains if it is given unrecognised options. + + It is also possible to write, say, `hide=true` instead of `hide`, + and `hide=false` means that the `hide` option should not be used. + Furthermore the same option can be given multiple times, in which + case later choices take precedence over earlier ones. + +* The code environment has a new option, `number`. + + When the option `number` is used an equation number is generated for + the code listing. The number is set to the right, centered + vertically. By default the number is set in parentheses, but this + can be changed by redefining `\AgdaFormatCodeNumber`. + + The option can optionally be given an argument: when `number=l` is + used a label `l`, referring to the code listing, is generated. It is + possible to use this option several times with different labels. + + The option has no effect if used together with `hide`, `inline` or + `inline*`. + +API +---- +* Removed module `Agda.Utils.HashMap`. It only re-exported `Data.HashMap.Strict` + from the package `unordered-containers`. Use `Data.HashMap.Strict` instead. + +* Removed module `Agda.Utils.Char`. It used to provide functions converting a + `Char` in base 8, 10, and 16 to the corresponding `Int`. Use `digitToInt` in + `Data.Char` instead. The rest of module was about Unicode test which was not + used. + +* `Agda.Utils.List` no longer provides `headMaybe`. + Use `listToMaybe` in `Data.Maybe` instead. + +* `Agda.Utils.Either` no longer provides `mapEither`. Use `bimap` in + `Data.Bifunctor` instead. + +* `Agda.Utils.Map` no longer provides `unionWithM`, `insertWithKeyM`, + `allWithKey`, `unzip`, and `unzip3`. + +Other issues +------------ + +For 2.6.1, the following issues were also closed (see [bug +tracker](https://github.com/agda/agda/issues)): + + - [#470](https://github.com/agda/agda/issues/470): Constraint solving in heterogenous situations + - [#471](https://github.com/agda/agda/issues/471): Emacs command to show goal with constraints on it + - [#500](https://github.com/agda/agda/issues/500): Allow creation of implicit parameters in with blocks + - [#543](https://github.com/agda/agda/issues/543): Irrelevant projections are inconsistent + - [#760](https://github.com/agda/agda/issues/760): Warning for open public in an abstract block + - [#1073](https://github.com/agda/agda/issues/1073): Solve C-c C-s inserts variables that are not in scope + - [#1097](https://github.com/agda/agda/issues/1097): Allow record patterns in lambda-bound positions + - [#1182](https://github.com/agda/agda/issues/1182): Request: allowing the use of patterns in syntax-bound variables + - [#1381](https://github.com/agda/agda/issues/1381): Termination checker rejects function with with-clause + - [#1445](https://github.com/agda/agda/issues/1445): Lack of subject reduction with REWRITE + - [#1820](https://github.com/agda/agda/issues/1820): Case splitting should preserve existing names + - [#2068](https://github.com/agda/agda/issues/2068): Copattern matching: Hyvernat termination would succeed + - [#2148](https://github.com/agda/agda/issues/2148): Option to use use `stack exec` for GHC backend + - [#2170](https://github.com/agda/agda/issues/2170): Two equal irrelevant definitions: one is type checked, the other is not + - [#2284](https://github.com/agda/agda/issues/2284): Disallow duplicate bound variable in lambda and pi + - [#2414](https://github.com/agda/agda/issues/2414): Case splitting loses as-patterns + - [#2498](https://github.com/agda/agda/issues/2498): Resolution of unnamed instances + - [#2512](https://github.com/agda/agda/issues/2512): Propose: Split the changelog + - [#2530](https://github.com/agda/agda/issues/2530): --ignore-interfaces should not recompile Primitive.agda + - [#2535](https://github.com/agda/agda/issues/2535): Expose name id in reflection API + - [#2589](https://github.com/agda/agda/issues/2589): Preserve the ellipsis (dots) when case splitting "with" arguments + - [#2610](https://github.com/agda/agda/issues/2610): Avoid rechecking by storing interfaces in separate directories? + - [#2619](https://github.com/agda/agda/issues/2619): Feature request: link to `renaming` clause + - [#2902](https://github.com/agda/agda/issues/2902): Case-splitting should not generate patterns containing pattern synonyms + - [#3034](https://github.com/agda/agda/issues/3034): Pattern matching without K seemingly illogical for the inductive family of squares + - [#3073](https://github.com/agda/agda/issues/3073): type-in-type and spurious levels + - [#3081](https://github.com/agda/agda/issues/3081): Termination problem: copatterns and without-K + - [#3089](https://github.com/agda/agda/issues/3089): Nicer syntax for implicit @-patterns + - [#3095](https://github.com/agda/agda/issues/3095): Would like to make hidden variable visible but it is created ambiguous + - [#3136](https://github.com/agda/agda/issues/3136): Spurious module parameters printed in extended lambda in termination error + - [#3189](https://github.com/agda/agda/issues/3189): No information about which warnings are enabled by default + - [#3233](https://github.com/agda/agda/issues/3233): Type declarations not accompanied by a definition should be highlighted in the emacs mode + - [#3238](https://github.com/agda/agda/issues/3238): Printing of inserted hidden lambdas + - [#3293](https://github.com/agda/agda/issues/3293): Absurd match in a do block + - [#3295](https://github.com/agda/agda/issues/3295): Allow import of files with incomplete pattern matching + - [#3353](https://github.com/agda/agda/issues/3353): Case splitting turns named arguments into positional arguments + - [#3383](https://github.com/agda/agda/issues/3383): Document the DISPLAY pragma + - [#3417](https://github.com/agda/agda/issues/3417): No highlighting for code that fails termination checking when an error is encountered + - [#3423](https://github.com/agda/agda/issues/3423): Implicit arguments with custom macro for resolution + - [#3432](https://github.com/agda/agda/issues/3432): Highlighting does not work for pattern synonyms in import lists + - [#3493](https://github.com/agda/agda/issues/3493): Impossible to normalize elements in a proposition + - [#3525](https://github.com/agda/agda/issues/3525): Rewrite rules with non-linear patterns do not work in presence of Prop + - [#3545](https://github.com/agda/agda/issues/3545): JavaScript backend: mapping a function that returns Set fails + - [#3574](https://github.com/agda/agda/issues/3574): Support precedent rebind / changing the precedents in builtin library + - [#3582](https://github.com/agda/agda/issues/3582): Error message referring to Set instead of Prop + - [#3594](https://github.com/agda/agda/issues/3594): Occurs check throws error when a solution is possible by eta expansion + - [#3599](https://github.com/agda/agda/issues/3599): Bad performance on pathToEquiv + - [#3606](https://github.com/agda/agda/issues/3606): Do not create/display superfluous metas and show constraints in a readable way + - [#3654](https://github.com/agda/agda/issues/3654): Show non-blocked constraints first in list of unsolved constraints + - [#3695](https://github.com/agda/agda/issues/3695): Generalisation introduces multiple explicit arguments for one generalisable variable + - [#3698](https://github.com/agda/agda/issues/3698): Remove primComp? + - [#3712](https://github.com/agda/agda/issues/3712): Sigma not listed in Built-ins documentation + - [#3724](https://github.com/agda/agda/issues/3724): Internal error with Prop and inductive-inductive type + - [#3725](https://github.com/agda/agda/issues/3725): Support GHC 8.8.1 + - [#3730](https://github.com/agda/agda/issues/3730): Internal error resulting from unused implicit argument + - [#3735](https://github.com/agda/agda/issues/3735): Incorrect context when generalisable variable is used + - [#3736](https://github.com/agda/agda/issues/3736): Safe decidability equality support for Name and Meta + - [#3745](https://github.com/agda/agda/issues/3745): Update user manual on built-ins + - [#3749](https://github.com/agda/agda/issues/3749): Inconsistency: Rounding op differentiates NaNs + - [#3759](https://github.com/agda/agda/issues/3759): Change the default RTS options? + - [#3774](https://github.com/agda/agda/issues/3774): de Bruijn index out of scope with rewrite rules + - [#3776](https://github.com/agda/agda/issues/3776): Conversion check fails too quickly when type could be eta unit type + - [#3779](https://github.com/agda/agda/issues/3779): Incorrectly ordered generalised variables + - [#3785](https://github.com/agda/agda/issues/3785): Comparison of blocked terms doesn't respect eta + - [#3791](https://github.com/agda/agda/issues/3791): Asking Agda to solve a constraint inside a macro + - [#3803](https://github.com/agda/agda/issues/3803): Parse empty field lists + - [#3805](https://github.com/agda/agda/issues/3805): Agda prelude: Internal error at src/full/Agda/TypeChecking/Reduce/Fast.hs:1347 + - [#3807](https://github.com/agda/agda/issues/3807): Internal error related to generalisable variables + - [#3812](https://github.com/agda/agda/issues/3812): Rewriting projected symbols leads to loss of subject reduction + - [#3813](https://github.com/agda/agda/issues/3813): Destructuring leads to invalid premises + - [#3818](https://github.com/agda/agda/issues/3818): For open import M, Agda should remember that M is an external module + - [#3824](https://github.com/agda/agda/issues/3824): rewrite drops named where module + - [#3825](https://github.com/agda/agda/issues/3825): record{M} syntax reports unsolved metas in module M instead of in record expression + - [#3828](https://github.com/agda/agda/issues/3828): Internal error in Agda/TypeChecking/Coverage.hs:467 + - [#3829](https://github.com/agda/agda/issues/3829): Case-split: don't generate pattern covered by unreachable clause + - [#3830](https://github.com/agda/agda/issues/3830): primShow(Char/String) display spurious square brackets + - [#3831](https://github.com/agda/agda/issues/3831): Wrong de Bruijn indices for reflected variables inside an extended context + - [#3843](https://github.com/agda/agda/issues/3843): Internal error with-clause and unification + - [#3851](https://github.com/agda/agda/issues/3851): C-c C-h should default to AsIs rather than Simplified + - [#3866](https://github.com/agda/agda/issues/3866): `--no-unicode` option producing unicode variable names + - [#3878](https://github.com/agda/agda/issues/3878): Case splitting should respect existing input + - [#3879](https://github.com/agda/agda/issues/3879): Only unqualified pattern synonyms should be used for resugaring + - [#3882](https://github.com/agda/agda/issues/3882): de Bruijn index out of scope + - [#3892](https://github.com/agda/agda/issues/3892): Internal error with `data .. where` definitions + - [#3898](https://github.com/agda/agda/issues/3898): Forcing analysis sensitive to normalization + - [#3900](https://github.com/agda/agda/issues/3900): Abstract constructor not usable in function definition involving "with" + - [#3901](https://github.com/agda/agda/issues/3901): Unnamed implicit non-dependent function space {A} -> B and {{A}} -> B + - [#3912](https://github.com/agda/agda/issues/3912): Generalisable variables generate unknown and explicit parameters + - [#3919](https://github.com/agda/agda/issues/3919): Case splitting fails in parameterized module + - [#3927](https://github.com/agda/agda/issues/3927): `import … hiding …` should be documented + - [#3928](https://github.com/agda/agda/issues/3928): The error message `Hiding … has no effect` should be improved + - [#3930](https://github.com/agda/agda/issues/3930): BUILTIN NATURAL internal error at Forcing.hs:232 + - [#3932](https://github.com/agda/agda/issues/3932): Internal error when mixing implicit and explicit mutual blocks + - [#3937](https://github.com/agda/agda/issues/3937): Internal error at "ConcreteToAbstract:1372" + - [#3940](https://github.com/agda/agda/issues/3940): Weird error with piSort and generalization + - [#3943](https://github.com/agda/agda/issues/3943): Print also hidden problematic unification terms + - [#3955](https://github.com/agda/agda/issues/3955): Document module keyword in using/hiding/renaming + - [#3956](https://github.com/agda/agda/issues/3956): Duplicate name in environment buffer with @-pattern + - [#3964](https://github.com/agda/agda/issues/3964): Agda overwrites user-written dotted pattern + - [#3965](https://github.com/agda/agda/issues/3965): Wrong indication of unreachable clauses + - [#3966](https://github.com/agda/agda/issues/3966): All clauses marked when one clause has unification error + - [#3972](https://github.com/agda/agda/issues/3972): Unreachable clause leads to internal error at Serialise/Instances/Internal.hs:94 (MetaV) + - [#3974](https://github.com/agda/agda/issues/3974): Range for unexpected implicit argument on lhs too big + - [#3983](https://github.com/agda/agda/issues/3983): TERMINATING accepted with --safe if hidden in a block + - [#3989](https://github.com/agda/agda/issues/3989): Warn about duplicate bindings in a single telescope + - [#4000](https://github.com/agda/agda/issues/4000): How to get Agda to ignore `~/.agda`? + - [#4006](https://github.com/agda/agda/issues/4006): Internal error related to abstract and variable + - [#4007](https://github.com/agda/agda/issues/4007): Cannot give pattern-matching lambda in abstract setting + - [#4010](https://github.com/agda/agda/issues/4010): unquoteDef fails in abstract block + - [#4012](https://github.com/agda/agda/issues/4012): Internal error when accessing abstract definitions created by unquoteDef/Decl + - [#4020](https://github.com/agda/agda/issues/4020): Rewriting incorrectly considers level variables under lambdas as unbound in the LHS + - [#4032](https://github.com/agda/agda/issues/4032): Loss of subject reduction involving --rewriting even when --confluence-check is on and everything passes the confluence checker + - [#4038](https://github.com/agda/agda/issues/4038): Rewriting sometimes fails to rewrite in the presence of unsolved metas + - [#4044](https://github.com/agda/agda/issues/4044): Equality checking uses too much memory in 2.6.0 (compared to 2.5.4) + - [#4046](https://github.com/agda/agda/issues/4046): Remove (deprecated) codata keyword + - [#4048](https://github.com/agda/agda/issues/4048): Rewriting rule fails to trigger + - [#4049](https://github.com/agda/agda/issues/4049): Internal error with sized types if the target type of a constructor is an alias + - [#4051](https://github.com/agda/agda/issues/4051): Internal error when importing a module with a hole in a type + - [#4053](https://github.com/agda/agda/issues/4053): Emacs-mode: Case split leaves part of old line behind + - [#4059](https://github.com/agda/agda/issues/4059): Two variants of irrefutable with? + - [#4066](https://github.com/agda/agda/issues/4066): Regression related to instance resolution + - [#4116](https://github.com/agda/agda/issues/4116): Internal error Forcing.hs:232 + - [#4121](https://github.com/agda/agda/issues/4121): Pattern synonyms cannot be made private + - [#4125](https://github.com/agda/agda/issues/4125): Type checker normalizes too much + - [#4134](https://github.com/agda/agda/issues/4134): Internal error triggered by missing check for irrelevant meta dependencies + - [#4136](https://github.com/agda/agda/issues/4136): Overzealous pruning of metavariable with irrelevant argument + - [#4141](https://github.com/agda/agda/issues/4141): Printing of DontCare should not use dot syntax + - [#4142](https://github.com/agda/agda/issues/4142): defCopatternLHS needs to be set when record expression were translated to copatterns + - [#4148](https://github.com/agda/agda/issues/4148): Internal error related to records and type-level indices + - [#4152](https://github.com/agda/agda/issues/4152): Variables in Prop position should not raise hard error in occurs check + - [#4154](https://github.com/agda/agda/issues/4154): Renaming declarations within a module may cause name clash + - [#4158](https://github.com/agda/agda/issues/4158): Double check failure (unaware of rewrite rule) + - [#4163](https://github.com/agda/agda/issues/4163): pattern matching in parametrized module leads to ill-typed definitions in where modules. + - [#4170](https://github.com/agda/agda/issues/4170): Tactic causes Agda to enter into an infinite loop + - [#4179](https://github.com/agda/agda/issues/4179): Coverage check false positive + - [#4185](https://github.com/agda/agda/issues/4185): Agda uses η-equality for record types defined with no-eta-equality + - [#4205](https://github.com/agda/agda/issues/4205): Internal error in connection with with, copatterns, and open record + - [#4211](https://github.com/agda/agda/issues/4211): Cannot add as-pattern on literal pattern + - [#4214](https://github.com/agda/agda/issues/4214): `with` abstraction fails with HIT constructors in the goal + - [#4215](https://github.com/agda/agda/issues/4215): Case splitting should respect Nat literals + - [#4255](https://github.com/agda/agda/issues/4255): Hole filler accepted, but type check error on reload + - [#4261](https://github.com/agda/agda/issues/4261): Order of arguments affects lambda pattern matching + - [#4268](https://github.com/agda/agda/issues/4268): Give failure with large quantification + - [#4269](https://github.com/agda/agda/issues/4269): Universe levels are not solved + - [#4283](https://github.com/agda/agda/issues/4283): DeBruijn issue(?) in standard library tests + - [#4289](https://github.com/agda/agda/issues/4289): datatype scope and import guidelines + - [#4297](https://github.com/agda/agda/issues/4297): Missing documentation: NO_UNIVERSE_CHECK pragma + - [#4310](https://github.com/agda/agda/issues/4310): Anonymous .. binder should not lead to a parse error + - [#4314](https://github.com/agda/agda/issues/4314): Internal error with generalize + - [#4320](https://github.com/agda/agda/issues/4320): Path constructor overloading + - [#4323](https://github.com/agda/agda/issues/4323): Internal error (Rewriting.hs:395) with generalize and rewrite rules + - [#4330](https://github.com/agda/agda/issues/4330): Equations for cubical subtypes + - [#4348](https://github.com/agda/agda/issues/4348): Seemingly needless repetition of highlighting of warnings + - [#4360](https://github.com/agda/agda/issues/4360): Missing warning for declaring constructor instances for records with explicit fields + - [#4361](https://github.com/agda/agda/issues/4361): Inconsistent highlighting of BUILTING EQUALITY/REWRITE + - [#4371](https://github.com/agda/agda/issues/4371): Inconsistency with rewrite rules and assumptions in Prop + - [#4373](https://github.com/agda/agda/issues/4373): Non-imported instances are used for instance resolution + - [#4375](https://github.com/agda/agda/issues/4375): Internal error in Agda/TypeChecking/Monad/Context.hs:120 + - [#4380](https://github.com/agda/agda/issues/4380): Parse error with instance constructor and end of file + - [#4382](https://github.com/agda/agda/issues/4382): Rewriting and records with eta + - [#4387](https://github.com/agda/agda/issues/4387): Less responsive Emacs mode in v2.6.1 release candidate 1 + - [#4390](https://github.com/agda/agda/issues/4390): Unification finds solution with bound variable used at wrong modality + - [#4391](https://github.com/agda/agda/issues/4391): Termination checking failed with guardedness + - [#4399](https://github.com/agda/agda/issues/4399): Case split on unnamed argument produces non-sensical code + - [#4401](https://github.com/agda/agda/issues/4401): Missing check on context variables leads to Set:Set with --cumulativity + - [#4404](https://github.com/agda/agda/issues/4404): Disambiguation fails in Cubical Agda + - [#4410](https://github.com/agda/agda/issues/4410): Rewrite rule matching does not respect Prop + - [#4447](https://github.com/agda/agda/issues/4447): Positivity: internal error with projection in constructor type + - [#4451](https://github.com/agda/agda/issues/4451): Highlighting: use several lookups rather than merging hash-maps? + - [#4452](https://github.com/agda/agda/issues/4452): Compiler error when using REWRITE + - [#4469](https://github.com/agda/agda/issues/4469): The warning machinery does not work correctly when interface files are involved + + +The following previously closed issues were reopened: + + - [#1556](https://github.com/agda/agda/issues/1556): Agda allows "very dependent" types diff --git a/LICENSE b/LICENSE --- a/LICENSE +++ b/LICENSE @@ -1,4 +1,4 @@ -Copyright (c) 2005-2019 remains with the authors. +Copyright (c) 2005-2020 remains with the authors. Agda 2 was originally written by Ulf Norell, partially based on code from Agda 1 by Catarina Coquand and Makoto Takeyama, and from Agdalight by Ulf Norell and Andreas Abel. @@ -36,39 +36,6 @@ CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - --------------------------------------------------------------------------------- - -The file src/full/Agda/Utils/Parser/ReadP.hs is Copyright (c) The -University of Glasgow 2002 and is licensed under a BSD-like license as -follows: - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are met: - -- Redistributions of source code must retain the above copyright notice, -this list of conditions and the following disclaimer. - -- Redistributions in binary form must reproduce the above copyright notice, -this list of conditions and the following disclaimer in the documentation -and/or other materials provided with the distribution. - -- Neither name of the University nor the names of its contributors may be -used to endorse or promote products derived from this software without -specific prior written permission. - -THIS SOFTWARE IS PROVIDED BY THE UNIVERSITY COURT OF THE UNIVERSITY OF -GLASGOW AND THE CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, -INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND -FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE -UNIVERSITY COURT OF THE UNIVERSITY OF GLASGOW OR THE CONTRIBUTORS BE LIABLE -FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL -DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR -SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER -CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT -LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY -OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH -DAMAGE. -------------------------------------------------------------------------------- diff --git a/README.md b/README.md --- a/README.md +++ b/README.md @@ -4,9 +4,12 @@ [![Hackage version](https://img.shields.io/hackage/v/Agda.svg?label=Hackage)](http://hackage.haskell.org/package/Agda) [![Stackage version](https://www.stackage.org/package/Agda/badge/lts?label=Stackage)](https://www.stackage.org/package/Agda) [![Travis Status](https://travis-ci.org/agda/agda.svg?branch=master)](https://travis-ci.org/agda/agda) +[![Stack Build Status via GH Actions](https://github.com/agda/agda/workflows/stack%20build/badge.svg)](https://github.com/agda/agda/actions?query=workflow%3A%22stack+build%22) [![Appveyor Status](https://ci.appveyor.com/api/projects/status/x6liln2dol0bg4qw/branch/master?svg=true)](https://ci.appveyor.com/project/gallais/agda) -[![Documentation Status](https://readthedocs.org/projects/agda/badge/?version=latest)](http://agda.readthedocs.io/en/latest/?badge=latest) +[![Documentation Status](https://readthedocs.org/projects/agda/badge/?version=latest)](http://agda.readthedocs.io/en/latest/?badge=latest) [![Join the chat at https://gitter.im/agda/agda](https://badges.gitter.im/agda/agda.svg)](https://gitter.im/agda/agda?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) +![The official Agda logo](doc/user-manual/agda.svg) + Note that this README is only about Agda, not its standard library. See the [Agda Wiki][agdawiki] for information about the library. @@ -15,6 +18,8 @@ ------------- * [User manual](http://agda.readthedocs.io) + (per-commit pdf can be downloaded from the + [github actions](https://github.com/agda/agda/actions?query=workflow%3A%22User+Manual%22) page) * [CHANGELOG](https://github.com/agda/agda/blob/master/CHANGELOG.md) Getting Started @@ -25,9 +30,10 @@ * [Quick guide to editing, type checking and compiling Agda code](http://agda.readthedocs.io/en/latest/getting-started/quick-guide.html) -Hacking on Agda ---------------- +Contributing to Agda +-------------------- -Head to [`HACKING`](https://github.com/agda/agda/blob/master/HACKING.md) +* Contribution how-to: [`HACKING`](https://github.com/agda/agda/blob/master/HACKING.md) +* [Haskell style-guide](https://github.com/andreasabel/haskell-style-guide/blob/master/haskell-style.md) [agdawiki]: http://wiki.portal.chalmers.se/agda/pmwiki.php diff --git a/Setup.hs b/Setup.hs --- a/Setup.hs +++ b/Setup.hs @@ -1,18 +1,16 @@ {-# LANGUAGE CPP #-} +{-# LANGUAGE NondecreasingIndentation #-} +import Data.Maybe + import Distribution.Simple import Distribution.Simple.LocalBuildInfo import Distribution.Simple.Setup import Distribution.Simple.BuildPaths (exeExtension) import Distribution.PackageDescription --- ASR (2019-01-10): The Cabal macro @MIN_VERSION_Cabal@ is avaliable --- from Cabal_>_1.24 so this macro is not supported with the --- "standard" GHC 7.10.3 which is shipped with Cabal 1.22.5.0. -#if __GLASGOW_HASKELL__ >= 800 #if MIN_VERSION_Cabal(2,3,0) import Distribution.System ( buildPlatform ) #endif -#endif import System.FilePath import System.Directory (makeAbsolute, removeFile) import System.Environment (getEnvironment) @@ -20,7 +18,7 @@ import System.Exit import System.IO.Error (isDoesNotExistError) -import Control.Monad (when, forM_) +import Control.Monad (when, forM_, unless) import Control.Exception (catch, throwIO) main :: IO () @@ -51,9 +49,18 @@ buildHook' :: PackageDescription -> LocalBuildInfo -> UserHooks -> BuildFlags -> IO () buildHook' pd lbi hooks flags = do + + -- for debugging, this is examples how you can inspect the flags... + -- print $ flagAssignment lbi + -- print $ fromPathTemplate $ progSuffix lbi + -- build first buildHook simpleUserHooks pd lbi hooks flags + -- Andreas, 2019-10-21, issue #4151: + -- skip the generation of interface files with program suffix "-quicker" + unless (fromPathTemplate (progSuffix lbi) == "-quicker") $ do + -- then... let bdir = buildDir lbi agda = bdir "agda" "agda" <.> agdaExeExtension @@ -75,21 +82,17 @@ removeFile fullpathi `catch` handleExists putStrLn $ "... " ++ fullpath - ok <- rawSystem' ddir agda [ "--no-libraries", fullpath, "-v0" ] + ok <- rawSystem' ddir agda [ "--no-libraries", "--local-interfaces" + , "-Werror" + , fullpath, "-v0" + ] case ok of ExitSuccess -> return () ExitFailure _ -> die $ "Error: Failed to typecheck " ++ fullpath ++ "!" agdaExeExtension :: String --- ASR (2019-01-10): The Cabal macro @MIN_VERSION_Cabal@ is avaliable --- from Cabal_>_1.24 so this macro is not supported with the --- "standard" GHC 7.10.3 which is shipped with Cabal 1.22.5.0. -#if __GLASGOW_HASKELL__ >= 800 #if MIN_VERSION_Cabal(2,3,0) agdaExeExtension = exeExtension buildPlatform -#else -agdaExeExtension = exeExtension -#endif #else agdaExeExtension = exeExtension #endif diff --git a/dist/build/Agda/Syntax/Parser/Lexer.hs b/dist/build/Agda/Syntax/Parser/Lexer.hs --- a/dist/build/Agda/Syntax/Parser/Lexer.hs +++ b/dist/build/Agda/Syntax/Parser/Lexer.hs @@ -42,1389 +42,1400 @@ #endif #if __GLASGOW_HASKELL__ >= 503 import Data.Array -import Data.Array.Base (unsafeAt) -#else -import Array -#endif -#if __GLASGOW_HASKELL__ >= 503 -import GHC.Exts -#else -import GlaExts -#endif -alex_tab_size :: Int -alex_tab_size = 8 -alex_base :: AlexAddr -alex_base = AlexA# - "\xf7\xff\xff\xff\x6c\x00\x00\x00\xe1\x00\x00\x00\x55\x01\x00\x00\xcb\x01\x00\x00\xc1\x02\x00\x00\x36\x03\x00\x00\xac\x03\x00\x00\x73\x00\x00\x00\xd8\xff\xff\xff\x8b\x04\x00\x00\xe9\x04\x00\x00\x47\x05\x00\x00\xcc\x01\x00\x00\xa3\x05\x00\x00\xff\x05\x00\x00\x54\x06\x00\x00\x53\x06\x00\x00\xd3\x06\x00\x00\x53\x07\x00\x00\x32\x08\x00\x00\x31\x08\x00\x00\xb1\x08\x00\x00\x31\x09\x00\x00\xb1\x09\x00\x00\x90\x0a\x00\x00\xec\x0a\x00\x00\xeb\x0a\x00\x00\x00\x00\x00\x00\x5c\x0b\x00\x00\x00\x00\x00\x00\xcd\x0b\x00\x00\x00\x00\x00\x00\x3e\x0c\x00\x00\x00\x00\x00\x00\xaf\x0c\x00\x00\x00\x00\x00\x00\xf0\x0c\x00\x00\x00\x00\x00\x00\x31\x0d\x00\x00\x00\x00\x00\x00\x72\x0d\x00\x00\x00\x00\x00\x00\xb3\x0d\x00\x00\x92\x0e\x00\x00\x11\x0f\x00\x00\xd1\x0e\x00\x00\x00\x00\x00\x00\xd1\x0f\x00\x00\x91\x0f\x00\x00\x00\x00\x00\x00\x91\x10\x00\x00\x51\x10\x00\x00\x00\x00\x00\x00\x51\x11\x00\x00\xc7\x11\x00\x00\x29\x11\x00\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x12\x00\x00\xb5\x13\x00\x00\xac\x14\x00\x00\xa3\x15\x00\x00\x9a\x16\x00\x00\x91\x17\x00\x00\x88\x18\x00\x00\x7f\x19\x00\x00\x76\x1a\x00\x00\x6d\x1b\x00\x00\x64\x1c\x00\x00\x5b\x1d\x00\x00\x52\x1e\x00\x00\x49\x1f\x00\x00\x40\x20\x00\x00\x37\x21\x00\x00\x2e\x22\x00\x00\x25\x23\x00\x00\x1c\x24\x00\x00\x13\x25\x00\x00\x0a\x26\x00\x00\x01\x27\x00\x00\xf8\x27\x00\x00\xef\x28\x00\x00\xe6\x29\x00\x00\xdd\x2a\x00\x00\xd4\x2b\x00\x00\xcb\x2c\x00\x00\xc2\x2d\x00\x00\xb9\x2e\x00\x00\xb0\x2f\x00\x00\xa7\x30\x00\x00\x9e\x31\x00\x00\x95\x32\x00\x00\x8c\x33\x00\x00\x83\x34\x00\x00\x7a\x35\x00\x00\x71\x36\x00\x00\x68\x37\x00\x00\x5f\x38\x00\x00\x56\x39\x00\x00\x4d\x3a\x00\x00\x44\x3b\x00\x00\x3b\x3c\x00\x00\x32\x3d\x00\x00\x29\x3e\x00\x00\x20\x3f\x00\x00\x17\x40\x00\x00\x0e\x41\x00\x00\x05\x42\x00\x00\xfc\x42\x00\x00\xf3\x43\x00\x00\xea\x44\x00\x00\xe1\x45\x00\x00\xd8\x46\x00\x00\xcf\x47\x00\x00\xc6\x48\x00\x00\xbd\x49\x00\x00\xb4\x4a\x00\x00\xab\x4b\x00\x00\xa2\x4c\x00\x00\x99\x4d\x00\x00\x90\x4e\x00\x00\x87\x4f\x00\x00\x7e\x50\x00\x00\x75\x51\x00\x00\x6c\x52\x00\x00\x63\x53\x00\x00\x5a\x54\x00\x00\x51\x55\x00\x00\x48\x56\x00\x00\x3f\x57\x00\x00\x36\x58\x00\x00\x2d\x59\x00\x00\x24\x5a\x00\x00\x1b\x5b\x00\x00\x12\x5c\x00\x00\x09\x5d\x00\x00\x00\x5e\x00\x00\xf7\x5e\x00\x00\xee\x5f\x00\x00\xe5\x60\x00\x00\xdc\x61\x00\x00\xd3\x62\x00\x00\xca\x63\x00\x00\xc1\x64\x00\x00\xb8\x65\x00\x00\xaf\x66\x00\x00\xa6\x67\x00\x00\x9d\x68\x00\x00\x94\x69\x00\x00\x8b\x6a\x00\x00\x82\x6b\x00\x00\x79\x6c\x00\x00\x70\x6d\x00\x00\x67\x6e\x00\x00\x5e\x6f\x00\x00\x55\x70\x00\x00\x4c\x71\x00\x00\x43\x72\x00\x00\x3a\x73\x00\x00\x31\x74\x00\x00\x28\x75\x00\x00\x1f\x76\x00\x00\x16\x77\x00\x00\x0d\x78\x00\x00\x04\x79\x00\x00\xfb\x79\x00\x00\xf2\x7a\x00\x00\xe9\x7b\x00\x00\xe0\x7c\x00\x00\xd7\x7d\x00\x00\xce\x7e\x00\x00\xc5\x7f\x00\x00\xbc\x80\x00\x00\xb3\x81\x00\x00\xaa\x82\x00\x00\xa1\x83\x00\x00\x98\x84\x00\x00\x8f\x85\x00\x00\x86\x86\x00\x00\x7d\x87\x00\x00\x74\x88\x00\x00\x6b\x89\x00\x00\x62\x8a\x00\x00\x59\x8b\x00\x00\x50\x8c\x00\x00\x47\x8d\x00\x00\x3e\x8e\x00\x00\x35\x8f\x00\x00\x2c\x90\x00\x00\x23\x91\x00\x00\x1a\x92\x00\x00\x11\x93\x00\x00\x08\x94\x00\x00\xff\x94\x00\x00\xf6\x95\x00\x00\xed\x96\x00\x00\xe4\x97\x00\x00\xdb\x98\x00\x00\xd2\x99\x00\x00\xc9\x9a\x00\x00\xc0\x9b\x00\x00\xb7\x9c\x00\x00\xae\x9d\x00\x00\xa5\x9e\x00\x00\x9c\x9f\x00\x00\x93\xa0\x00\x00\x8a\xa1\x00\x00\x81\xa2\x00\x00\x78\xa3\x00\x00\x6f\xa4\x00\x00\x66\xa5\x00\x00\x5d\xa6\x00\x00\x54\xa7\x00\x00\x4b\xa8\x00\x00\x42\xa9\x00\x00\x39\xaa\x00\x00\x30\xab\x00\x00\x27\xac\x00\x00\x1e\xad\x00\x00\x15\xae\x00\x00\x0c\xaf\x00\x00\x03\xb0\x00\x00\xfa\xb0\x00\x00\xf1\xb1\x00\x00\xe8\xb2\x00\x00\xdf\xb3\x00\x00\xd6\xb4\x00\x00\xcd\xb5\x00\x00\xc4\xb6\x00\x00\xbb\xb7\x00\x00\xb2\xb8\x00\x00\xa9\xb9\x00\x00\xa0\xba\x00\x00\x97\xbb\x00\x00\x8e\xbc\x00\x00\x85\xbd\x00\x00\x7c\xbe\x00\x00\x73\xbf\x00\x00\x6a\xc0\x00\x00\x61\xc1\x00\x00\x58\xc2\x00\x00\x4f\xc3\x00\x00\x46\xc4\x00\x00\x3d\xc5\x00\x00\x34\xc6\x00\x00\x2b\xc7\x00\x00\x22\xc8\x00\x00\x19\xc9\x00\x00\x10\xca\x00\x00\x07\xcb\x00\x00\xfe\xcb\x00\x00\xf5\xcc\x00\x00\xec\xcd\x00\x00\xe3\xce\x00\x00\xda\xcf\x00\x00\xd1\xd0\x00\x00\xc8\xd1\x00\x00\xbf\xd2\x00\x00\xb6\xd3\x00\x00\xad\xd4\x00\x00\xa4\xd5\x00\x00\x9b\xd6\x00\x00\x92\xd7\x00\x00\x89\xd8\x00\x00\x80\xd9\x00\x00\x77\xda\x00\x00\x6e\xdb\x00\x00\xe3\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x64\xdc\x00\x00\x64\xdd\x00\x00\x64\xde\x00\x00\x5a\xdf\x00\x00\x5a\xe0\x00\x00\x50\xe1\x00\x00\x50\xe2\x00\x00\x50\xe3\x00\x00\x50\xe4\x00\x00\x50\xe5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x13\x00\x00\xa3\x14\x00\x00\x93\xd7\x00\x00\x80\xd8\x00\x00\x65\xdb\x00\x00\x4e\xdc\x00\x00\x44\xdf\x00\x00\x2f\xe6\x00\x00\x8b\xe6\x00\x00\xe7\xe6\x00\x00\x43\xe7\x00\x00\x9f\xe7\x00\x00\xfb\xe7\x00\x00\x57\xe8\x00\x00\xb3\xe8\x00\x00\x0f\xe9\x00\x00\x6b\xe9\x00\x00\xc7\xe9\x00\x00\x23\xea\x00\x00\x7f\xea\x00\x00\xdb\xea\x00\x00\x37\xeb\x00\x00\x93\xeb\x00\x00\xef\xeb\x00\x00\x4b\xec\x00\x00\xa7\xec\x00\x00\x03\xed\x00\x00\x5f\xed\x00\x00\xbb\xed\x00\x00\x17\xee\x00\x00\x73\xee\x00\x00\xcf\xee\x00\x00\x2b\xef\x00\x00\x87\xef\x00\x00\xe3\xef\x00\x00\x3f\xf0\x00\x00\x9b\xf0\x00\x00\xf7\xf0\x00\x00\x53\xf1\x00\x00\xaf\xf1\x00\x00\x0b\xf2\x00\x00\x67\xf2\x00\x00\xc3\xf2\x00\x00\x1f\xf3\x00\x00\x7b\xf3\x00\x00\xd7\xf3\x00\x00\x33\xf4\x00\x00\x8f\xf4\x00\x00\xeb\xf4\x00\x00\x47\xf5\x00\x00\xa3\xf5\x00\x00\xff\xf5\x00\x00\x5b\xf6\x00\x00\xb7\xf6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\xff\xff\xff\xda\xff\xff\xff\x00\x00\x00\x00\x13\xf7\x00\x00\x6f\xf7\x00\x00\x72\xd9\x00\x00\xcb\xf7\x00\x00\x27\xf8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\xff\xff\xff\x00\x00\x00\x00\x83\xf8\x00\x00\x69\xda\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdf\xf8\x00\x00\x3b\xf9\x00\x00\x97\xf9\x00\x00\xf3\xf9\x00\x00\x4f\xfa\x00\x00\xab\xfa\x00\x00\x07\xfb\x00\x00\x63\xfb\x00\x00\xbf\xfb\x00\x00\x1b\xfc\x00\x00\x77\xfc\x00\x00\xd3\xfc\x00\x00\x2f\xfd\x00\x00\x8b\xfd\x00\x00\xe7\xfd\x00\x00\x43\xfe\x00\x00\x9f\xfe\x00\x00\xfb\xfe\x00\x00\x57\xff\x00\x00\xb3\xff\x00\x00\x11\x00\x01\x00\x6f\x00\x01\x00\xcd\x00\x01\x00\x2b\x01\x01\x00\x89\x01\x01\x00\xe7\x01\x01\x00\x45\x02\x01\x00\xa1\x02\x01\x00\xfd\x02\x01\x00\x59\x03\x01\x00\xb5\x03\x01\x00\x11\x04\x01\x00\x6d\x04\x01\x00\xc9\x04\x01\x00\x25\x05\x01\x00\x81\x05\x01\x00\xdd\x05\x01\x00\x39\x06\x01\x00\x95\x06\x01\x00\xf1\x06\x01\x00\x4d\x07\x01\x00\xa9\x07\x01\x00\x05\x08\x01\x00\x61\x08\x01\x00\xbd\x08\x01\x00\x19\x09\x01\x00\x75\x09\x01\x00\xd1\x09\x01\x00\x2d\x0a\x01\x00\x89\x0a\x01\x00\xe5\x0a\x01\x00\x41\x0b\x01\x00\x9d\x0b\x01\x00\xf9\x0b\x01\x00\x55\x0c\x01\x00\xb1\x0c\x01\x00\x0d\x0d\x01\x00\x69\x0d\x01\x00\xc5\x0d\x01\x00\x21\x0e\x01\x00\x7d\x0e\x01\x00\xd9\x0e\x01\x00\x35\x0f\x01\x00\x91\x0f\x01\x00\xed\x0f\x01\x00\x49\x10\x01\x00\xa5\x10\x01\x00\x01\x11\x01\x00\x5d\x11\x01\x00\xb9\x11\x01\x00\x15\x12\x01\x00\x71\x12\x01\x00\xcd\x12\x01\x00\x29\x13\x01\x00\x85\x13\x01\x00\xe1\x13\x01\x00\x3d\x14\x01\x00\x99\x14\x01\x00\xf5\x14\x01\x00\x51\x15\x01\x00\xad\x15\x01\x00\x09\x16\x01\x00\x65\x16\x01\x00\xc1\x16\x01\x00\x1d\x17\x01\x00\x79\x17\x01\x00\xd5\x17\x01\x00\x31\x18\x01\x00\x8d\x18\x01\x00\xe9\x18\x01\x00\x45\x19\x01\x00\xa1\x19\x01\x00\xfd\x19\x01\x00\x59\x1a\x01\x00\xb5\x1a\x01\x00\x11\x1b\x01\x00\x6d\x1b\x01\x00\xc9\x1b\x01\x00\x25\x1c\x01\x00\x81\x1c\x01\x00\xdd\x1c\x01\x00\x39\x1d\x01\x00\x95\x1d\x01\x00\xf1\x1d\x01\x00\x4d\x1e\x01\x00\xa9\x1e\x01\x00\x05\x1f\x01\x00\x61\x1f\x01\x00\xbd\x1f\x01\x00\x19\x20\x01\x00\x75\x20\x01\x00\xd1\x20\x01\x00\x2d\x21\x01\x00\x89\x21\x01\x00\xe5\x21\x01\x00\x41\x22\x01\x00\x9d\x22\x01\x00\xf9\x22\x01\x00\x55\x23\x01\x00\xb1\x23\x01\x00\x0d\x24\x01\x00\x69\x24\x01\x00\xc5\x24\x01\x00\x21\x25\x01\x00\x7d\x25\x01\x00\xd9\x25\x01\x00\x35\x26\x01\x00\x91\x26\x01\x00\xed\x26\x01\x00\x49\x27\x01\x00\xa5\x27\x01\x00\x01\x28\x01\x00\x5d\x28\x01\x00\xb9\x28\x01\x00\x15\x29\x01\x00\x71\x29\x01\x00\xcd\x29\x01\x00\x29\x2a\x01\x00\x85\x2a\x01\x00\xe1\x2a\x01\x00\x3d\x2b\x01\x00\x99\x2b\x01\x00\xf5\x2b\x01\x00\x51\x2c\x01\x00\xad\x2c\x01\x00\x09\x2d\x01\x00\x65\x2d\x01\x00\xc1\x2d\x01\x00\x1d\x2e\x01\x00\x79\x2e\x01\x00\xd5\x2e\x01\x00\x31\x2f\x01\x00\x8d\x2f\x01\x00\xe9\x2f\x01\x00\x45\x30\x01\x00\xa1\x30\x01\x00\xfd\x30\x01\x00\x59\x31\x01\x00\xb5\x31\x01\x00\x11\x32\x01\x00\x6d\x32\x01\x00\xc9\x32\x01\x00\x25\x33\x01\x00\x81\x33\x01\x00\xdd\x33\x01\x00\x39\x34\x01\x00\x95\x34\x01\x00\xf1\x34\x01\x00\x4d\x35\x01\x00\xa9\x35\x01\x00\x05\x36\x01\x00\x61\x36\x01\x00\xbd\x36\x01\x00\x19\x37\x01\x00\x75\x37\x01\x00\xd1\x37\x01\x00\x2d\x38\x01\x00\x89\x38\x01\x00\xe5\x38\x01\x00\x41\x39\x01\x00\x9d\x39\x01\x00\xf9\x39\x01\x00\x55\x3a\x01\x00\xb1\x3a\x01\x00\x0d\x3b\x01\x00\x69\x3b\x01\x00\xc5\x3b\x01\x00\x21\x3c\x01\x00\x7d\x3c\x01\x00\xd9\x3c\x01\x00\x35\x3d\x01\x00\x91\x3d\x01\x00\xed\x3d\x01\x00\x49\x3e\x01\x00\xa5\x3e\x01\x00\x01\x3f\x01\x00\x5d\x3f\x01\x00\xb9\x3f\x01\x00\x15\x40\x01\x00\x71\x40\x01\x00\xcd\x40\x01\x00\x29\x41\x01\x00\x85\x41\x01\x00\xe1\x41\x01\x00\x3d\x42\x01\x00\x99\x42\x01\x00\xf5\x42\x01\x00\x51\x43\x01\x00\xad\x43\x01\x00\x09\x44\x01\x00\x65\x44\x01\x00\xc1\x44\x01\x00\x1d\x45\x01\x00\x79\x45\x01\x00\xd5\x45\x01\x00\x31\x46\x01\x00\x8d\x46\x01\x00\xe9\x46\x01\x00\x45\x47\x01\x00\xa1\x47\x01\x00\xfd\x47\x01\x00\x59\x48\x01\x00\xb5\x48\x01\x00\x11\x49\x01\x00\x6d\x49\x01\x00\xc9\x49\x01\x00\x25\x4a\x01\x00\x81\x4a\x01\x00\xdd\x4a\x01\x00\x39\x4b\x01\x00\x95\x4b\x01\x00\xf1\x4b\x01\x00\x4d\x4c\x01\x00\xa9\x4c\x01\x00\x05\x4d\x01\x00\x61\x4d\x01\x00\xbd\x4d\x01\x00\x19\x4e\x01\x00\x75\x4e\x01\x00\xd1\x4e\x01\x00\x2d\x4f\x01\x00\x89\x4f\x01\x00\xe5\x4f\x01\x00"# - -alex_table :: AlexAddr -alex_table = AlexA# - "\x00\x00\x1d\x01\x3a\x00\x3a\x00\x3a\x00\x10\x01\x3d\x00\x57\x01\x58\x01\x60\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\x3a\x00\xf8\x01\x6b\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x6a\x01\x62\x01\x63\x01\xf8\x01\xf8\x01\xf8\x01\x80\x01\x59\x01\xf8\x01\x72\x01\x70\x01\x70\x01\x70\x01\x70\x01\x70\x01\x70\x01\x70\x01\x70\x01\x70\x01\x5b\x01\x5a\x01\xf8\x01\x5c\x01\xf8\x01\x5e\x01\x66\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x1e\x02\xf8\x01\xf8\x01\xa7\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x65\x01\xf8\x01\xf8\x01\x5d\x01\xf8\x01\xfc\x01\xf8\x01\xd7\x01\x87\x01\xfa\x01\xca\x01\xf8\x01\xe4\x01\x5d\x02\xf8\x01\xf8\x01\x9f\x01\xce\x01\xf7\x01\x22\x02\xe6\x01\xcf\x01\xd8\x01\xe2\x01\xe1\x01\xd3\x01\xf0\x01\xb0\x01\xf8\x01\xf8\x01\xf8\x01\x68\x01\x5f\x01\x69\x01\xf8\x01\x1e\x01\x3a\x00\x3a\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x3a\x00\x3a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x3b\x00\x00\x00\x00\x00\x14\x00\x14\x00\x14\x00\x0a\x00\x3a\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x1a\x00\x14\x00\x14\x00\x19\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x09\x00\x14\x00\x00\x00\x14\x00\x1d\x01\x3a\x00\x3a\x00\x3a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\xf8\x01\x6b\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x6a\x01\x62\x01\x63\x01\xf8\x01\xf8\x01\xf8\x01\x80\x01\x59\x01\xf8\x01\x72\x01\x70\x01\x70\x01\x70\x01\x70\x01\x70\x01\x70\x01\x70\x01\x70\x01\x70\x01\x5b\x01\x5a\x01\xf8\x01\x5c\x01\xf8\x01\x5e\x01\x66\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x1e\x02\xf8\x01\xf8\x01\xa7\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x65\x01\xf8\x01\xf8\x01\x5d\x01\xf8\x01\xfc\x01\xf8\x01\xd7\x01\x87\x01\xfa\x01\xca\x01\xf8\x01\xe4\x01\x5d\x02\xf8\x01\xf8\x01\x9f\x01\xce\x01\xf7\x01\x22\x02\xe6\x01\xcf\x01\xd8\x01\xe2\x01\xe1\x01\xd3\x01\xf0\x01\xb0\x01\xf8\x01\xf8\x01\xf8\x01\x68\x01\x5f\x01\x69\x01\xf8\x01\x3a\x00\x3a\x00\x3a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x00\x00\x00\x00\x14\x00\x14\x00\x14\x00\x0a\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x1a\x00\x14\x00\x14\x00\x19\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x09\x00\x14\x00\x00\x00\x14\x00\xff\xff\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x56\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0f\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x00\x00\xf8\x01\x0d\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\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\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\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\x0c\x01\x00\x00\xf8\x01\x00\x00\xf8\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\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\x31\x00\x13\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x27\x00\x18\x00\x1e\x00\x1e\x00\x1e\x00\x1f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1d\x01\x3a\x00\x3a\x00\x3a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x7f\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x0d\x00\xf8\x01\xf8\x01\x0c\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x9d\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x09\x00\xf8\x01\x00\x00\xf8\x01\x1f\x01\x3a\x00\x3a\x00\x3a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x00\x00\x00\x00\x14\x00\x14\x00\x14\x00\x0a\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x1a\x00\x14\x00\x14\x00\x19\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x09\x00\x14\x00\x00\x00\x14\x00\xff\xff\x3c\x00\x3c\x00\x3c\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\x3c\x00\x00\x00\x6b\x01\x6e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x00\x9e\x00\xa0\x00\x04\x01\x9f\x00\x00\x00\x00\x00\xe5\x00\x00\x00\x00\x00\x7d\x00\xa4\x00\xab\x00\xdf\x00\xaf\x00\x00\x00\xa8\x00\xe2\x00\xbb\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\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x00\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\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x01\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x11\x01\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x00\x00\x14\x00\x14\x00\x14\x00\x0b\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x12\x01\x14\x00\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\x3e\x02\xf8\x01\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\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\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x3e\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\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x0f\x00\x3e\x02\x3e\x02\x0e\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\x00\x00\x3e\x02\x36\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x30\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\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\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x00\x00\x14\x00\x14\x00\x14\x00\x0b\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x00\x00\x14\x00\x2d\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x11\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x13\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\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\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x14\x00\x14\x00\x14\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\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x14\x00\x15\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x25\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\x27\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\x29\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\x2b\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\x2e\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\x31\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\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\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x00\x00\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\x7d\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x0f\x00\x3e\x02\x3e\x02\x0e\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\x00\x00\x3e\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x36\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x38\x00\x11\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2b\x00\x16\x00\x22\x00\x22\x00\x22\x00\x23\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xff\xff\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\x00\x00\xf8\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x30\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\x31\x00\x13\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x27\x00\x18\x00\x1e\x00\x1e\x00\x1e\x00\x1f\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xff\xff\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xe7\x01\xf8\x01\xa2\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x04\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\x00\x00\xf8\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x30\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\x31\x00\x13\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x27\x00\x18\x00\x1e\x00\x1e\x00\x1e\x00\x1f\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\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\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x89\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xec\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xeb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x91\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x93\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe4\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\xc6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x95\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc7\x00\x00\x00\x00\x00\x00\x00\xc9\x00\xce\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xba\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xf8\x01\x3f\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\x00\x00\xf8\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\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\x31\x00\x13\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x27\x00\x18\x00\x1e\x00\x1e\x00\x1e\x00\x1f\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xff\xff\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\x00\x00\xf8\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\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\x30\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\x31\x00\x13\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x27\x00\x18\x00\x1e\x00\x1e\x00\x1e\x00\x1f\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xff\xff\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x0a\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\x00\x00\xf8\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\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\x31\x00\x13\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x27\x00\x18\x00\x1e\x00\x1e\x00\x1e\x00\x1f\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xff\xff\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x0b\x01\xf8\x01\xf8\x01\xf8\x01\xf8\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\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\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\xf8\x01\x00\x00\xf8\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\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\x31\x00\x13\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x27\x00\x18\x00\x1e\x00\x1e\x00\x1e\x00\x1f\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xff\xff\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\x00\x00\xf8\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x30\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\x31\x00\x13\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x27\x00\x18\x00\x1e\x00\x1e\x00\x1e\x00\x1f\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\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\x00\x00\xf8\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2e\x00\x15\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x25\x00\x1b\x00\x1c\x00\x1c\x00\x1c\x00\x1d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\xff\xff\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x00\x00\x16\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x01\x16\x01\x00\x00\x00\x00\x00\x00\x14\x01\x16\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\x16\x01\x00\x00\x00\x00\x00\x00\x00\x00\x16\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\x16\x01\x00\x00\x13\x01\x00\x00\x16\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2e\x00\x15\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x25\x00\x1b\x00\x1c\x00\x1c\x00\x1c\x00\x1d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\xff\xff\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x00\x00\x16\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x01\x16\x01\x00\x00\x00\x00\x00\x00\x14\x01\x16\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\x16\x01\x00\x00\x00\x00\x00\x00\x00\x00\x16\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\x16\x01\x00\x00\x16\x01\x00\x00\x16\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2e\x00\x15\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x25\x00\x1b\x00\x1c\x00\x1c\x00\x1c\x00\x1d\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\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\x00\x00\xf8\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2e\x00\x15\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x25\x00\x1b\x00\x1c\x00\x1c\x00\x1c\x00\x1d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\xff\xff\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x00\x00\x16\x01\x00\x00\x00\x00\x00\x00\x00\x00\x16\x01\x16\x01\x16\x01\x00\x00\x00\x00\x00\x00\x00\x00\x16\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\x16\x01\x00\x00\x00\x00\x00\x00\x00\x00\x16\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\x18\x01\x00\x00\x00\x00\x19\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\x16\x01\x00\x00\x16\x01\x00\x00\x16\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2e\x00\x15\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x25\x00\x1b\x00\x1c\x00\x1c\x00\x1c\x00\x1d\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x00\x00\x1c\x01\x1c\x01\x1c\x01\x1c\x01\x1c\x01\x00\x00\x00\x00\x1c\x01\x1c\x01\x1c\x01\x1c\x01\x00\x00\x1c\x01\x1c\x01\x1c\x01\x1c\x01\x1c\x01\x1c\x01\x1c\x01\x1c\x01\x1c\x01\x1c\x01\x1c\x01\x1c\x01\x00\x00\x1c\x01\x1c\x01\x1c\x01\x1c\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\x1c\x01\x1c\x01\x1c\x01\x1c\x01\x00\x00\x1c\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\x1c\x01\x00\x00\x1c\x01\x00\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\x2d\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2e\x00\x15\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x25\x00\x1b\x00\x1c\x00\x1c\x00\x1c\x00\x1d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\xff\xff\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x00\x00\x16\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x01\x16\x01\x00\x00\x00\x00\x00\x00\x00\x00\x16\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\x16\x01\x00\x00\x00\x00\x00\x00\x00\x00\x16\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\x16\x01\x00\x00\x16\x01\x00\x00\x16\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2e\x00\x15\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x25\x00\x1b\x00\x1c\x00\x1c\x00\x1c\x00\x1d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\xff\xff\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x00\x00\x16\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x01\x16\x01\x00\x00\x00\x00\x00\x00\x1a\x01\x17\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\x16\x01\x00\x00\x00\x00\x00\x00\x00\x00\x16\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\x16\x01\x00\x00\x13\x01\x00\x00\x16\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2e\x00\x15\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x25\x00\x1b\x00\x1c\x00\x1c\x00\x1c\x00\x1d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\xff\xff\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x00\x00\x16\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x01\x16\x01\x00\x00\x00\x00\x00\x00\x1a\x01\x17\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\x16\x01\x00\x00\x00\x00\x00\x00\x00\x00\x16\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\x16\x01\x00\x00\x16\x01\x00\x00\x16\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2e\x00\x15\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x25\x00\x1b\x00\x1c\x00\x1c\x00\x1c\x00\x1d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\xff\xff\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x16\x01\x00\x00\x16\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\x01\x16\x01\x00\x00\x00\x00\x00\x00\x00\x00\x17\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\x16\x01\x00\x00\x00\x00\x00\x00\x00\x00\x16\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\x16\x01\x00\x00\x16\x01\x00\x00\x16\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2e\x00\x15\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x25\x00\x1b\x00\x1c\x00\x1c\x00\x1c\x00\x1d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x35\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x36\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\x42\x01\x41\x01\x41\x01\x41\x01\x41\x01\x41\x01\x41\x01\x41\x01\x41\x01\x41\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\x45\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\x41\x01\x41\x01\x41\x01\x41\x01\x41\x01\x41\x01\x41\x01\x41\x01\x41\x01\x41\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\x41\x01\x41\x01\x41\x01\x41\x01\x41\x01\x41\x01\x41\x01\x41\x01\x41\x01\x41\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x4f\x02\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\x43\x01\x43\x01\x43\x01\x43\x01\x43\x01\x43\x01\x43\x01\x43\x01\x43\x01\x43\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x43\x01\x43\x01\x43\x01\x43\x01\x43\x01\x43\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x43\x01\x43\x01\x43\x01\x43\x01\x43\x01\x43\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\x44\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x4e\x02\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xec\x01\xf8\x01\xf8\x01\xf8\x01\xc1\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xc4\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xaa\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x61\x01\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\x43\x02\xf8\x01\x85\x01\x2c\x00\xf8\x01\x6f\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x6d\x01\x6d\x01\x6d\x01\x6d\x01\x6c\x01\x6d\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\x6c\x01\x6d\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x2c\x00\xf8\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x6d\x01\x6d\x01\x6d\x01\x6d\x01\x6c\x01\x6d\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\x6c\x01\x6d\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x2c\x00\xf8\x01\x6e\x01\x6e\x01\x6e\x01\x6e\x01\x6e\x01\x6e\x01\x6e\x01\x6e\x01\x6e\x01\x6e\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x6e\x01\x6e\x01\x6e\x01\x6e\x01\x6e\x01\x6e\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x6e\x01\x6e\x01\x6e\x01\x6e\x01\x6e\x01\x6e\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x2c\x00\xf8\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x6d\x01\x6d\x01\x6d\x01\x6d\x01\x6c\x01\x6d\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\x6c\x01\x6d\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x3f\x02\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x2c\x00\xf8\x01\x70\x01\x70\x01\x70\x01\x70\x01\x70\x01\x70\x01\x70\x01\x70\x01\x70\x01\x70\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x42\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x42\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x2c\x00\xf8\x01\x71\x01\x71\x01\x71\x01\x71\x01\x71\x01\x71\x01\x71\x01\x71\x01\x71\x01\x71\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x2c\x00\xf8\x01\x70\x01\x70\x01\x70\x01\x70\x01\x70\x01\x70\x01\x70\x01\x70\x01\x70\x01\x70\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x42\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x42\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x46\x02\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x2c\x00\xf8\x01\x71\x01\x71\x01\x71\x01\x71\x01\x71\x01\x71\x01\x71\x01\x71\x01\x71\x01\x71\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x47\x02\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\x74\x01\x74\x01\x74\x01\x74\x01\x74\x01\x74\x01\x74\x01\x74\x01\x74\x01\x74\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x74\x01\x74\x01\x74\x01\x74\x01\x74\x01\x74\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x74\x01\x74\x01\x74\x01\x74\x01\x74\x01\x74\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\x3e\x02\xf8\x01\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x00\x00\x3e\x02\x45\x02\x3e\x02\x45\x02\x10\x00\x3e\x02\x78\x01\x76\x01\x76\x01\x76\x01\x76\x01\x76\x01\x76\x01\x76\x01\x76\x01\x76\x01\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x76\x01\x76\x01\x76\x01\x76\x01\x75\x01\x76\x01\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x76\x01\x76\x01\x76\x01\x76\x01\x75\x01\x76\x01\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x10\x00\x3e\x02\x76\x01\x76\x01\x76\x01\x76\x01\x76\x01\x76\x01\x76\x01\x76\x01\x76\x01\x76\x01\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x76\x01\x76\x01\x76\x01\x76\x01\x75\x01\x76\x01\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x76\x01\x76\x01\x76\x01\x76\x01\x75\x01\x76\x01\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x10\x00\x3e\x02\x77\x01\x77\x01\x77\x01\x77\x01\x77\x01\x77\x01\x77\x01\x77\x01\x77\x01\x77\x01\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x77\x01\x77\x01\x77\x01\x77\x01\x77\x01\x77\x01\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x77\x01\x77\x01\x77\x01\x77\x01\x77\x01\x77\x01\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x10\x00\x3e\x02\x76\x01\x76\x01\x76\x01\x76\x01\x76\x01\x76\x01\x76\x01\x76\x01\x76\x01\x76\x01\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x76\x01\x76\x01\x76\x01\x76\x01\x75\x01\x76\x01\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x76\x01\x76\x01\x76\x01\x76\x01\x75\x01\x76\x01\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x40\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\xf8\x01\x3e\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\x79\x01\x79\x01\x79\x01\x79\x01\x79\x01\x79\x01\x79\x01\x79\x01\x79\x01\x79\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\x79\x01\x79\x01\x79\x01\x79\x01\x79\x01\x79\x01\x79\x01\x79\x01\x79\x01\x79\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x3f\x02\xf8\x01\xf8\x01\x00\x00\xf8\x01\x3e\x02\xf8\x01\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x10\x00\x3e\x02\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x44\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x44\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x10\x00\x3e\x02\x7c\x01\x7c\x01\x7c\x01\x7c\x01\x7c\x01\x7c\x01\x7c\x01\x7c\x01\x7c\x01\x7c\x01\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x10\x00\x3e\x02\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x44\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x44\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x41\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x10\x00\x3e\x02\x7c\x01\x7c\x01\x7c\x01\x7c\x01\x7c\x01\x7c\x01\x7c\x01\x7c\x01\x7c\x01\x7c\x01\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x40\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\xf8\x01\x3e\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x1a\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\x11\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x1a\x01\x10\x00\xf8\x01\x73\x01\x71\x01\x71\x01\x71\x01\x71\x01\x71\x01\x71\x01\x71\x01\x71\x01\x71\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\x64\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\x11\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xee\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\x12\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xef\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\x12\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf9\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\x12\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\x12\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\x7a\x01\x79\x01\x79\x01\x79\x01\x79\x01\x79\x01\x79\x01\x79\x01\x79\x01\x79\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\x12\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x22\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x35\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x23\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x26\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x27\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x28\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x2b\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x2c\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x2d\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x30\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x31\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x32\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x33\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x39\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x3a\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x3c\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x48\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x49\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x4a\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x4d\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x50\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x51\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x52\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x53\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x54\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x55\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x5e\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x5a\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x57\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x56\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x55\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x54\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x93\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x53\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x52\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x51\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x4d\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x4a\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x98\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x49\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x9e\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x3d\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x3c\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xae\x01\x3b\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x3a\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x39\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x38\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x37\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x36\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x34\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x33\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x32\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x31\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x30\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x2f\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xa3\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xa4\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x2e\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x2d\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x2c\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xa9\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x2b\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x2a\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x29\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x28\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x27\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x25\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x24\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x23\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xaf\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x0b\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xb7\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xe5\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x19\x02\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x21\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x20\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xbf\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x15\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x0f\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xc3\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xc5\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x1d\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x1b\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xe0\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xc7\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xc9\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x18\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x17\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x14\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xcb\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xcc\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x13\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x12\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x11\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x10\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x0d\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x0c\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xd0\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xd1\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x09\x02\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xd2\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x07\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xd4\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x02\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xed\x01\xf8\x01\xf8\x01\xde\x01\xf8\x01\xf8\x01\x06\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xda\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xdb\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xdc\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xdd\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x05\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x03\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x01\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xe9\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xea\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xff\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xfe\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x81\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x82\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf2\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf3\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x83\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf6\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf5\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf4\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xfd\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xeb\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xe8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xe3\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xd9\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xd5\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x08\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x0a\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xcd\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x0e\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x1a\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xc8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xc6\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x1c\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xc2\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xc0\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x1f\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xd6\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xbe\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xbd\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xbc\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xbb\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xba\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xb9\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xb8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xb6\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xfb\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf1\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xb5\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xb4\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xb3\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xb2\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xb1\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xad\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x26\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xac\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xab\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xa8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xa6\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xa5\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xa1\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xa0\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xdf\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x9c\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x9b\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x9a\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x99\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x48\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x97\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x96\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x95\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x4c\x02\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x50\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x94\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x92\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x91\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x90\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x8f\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x8e\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x58\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x8d\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x8c\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x8b\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x59\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x8a\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x89\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x88\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x5b\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x5c\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x86\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\x3e\x02\xf8\x01\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x10\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\xf8\x01\x3e\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\x74\x01\x74\x01\x74\x01\x74\x01\x74\x01\x74\x01\x74\x01\x74\x01\x74\x01\x74\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x74\x01\x74\x01\x74\x01\x74\x01\x74\x01\x74\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x74\x01\x74\x01\x74\x01\x74\x01\x74\x01\x74\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\x3e\x02\xf8\x01\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x10\x00\x3e\x02\x77\x01\x77\x01\x77\x01\x77\x01\x77\x01\x77\x01\x77\x01\x77\x01\x77\x01\x77\x01\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x77\x01\x77\x01\x77\x01\x77\x01\x77\x01\x77\x01\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x77\x01\x77\x01\x77\x01\x77\x01\x77\x01\x77\x01\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x10\x00\x3e\x02\x76\x01\x76\x01\x76\x01\x76\x01\x76\x01\x76\x01\x76\x01\x76\x01\x76\x01\x76\x01\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x76\x01\x76\x01\x76\x01\x76\x01\x76\x01\x76\x01\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x76\x01\x76\x01\x76\x01\x76\x01\x76\x01\x76\x01\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\xf8\x01\x3e\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\x43\x02\xf8\x01\x85\x01\x10\x00\xf8\x01\x7a\x01\x79\x01\x79\x01\x79\x01\x79\x01\x79\x01\x79\x01\x79\x01\x79\x01\x79\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\x7a\x01\x79\x01\x79\x01\x79\x01\x79\x01\x79\x01\x79\x01\x79\x01\x79\x01\x79\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\x3e\x02\xf8\x01\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x00\x00\x3e\x02\x45\x02\x3e\x02\x45\x02\x10\x00\x3e\x02\x7e\x01\x7c\x01\x7c\x01\x7c\x01\x7c\x01\x7c\x01\x7c\x01\x7c\x01\x7c\x01\x7c\x01\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x10\x00\x3e\x02\x7e\x01\x7c\x01\x7c\x01\x7c\x01\x7c\x01\x7c\x01\x7c\x01\x7c\x01\x7c\x01\x7c\x01\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x3e\x02\x00\x00\x3e\x02\xf8\x01\x3e\x02\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x6d\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\x6d\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\x6e\x01\x6e\x01\x6e\x01\x6e\x01\x6e\x01\x6e\x01\x6e\x01\x6e\x01\x6e\x01\x6e\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x6e\x01\x6e\x01\x6e\x01\x6e\x01\x6e\x01\x6e\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x6e\x01\x6e\x01\x6e\x01\x6e\x01\x6e\x01\x6e\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x4f\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x4e\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x4b\x02\xf8\x01\xf8\x01\x4c\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x4b\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x47\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x46\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\x43\x01\x43\x01\x43\x01\x43\x01\x43\x01\x43\x01\x43\x01\x43\x01\x43\x01\x43\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x43\x01\x43\x01\x43\x01\x43\x01\x43\x01\x43\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x43\x01\x43\x01\x43\x01\x43\x01\x43\x01\x43\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\x40\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x3f\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x3e\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x3d\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x3b\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x38\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x37\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x34\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x2f\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x2e\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x2a\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x29\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x25\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x24\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x16\x02\x21\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\x00\x00\xf8\x01\xf8\x01\xf8\x01\x84\x01\x10\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x20\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\xf8\x01\x00\x00\xf8\x01\x00\x00\xf8\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"# - -alex_check :: AlexAddr -alex_check = AlexA# - "\xff\xff\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x2d\x00\x23\x00\x2e\x00\x2e\x00\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\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\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x20\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x20\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\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\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\xff\xff\x7e\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\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\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\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\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\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\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\xff\xff\x7e\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x21\x00\x23\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\x5c\x00\x5d\x00\x5e\x00\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\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\x7b\x00\xff\xff\x7c\x00\xff\xff\x7e\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x2c\x00\x2d\x00\xff\xff\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\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\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\xff\xff\x7e\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x2c\x00\x2d\x00\xff\xff\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\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\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\xff\xff\x7e\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\x00\x23\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\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\x52\x00\x53\x00\x54\x00\xff\xff\xff\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\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\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\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\xff\xff\x7c\x00\x7d\x00\x7e\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\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\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\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\xff\xff\x7c\x00\x7d\x00\x7e\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\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\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\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\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\x5c\x00\x5d\x00\x5e\x00\xff\xff\x60\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\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x7c\x00\xff\xff\x7e\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\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\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\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\xff\xff\x7c\x00\xff\xff\x7e\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\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\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\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\xff\xff\x7c\x00\xff\xff\x7e\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\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\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\x5c\x00\x5d\x00\x5e\x00\xff\xff\x60\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\x7c\x00\xff\xff\x7e\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\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\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\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\xff\xff\x7c\x00\xff\xff\x7e\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\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\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\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\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\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\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\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\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\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\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\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\x7f\x00\x0a\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\x21\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\x20\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\x20\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\x00\x23\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x7d\x00\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x59\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x41\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4b\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4b\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4b\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x47\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x59\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x43\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x47\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x47\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x41\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x43\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x43\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x43\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x47\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x41\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x55\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x41\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x41\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x43\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4d\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x43\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x41\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x43\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x43\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x43\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x41\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x41\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x41\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x55\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x55\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x41\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\x4f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\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\x5f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x5f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x5f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x5f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x5f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x59\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4d\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4d\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x5f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x47\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x41\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x5f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4d\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x50\x00\xff\xff\xff\xff\xff\xff\x54\x00\x55\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x41\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x52\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x52\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x54\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x54\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x56\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x54\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x56\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x52\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x52\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x52\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x54\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4c\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x54\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x54\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x54\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4d\x00\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x52\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x54\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x52\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x52\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x54\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x48\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x48\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x48\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4c\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4a\x00\xff\xff\x4c\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x54\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x48\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4c\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x54\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x42\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4c\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x54\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x54\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x54\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x52\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x56\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4c\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x54\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4c\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4c\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4c\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x21\x00\x23\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\xff\xff\x7e\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\x20\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7d\x00\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x20\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\x2d\x00\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\xff\xff\x7e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x20\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\x2d\x00\x3c\x00\x3d\x00\x3e\x00\x3f\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\x5b\x00\x5c\x00\x5d\x00\x5e\x00\xff\xff\x60\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\x7c\x00\xff\xff\x7e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\x20\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\xff\xff\x7e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\x29\x00\xff\xff\xff\xff\xff\xff\x2d\x00\x2e\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\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x40\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\x7b\x00\xff\xff\x7d\x00\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\x29\x00\xff\xff\xff\xff\xff\xff\x2d\x00\x2e\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\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x40\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\x7b\x00\xff\xff\x7d\x00\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\xff\xff\x7e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2e\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\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x40\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\x5c\x00\xff\xff\xff\xff\x5f\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\x7b\x00\xff\xff\x7d\x00\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\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\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\x5c\x00\x5d\x00\x5e\x00\xff\xff\x60\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\x7c\x00\xff\xff\x7e\x00\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\x29\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2e\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\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x40\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\x7b\x00\xff\xff\x7d\x00\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\x29\x00\xff\xff\xff\xff\xff\xff\x2d\x00\x2e\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\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x40\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\x7b\x00\xff\xff\x7d\x00\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\x29\x00\xff\xff\xff\xff\xff\xff\x2d\x00\x2e\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\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x40\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\x7b\x00\xff\xff\x7d\x00\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\x29\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2e\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\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x40\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\x7b\x00\xff\xff\x7d\x00\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x7d\x00\x7e\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x7d\x00\x7e\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x7d\x00\x7e\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x7d\x00\x7e\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x7d\x00\x7e\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x7d\x00\x7e\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x7d\x00\x7e\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\xff\xff\x7e\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"# - -alex_deflt :: AlexAddr -alex_deflt = AlexA# - "\xff\xff\xff\xff\xff\xff\xff\xff\x0e\x01\xff\xff\xff\xff\xca\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\x24\x00\x24\x00\x26\x00\x26\x00\x28\x00\x28\x00\x2a\x00\x2a\x00\x2f\x00\x2f\x00\x32\x00\x32\x00\x35\x00\x35\x00\x39\x00\x39\x00\xff\xff\x16\x01\x16\x01\x16\x01\x0e\x01\x0e\x01\x0e\x01\xca\x00\xca\x00\xca\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xca\x00\x0e\x01\x0e\x01\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\xca\x00\x0e\x01\x0e\x01\x0e\x01\x0e\x01\x0e\x01\xff\xff\xff\xff\xff\xff\xff\xff\x16\x01\x15\x01\x15\x01\x16\x01\x1c\x01\x16\x01\x1c\x01\x1b\x01\x1b\x01\x1c\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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, 606) - [ AlexAccNone - , AlexAccPred 549 ( not' eof )(AlexAccNone) - , AlexAccNone - , AlexAcc 548 - , AlexAccNone - , AlexAccNone - , AlexAcc 547 - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccNone - , AlexAccSkip - , AlexAccSkip - , AlexAccSkip - , AlexAcc 546 - , AlexAcc 545 - , AlexAcc 544 - , AlexAcc 543 - , AlexAcc 542 - , AlexAcc 541 - , AlexAcc 540 - , AlexAcc 539 - , AlexAcc 538 - , AlexAcc 537 - , AlexAcc 536 - , AlexAcc 535 - , AlexAcc 534 - , AlexAcc 533 - , AlexAcc 532 - , AlexAcc 531 - , AlexAcc 530 - , AlexAcc 529 - , AlexAcc 528 - , AlexAcc 527 - , AlexAcc 526 - , AlexAcc 525 - , AlexAcc 524 - , AlexAcc 523 - , AlexAcc 522 - , AlexAcc 521 - , AlexAcc 520 - , AlexAcc 519 - , AlexAcc 518 - , AlexAcc 517 - , AlexAcc 516 - , AlexAcc 515 - , AlexAcc 514 - , AlexAcc 513 - , AlexAcc 512 - , AlexAcc 511 - , AlexAcc 510 - , AlexAcc 509 - , AlexAcc 508 - , AlexAcc 507 - , AlexAcc 506 - , AlexAcc 505 - , AlexAcc 504 - , AlexAcc 503 - , AlexAcc 502 - , AlexAcc 501 - , AlexAcc 500 - , AlexAcc 499 - , AlexAcc 498 - , AlexAcc 497 - , AlexAcc 496 - , AlexAcc 495 - , AlexAcc 494 - , AlexAcc 493 - , AlexAcc 492 - , AlexAcc 491 - , AlexAcc 490 - , AlexAcc 489 - , AlexAcc 488 - , AlexAcc 487 - , AlexAcc 486 - , AlexAcc 485 - , AlexAcc 484 - , AlexAcc 483 - , AlexAcc 482 - , AlexAcc 481 - , AlexAcc 480 - , AlexAcc 479 - , AlexAcc 478 - , AlexAcc 477 - , AlexAcc 476 - , AlexAcc 475 - , AlexAcc 474 - , AlexAcc 473 - , AlexAcc 472 - , AlexAcc 471 - , AlexAcc 470 - , AlexAcc 469 - , AlexAcc 468 - , AlexAcc 467 - , AlexAcc 466 - , AlexAcc 465 - , AlexAcc 464 - , AlexAcc 463 - , AlexAcc 462 - , AlexAcc 461 - , AlexAcc 460 - , AlexAcc 459 - , AlexAcc 458 - , AlexAcc 457 - , AlexAcc 456 - , AlexAcc 455 - , AlexAcc 454 - , AlexAcc 453 - , AlexAcc 452 - , AlexAcc 451 - , AlexAcc 450 - , AlexAcc 449 - , AlexAcc 448 - , AlexAcc 447 - , AlexAcc 446 - , AlexAcc 445 - , AlexAcc 444 - , AlexAcc 443 - , AlexAcc 442 - , AlexAcc 441 - , AlexAcc 440 - , AlexAcc 439 - , AlexAcc 438 - , AlexAcc 437 - , AlexAcc 436 - , AlexAcc 435 - , AlexAcc 434 - , AlexAcc 433 - , AlexAcc 432 - , AlexAcc 431 - , AlexAcc 430 - , AlexAcc 429 - , AlexAcc 428 - , AlexAcc 427 - , AlexAcc 426 - , AlexAcc 425 - , AlexAcc 424 - , AlexAcc 423 - , AlexAcc 422 - , AlexAcc 421 - , AlexAcc 420 - , AlexAcc 419 - , AlexAcc 418 - , AlexAcc 417 - , AlexAcc 416 - , AlexAcc 415 - , AlexAcc 414 - , AlexAcc 413 - , AlexAcc 412 - , AlexAcc 411 - , AlexAcc 410 - , AlexAcc 409 - , AlexAcc 408 - , AlexAcc 407 - , AlexAcc 406 - , AlexAcc 405 - , AlexAcc 404 - , AlexAcc 403 - , AlexAcc 402 - , AlexAcc 401 - , AlexAcc 400 - , AlexAcc 399 - , AlexAcc 398 - , AlexAcc 397 - , AlexAcc 396 - , AlexAcc 395 - , AlexAcc 394 - , AlexAcc 393 - , AlexAcc 392 - , AlexAcc 391 - , AlexAcc 390 - , AlexAcc 389 - , AlexAcc 388 - , AlexAcc 387 - , AlexAcc 386 - , AlexAcc 385 - , AlexAcc 384 - , AlexAcc 383 - , AlexAcc 382 - , AlexAcc 381 - , AlexAcc 380 - , AlexAcc 379 - , AlexAcc 378 - , AlexAcc 377 - , AlexAcc 376 - , AlexAcc 375 - , AlexAcc 374 - , AlexAcc 373 - , AlexAcc 372 - , AlexAcc 371 - , AlexAcc 370 - , AlexAcc 369 - , AlexAcc 368 - , AlexAcc 367 - , AlexAcc 366 - , AlexAcc 365 - , AlexAcc 364 - , AlexAcc 363 - , AlexAcc 362 - , AlexAcc 361 - , AlexAcc 360 - , AlexAcc 359 - , AlexAcc 358 - , AlexAcc 357 - , AlexAcc 356 - , AlexAcc 355 - , AlexAcc 354 - , AlexAcc 353 - , AlexAcc 352 - , AlexAcc 351 - , AlexAcc 350 - , AlexAcc 349 - , AlexAcc 348 - , AlexAcc 347 - , AlexAcc 346 - , AlexAcc 345 - , AlexAcc 344 - , AlexAcc 343 - , AlexAcc 342 - , AlexAcc 341 - , AlexAcc 340 - , AlexAcc 339 - , AlexAcc 338 - , AlexAcc 337 - , AlexAccPred 336 ( not' (followedBy '#') )(AlexAccNone) - , AlexAccPred 335 ( not' (followedBy '#') )(AlexAccNone) - , AlexAcc 334 - , AlexAcc 333 - , AlexAcc 332 - , AlexAccPred 331 ( keepComments .&&. (followedBy '\n' .||. eof) )(AlexAccSkipPred ( followedBy '\n' .||. eof )(AlexAccNone)) - , AlexAccPred 330 ( keepComments .&&. (followedBy '\n' .||. eof) )(AlexAccSkipPred ( followedBy '\n' .||. eof )(AlexAccNone)) - , AlexAccPred 329 ( keepComments .&&. (followedBy '\n' .||. eof) )(AlexAccSkipPred ( followedBy '\n' .||. eof )(AlexAccNone)) - , AlexAccPred 328 ( keepComments .&&. (followedBy '\n' .||. eof) )(AlexAccSkipPred ( followedBy '\n' .||. eof )(AlexAccNone)) - , AlexAccPred 327 ( keepComments .&&. (followedBy '\n' .||. eof) )(AlexAccSkipPred ( followedBy '\n' .||. eof )(AlexAccNone)) - , AlexAccPred 326 ( keepComments .&&. (followedBy '\n' .||. eof) )(AlexAccSkipPred ( followedBy '\n' .||. eof )(AlexAccNone)) - , AlexAccPred 325 ( keepComments .&&. (followedBy '\n' .||. eof) )(AlexAccSkipPred ( followedBy '\n' .||. eof )(AlexAcc 324)) - , AlexAccPred 323 ( keepComments .&&. (followedBy '\n' .||. eof) )(AlexAccSkipPred ( followedBy '\n' .||. eof )(AlexAcc 322)) - , AlexAccPred 321 ( keepComments .&&. (followedBy '\n' .||. eof) )(AlexAccSkipPred ( followedBy '\n' .||. eof )(AlexAcc 320)) - , AlexAcc 319 - , AlexAccSkip - , AlexAccSkip - , AlexAcc 318 - , AlexAcc 317 - , AlexAcc 316 - , AlexAcc 315 - , AlexAcc 314 - , AlexAcc 313 - , AlexAcc 312 - , AlexAcc 311 - , AlexAcc 310 - , AlexAcc 309 - , AlexAcc 308 - , AlexAcc 307 - , AlexAcc 306 - , AlexAcc 305 - , AlexAcc 304 - , AlexAcc 303 - , AlexAcc 302 - , AlexAcc 301 - , AlexAcc 300 - , AlexAcc 299 - , AlexAcc 298 - , AlexAcc 297 - , AlexAcc 296 - , AlexAcc 295 - , AlexAcc 294 - , AlexAcc 293 - , AlexAcc 292 - , AlexAcc 291 - , AlexAcc 290 - , AlexAcc 289 - , AlexAcc 288 - , AlexAcc 287 - , AlexAcc 286 - , AlexAcc 285 - , AlexAcc 284 - , AlexAcc 283 - , AlexAcc 282 - , AlexAcc 281 - , AlexAcc 280 - , AlexAcc 279 - , AlexAcc 278 - , AlexAcc 277 - , AlexAcc 276 - , AlexAcc 275 - , AlexAcc 274 - , AlexAcc 273 - , AlexAcc 272 - , AlexAcc 271 - , AlexAcc 270 - , AlexAcc 269 - , AlexAcc 268 - , AlexAcc 267 - , AlexAcc 266 - , AlexAcc 265 - , AlexAcc 264 - , AlexAcc 263 - , AlexAcc 262 - , AlexAcc 261 - , AlexAcc 260 - , AlexAcc 259 - , AlexAcc 258 - , AlexAcc 257 - , AlexAcc 256 - , AlexAcc 255 - , AlexAccPred 254 (alexRightContext 8)(AlexAccNone) - , AlexAcc 253 - , AlexAcc 252 - , AlexAcc 251 - , AlexAcc 250 - , AlexAcc 249 - , AlexAcc 248 - , AlexAccPred 247 (alexRightContext 55)(AlexAccNone) - , AlexAcc 246 - , AlexAcc 245 - , AlexAcc 244 - , AlexAcc 243 - , AlexAcc 242 - , AlexAcc 241 - , AlexAcc 240 - , AlexAcc 239 - , AlexAcc 238 - , AlexAcc 237 - , AlexAcc 236 - , AlexAcc 235 - , AlexAcc 234 - , AlexAcc 233 - , AlexAcc 232 - , AlexAcc 231 - , AlexAcc 230 - , AlexAcc 229 - , AlexAcc 228 - , AlexAcc 227 - , AlexAcc 226 - , AlexAcc 225 - , AlexAcc 224 - , AlexAcc 223 - , AlexAcc 222 - , AlexAcc 221 - , AlexAcc 220 - , AlexAcc 219 - , AlexAcc 218 - , AlexAcc 217 - , AlexAcc 216 - , AlexAcc 215 - , AlexAcc 214 - , AlexAcc 213 - , AlexAcc 212 - , AlexAcc 211 - , AlexAcc 210 - , AlexAcc 209 - , AlexAcc 208 - , AlexAcc 207 - , AlexAcc 206 - , AlexAcc 205 - , AlexAcc 204 - , AlexAcc 203 - , AlexAcc 202 - , AlexAcc 201 - , AlexAcc 200 - , AlexAcc 199 - , AlexAcc 198 - , AlexAcc 197 - , AlexAcc 196 - , AlexAcc 195 - , AlexAcc 194 - , AlexAcc 193 - , AlexAcc 192 - , AlexAcc 191 - , AlexAcc 190 - , AlexAcc 189 - , AlexAcc 188 - , AlexAcc 187 - , AlexAcc 186 - , AlexAcc 185 - , AlexAcc 184 - , AlexAcc 183 - , AlexAcc 182 - , AlexAcc 181 - , AlexAcc 180 - , AlexAcc 179 - , AlexAcc 178 - , AlexAcc 177 - , AlexAcc 176 - , AlexAcc 175 - , AlexAcc 174 - , AlexAcc 173 - , AlexAcc 172 - , AlexAcc 171 - , AlexAcc 170 - , AlexAcc 169 - , AlexAcc 168 - , AlexAcc 167 - , AlexAcc 166 - , AlexAcc 165 - , AlexAcc 164 - , AlexAcc 163 - , AlexAcc 162 - , AlexAcc 161 - , AlexAcc 160 - , AlexAcc 159 - , AlexAcc 158 - , AlexAcc 157 - , AlexAcc 156 - , AlexAcc 155 - , AlexAcc 154 - , AlexAcc 153 - , AlexAcc 152 - , AlexAcc 151 - , AlexAcc 150 - , AlexAcc 149 - , AlexAcc 148 - , AlexAcc 147 - , AlexAcc 146 - , AlexAcc 145 - , AlexAcc 144 - , AlexAcc 143 - , AlexAcc 142 - , AlexAcc 141 - , AlexAcc 140 - , AlexAcc 139 - , AlexAcc 138 - , AlexAcc 137 - , AlexAcc 136 - , AlexAcc 135 - , AlexAcc 134 - , AlexAcc 133 - , AlexAcc 132 - , AlexAcc 131 - , AlexAcc 130 - , AlexAcc 129 - , AlexAcc 128 - , AlexAcc 127 - , AlexAcc 126 - , AlexAcc 125 - , AlexAcc 124 - , AlexAcc 123 - , AlexAcc 122 - , AlexAcc 121 - , AlexAcc 120 - , AlexAcc 119 - , AlexAcc 118 - , AlexAcc 117 - , AlexAcc 116 - , AlexAcc 115 - , AlexAcc 114 - , AlexAcc 113 - , AlexAcc 112 - , AlexAcc 111 - , AlexAcc 110 - , AlexAcc 109 - , AlexAcc 108 - , AlexAcc 107 - , AlexAcc 106 - , AlexAcc 105 - , AlexAcc 104 - , AlexAcc 103 - , AlexAcc 102 - , AlexAcc 101 - , AlexAcc 100 - , AlexAcc 99 - , AlexAcc 98 - , AlexAcc 97 - , AlexAcc 96 - , AlexAcc 95 - , AlexAcc 94 - , AlexAcc 93 - , AlexAcc 92 - , AlexAcc 91 - , AlexAcc 90 - , AlexAcc 89 - , AlexAcc 88 - , AlexAcc 87 - , AlexAcc 86 - , AlexAcc 85 - , AlexAcc 84 - , AlexAcc 83 - , AlexAcc 82 - , AlexAcc 81 - , AlexAcc 80 - , AlexAcc 79 - , AlexAcc 78 - , AlexAcc 77 - , AlexAcc 76 - , AlexAcc 75 - , AlexAcc 74 - , AlexAcc 73 - , AlexAcc 72 - , AlexAcc 71 - , AlexAcc 70 - , AlexAcc 69 - , AlexAcc 68 - , AlexAcc 67 - , AlexAcc 66 - , AlexAcc 65 - , AlexAcc 64 - , AlexAcc 63 - , AlexAcc 62 - , AlexAcc 61 - , AlexAcc 60 - , AlexAcc 59 - , AlexAcc 58 - , AlexAcc 57 - , AlexAcc 56 - , AlexAcc 55 - , AlexAcc 54 - , AlexAcc 53 - , AlexAcc 52 - , AlexAcc 51 - , AlexAcc 50 - , AlexAcc 49 - , AlexAcc 48 - , AlexAcc 47 - , AlexAcc 46 - , AlexAcc 45 - , AlexAcc 44 - , AlexAcc 43 - , AlexAcc 42 - , AlexAcc 41 - , AlexAcc 40 - , AlexAcc 39 - , AlexAcc 38 - , AlexAcc 37 - , AlexAcc 36 - , AlexAcc 35 - , AlexAcc 34 - , AlexAcc 33 - , AlexAcc 32 - , AlexAcc 31 - , AlexAcc 30 - , AlexAcc 29 - , 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 - , AlexAcc 14 - , AlexAcc 13 - , AlexAcc 12 - , AlexAcc 11 - , AlexAcc 10 - , AlexAcc 9 - , AlexAcc 8 - , AlexAcc 7 - , AlexAcc 6 - , AlexAcc 5 - , AlexAcc 4 - , AlexAcc 3 - , AlexAcc 2 - , AlexAcc 1 - , AlexAcc 0 - ] - -alex_actions = array (0 :: Int, 550) - [ (549,alex_action_36) - , (548,alex_action_39) - , (547,alex_action_38) - , (546,alex_action_2) - , (545,alex_action_2) - , (544,alex_action_3) - , (543,alex_action_4) - , (542,alex_action_4) - , (541,alex_action_5) - , (540,alex_action_6) - , (539,alex_action_7) - , (538,alex_action_8) - , (537,alex_action_9) - , (536,alex_action_10) - , (535,alex_action_11) - , (534,alex_action_12) - , (533,alex_action_13) - , (532,alex_action_14) - , (531,alex_action_15) - , (530,alex_action_16) - , (529,alex_action_17) - , (528,alex_action_18) - , (527,alex_action_19) - , (526,alex_action_20) - , (525,alex_action_21) - , (524,alex_action_22) - , (523,alex_action_23) - , (522,alex_action_24) - , (521,alex_action_25) - , (520,alex_action_26) - , (519,alex_action_27) - , (518,alex_action_27) - , (517,alex_action_27) - , (516,alex_action_27) - , (515,alex_action_27) - , (514,alex_action_27) - , (513,alex_action_27) - , (512,alex_action_27) - , (511,alex_action_27) - , (510,alex_action_27) - , (509,alex_action_27) - , (508,alex_action_27) - , (507,alex_action_27) - , (506,alex_action_27) - , (505,alex_action_27) - , (504,alex_action_27) - , (503,alex_action_27) - , (502,alex_action_27) - , (501,alex_action_27) - , (500,alex_action_27) - , (499,alex_action_27) - , (498,alex_action_27) - , (497,alex_action_27) - , (496,alex_action_27) - , (495,alex_action_27) - , (494,alex_action_27) - , (493,alex_action_27) - , (492,alex_action_27) - , (491,alex_action_27) - , (490,alex_action_27) - , (489,alex_action_27) - , (488,alex_action_27) - , (487,alex_action_27) - , (486,alex_action_27) - , (485,alex_action_27) - , (484,alex_action_27) - , (483,alex_action_27) - , (482,alex_action_27) - , (481,alex_action_27) - , (480,alex_action_27) - , (479,alex_action_27) - , (478,alex_action_27) - , (477,alex_action_27) - , (476,alex_action_27) - , (475,alex_action_27) - , (474,alex_action_27) - , (473,alex_action_27) - , (472,alex_action_27) - , (471,alex_action_27) - , (470,alex_action_27) - , (469,alex_action_27) - , (468,alex_action_27) - , (467,alex_action_27) - , (466,alex_action_27) - , (465,alex_action_27) - , (464,alex_action_27) - , (463,alex_action_27) - , (462,alex_action_27) - , (461,alex_action_27) - , (460,alex_action_27) - , (459,alex_action_27) - , (458,alex_action_27) - , (457,alex_action_27) - , (456,alex_action_27) - , (455,alex_action_27) - , (454,alex_action_27) - , (453,alex_action_27) - , (452,alex_action_27) - , (451,alex_action_27) - , (450,alex_action_27) - , (449,alex_action_27) - , (448,alex_action_27) - , (447,alex_action_27) - , (446,alex_action_27) - , (445,alex_action_27) - , (444,alex_action_27) - , (443,alex_action_27) - , (442,alex_action_27) - , (441,alex_action_27) - , (440,alex_action_27) - , (439,alex_action_27) - , (438,alex_action_27) - , (437,alex_action_27) - , (436,alex_action_27) - , (435,alex_action_27) - , (434,alex_action_27) - , (433,alex_action_27) - , (432,alex_action_27) - , (431,alex_action_27) - , (430,alex_action_27) - , (429,alex_action_27) - , (428,alex_action_27) - , (427,alex_action_27) - , (426,alex_action_27) - , (425,alex_action_27) - , (424,alex_action_27) - , (423,alex_action_27) - , (422,alex_action_27) - , (421,alex_action_27) - , (420,alex_action_27) - , (419,alex_action_27) - , (418,alex_action_27) - , (417,alex_action_27) - , (416,alex_action_27) - , (415,alex_action_27) - , (414,alex_action_27) - , (413,alex_action_27) - , (412,alex_action_27) - , (411,alex_action_27) - , (410,alex_action_27) - , (409,alex_action_27) - , (408,alex_action_27) - , (407,alex_action_27) - , (406,alex_action_27) - , (405,alex_action_27) - , (404,alex_action_27) - , (403,alex_action_27) - , (402,alex_action_27) - , (401,alex_action_27) - , (400,alex_action_27) - , (399,alex_action_27) - , (398,alex_action_27) - , (397,alex_action_27) - , (396,alex_action_27) - , (395,alex_action_27) - , (394,alex_action_27) - , (393,alex_action_27) - , (392,alex_action_27) - , (391,alex_action_27) - , (390,alex_action_27) - , (389,alex_action_27) - , (388,alex_action_27) - , (387,alex_action_27) - , (386,alex_action_27) - , (385,alex_action_27) - , (384,alex_action_27) - , (383,alex_action_27) - , (382,alex_action_27) - , (381,alex_action_27) - , (380,alex_action_27) - , (379,alex_action_27) - , (378,alex_action_27) - , (377,alex_action_27) - , (376,alex_action_27) - , (375,alex_action_27) - , (374,alex_action_27) - , (373,alex_action_27) - , (372,alex_action_27) - , (371,alex_action_27) - , (370,alex_action_27) - , (369,alex_action_27) - , (368,alex_action_27) - , (367,alex_action_27) - , (366,alex_action_27) - , (365,alex_action_27) - , (364,alex_action_27) - , (363,alex_action_27) - , (362,alex_action_27) - , (361,alex_action_27) - , (360,alex_action_27) - , (359,alex_action_27) - , (358,alex_action_27) - , (357,alex_action_27) - , (356,alex_action_27) - , (355,alex_action_27) - , (354,alex_action_27) - , (353,alex_action_27) - , (352,alex_action_27) - , (351,alex_action_27) - , (350,alex_action_27) - , (349,alex_action_27) - , (348,alex_action_27) - , (347,alex_action_27) - , (346,alex_action_27) - , (345,alex_action_27) - , (344,alex_action_27) - , (343,alex_action_27) - , (342,alex_action_27) - , (341,alex_action_28) - , (340,alex_action_28) - , (339,alex_action_28) - , (338,alex_action_28) - , (337,alex_action_28) - , (336,alex_action_29) - , (335,alex_action_29) - , (334,alex_action_30) - , (333,alex_action_31) - , (332,alex_action_31) - , (331,alex_action_32) - , (330,alex_action_32) - , (329,alex_action_32) - , (328,alex_action_32) - , (327,alex_action_32) - , (326,alex_action_32) - , (325,alex_action_32) - , (324,alex_action_114) - , (323,alex_action_32) - , (322,alex_action_114) - , (321,alex_action_32) - , (320,alex_action_114) - , (319,alex_action_34) - , (318,alex_action_40) - , (317,alex_action_41) - , (316,alex_action_42) - , (315,alex_action_43) - , (314,alex_action_44) - , (313,alex_action_45) - , (312,alex_action_46) - , (311,alex_action_47) - , (310,alex_action_48) - , (309,alex_action_49) - , (308,alex_action_50) - , (307,alex_action_51) - , (306,alex_action_52) - , (305,alex_action_53) - , (304,alex_action_54) - , (303,alex_action_55) - , (302,alex_action_56) - , (301,alex_action_57) - , (300,alex_action_58) - , (299,alex_action_59) - , (298,alex_action_60) - , (297,alex_action_61) - , (296,alex_action_62) - , (295,alex_action_63) - , (294,alex_action_64) - , (293,alex_action_65) - , (292,alex_action_66) - , (291,alex_action_67) - , (290,alex_action_68) - , (289,alex_action_69) - , (288,alex_action_70) - , (287,alex_action_71) - , (286,alex_action_72) - , (285,alex_action_72) - , (284,alex_action_72) - , (283,alex_action_73) - , (282,alex_action_73) - , (281,alex_action_73) - , (280,alex_action_74) - , (279,alex_action_75) - , (278,alex_action_76) - , (277,alex_action_77) - , (276,alex_action_78) - , (275,alex_action_79) - , (274,alex_action_80) - , (273,alex_action_81) - , (272,alex_action_82) - , (271,alex_action_83) - , (270,alex_action_84) - , (269,alex_action_85) - , (268,alex_action_86) - , (267,alex_action_87) - , (266,alex_action_88) - , (265,alex_action_89) - , (264,alex_action_90) - , (263,alex_action_91) - , (262,alex_action_92) - , (261,alex_action_93) - , (260,alex_action_94) - , (259,alex_action_95) - , (258,alex_action_96) - , (257,alex_action_97) - , (256,alex_action_98) - , (255,alex_action_99) - , (254,alex_action_100) - , (253,alex_action_101) - , (252,alex_action_102) - , (251,alex_action_103) - , (250,alex_action_104) - , (249,alex_action_105) - , (248,alex_action_106) - , (247,alex_action_107) - , (246,alex_action_108) - , (245,alex_action_109) - , (244,alex_action_110) - , (243,alex_action_111) - , (242,alex_action_112) - , (241,alex_action_112) - , (240,alex_action_112) - , (239,alex_action_112) - , (238,alex_action_112) - , (237,alex_action_112) - , (236,alex_action_112) - , (235,alex_action_112) - , (234,alex_action_113) - , (233,alex_action_113) - , (232,alex_action_113) - , (231,alex_action_113) - , (230,alex_action_113) - , (229,alex_action_113) - , (228,alex_action_113) - , (227,alex_action_113) - , (226,alex_action_113) - , (225,alex_action_113) - , (224,alex_action_113) - , (223,alex_action_114) - , (222,alex_action_114) - , (221,alex_action_114) - , (220,alex_action_114) - , (219,alex_action_114) - , (218,alex_action_114) - , (217,alex_action_114) - , (216,alex_action_114) - , (215,alex_action_114) - , (214,alex_action_114) - , (213,alex_action_114) - , (212,alex_action_114) - , (211,alex_action_114) - , (210,alex_action_114) - , (209,alex_action_114) - , (208,alex_action_114) - , (207,alex_action_114) - , (206,alex_action_114) - , (205,alex_action_114) - , (204,alex_action_114) - , (203,alex_action_114) - , (202,alex_action_114) - , (201,alex_action_114) - , (200,alex_action_114) - , (199,alex_action_114) - , (198,alex_action_114) - , (197,alex_action_114) - , (196,alex_action_114) - , (195,alex_action_114) - , (194,alex_action_114) - , (193,alex_action_114) - , (192,alex_action_114) - , (191,alex_action_114) - , (190,alex_action_114) - , (189,alex_action_114) - , (188,alex_action_114) - , (187,alex_action_114) - , (186,alex_action_114) - , (185,alex_action_114) - , (184,alex_action_114) - , (183,alex_action_114) - , (182,alex_action_114) - , (181,alex_action_114) - , (180,alex_action_114) - , (179,alex_action_114) - , (178,alex_action_114) - , (177,alex_action_114) - , (176,alex_action_114) - , (175,alex_action_114) - , (174,alex_action_114) - , (173,alex_action_114) - , (172,alex_action_114) - , (171,alex_action_114) - , (170,alex_action_114) - , (169,alex_action_114) - , (168,alex_action_114) - , (167,alex_action_114) - , (166,alex_action_114) - , (165,alex_action_114) - , (164,alex_action_114) - , (163,alex_action_114) - , (162,alex_action_114) - , (161,alex_action_114) - , (160,alex_action_114) - , (159,alex_action_114) - , (158,alex_action_114) - , (157,alex_action_114) - , (156,alex_action_114) - , (155,alex_action_114) - , (154,alex_action_114) - , (153,alex_action_114) - , (152,alex_action_114) - , (151,alex_action_114) - , (150,alex_action_114) - , (149,alex_action_114) - , (148,alex_action_114) - , (147,alex_action_114) - , (146,alex_action_114) - , (145,alex_action_114) - , (144,alex_action_114) - , (143,alex_action_114) - , (142,alex_action_114) - , (141,alex_action_114) - , (140,alex_action_114) - , (139,alex_action_114) - , (138,alex_action_114) - , (137,alex_action_114) - , (136,alex_action_114) - , (135,alex_action_114) - , (134,alex_action_114) - , (133,alex_action_114) - , (132,alex_action_114) - , (131,alex_action_114) - , (130,alex_action_114) - , (129,alex_action_114) - , (128,alex_action_114) - , (127,alex_action_114) - , (126,alex_action_114) - , (125,alex_action_114) - , (124,alex_action_114) - , (123,alex_action_114) - , (122,alex_action_114) - , (121,alex_action_114) - , (120,alex_action_114) - , (119,alex_action_114) - , (118,alex_action_114) - , (117,alex_action_114) - , (116,alex_action_114) - , (115,alex_action_114) - , (114,alex_action_114) - , (113,alex_action_114) - , (112,alex_action_114) - , (111,alex_action_114) - , (110,alex_action_114) - , (109,alex_action_114) - , (108,alex_action_114) - , (107,alex_action_114) - , (106,alex_action_114) - , (105,alex_action_114) - , (104,alex_action_114) - , (103,alex_action_114) - , (102,alex_action_114) - , (101,alex_action_114) - , (100,alex_action_114) - , (99,alex_action_114) - , (98,alex_action_114) - , (97,alex_action_114) - , (96,alex_action_114) - , (95,alex_action_114) - , (94,alex_action_114) - , (93,alex_action_114) - , (92,alex_action_114) - , (91,alex_action_114) - , (90,alex_action_114) - , (89,alex_action_114) - , (88,alex_action_114) - , (87,alex_action_114) - , (86,alex_action_114) - , (85,alex_action_114) - , (84,alex_action_114) - , (83,alex_action_114) - , (82,alex_action_114) - , (81,alex_action_114) - , (80,alex_action_114) - , (79,alex_action_114) - , (78,alex_action_114) - , (77,alex_action_114) - , (76,alex_action_114) - , (75,alex_action_114) - , (74,alex_action_114) - , (73,alex_action_114) - , (72,alex_action_114) - , (71,alex_action_114) - , (70,alex_action_114) - , (69,alex_action_114) - , (68,alex_action_114) - , (67,alex_action_114) - , (66,alex_action_114) - , (65,alex_action_114) - , (64,alex_action_114) - , (63,alex_action_114) - , (62,alex_action_114) - , (61,alex_action_114) - , (60,alex_action_114) - , (59,alex_action_114) - , (58,alex_action_114) - , (57,alex_action_114) - , (56,alex_action_114) - , (55,alex_action_114) - , (54,alex_action_114) - , (53,alex_action_114) - , (52,alex_action_114) - , (51,alex_action_114) - , (50,alex_action_114) - , (49,alex_action_114) - , (48,alex_action_114) - , (47,alex_action_114) - , (46,alex_action_114) - , (45,alex_action_114) - , (44,alex_action_114) - , (43,alex_action_114) - , (42,alex_action_114) - , (41,alex_action_114) - , (40,alex_action_114) - , (39,alex_action_114) - , (38,alex_action_114) - , (37,alex_action_114) - , (36,alex_action_114) - , (35,alex_action_114) - , (34,alex_action_114) - , (33,alex_action_114) - , (32,alex_action_114) - , (31,alex_action_114) - , (30,alex_action_114) - , (29,alex_action_114) - , (28,alex_action_114) - , (27,alex_action_114) - , (26,alex_action_114) - , (25,alex_action_114) - , (24,alex_action_114) - , (23,alex_action_114) - , (22,alex_action_114) - , (21,alex_action_114) - , (20,alex_action_114) - , (19,alex_action_114) - , (18,alex_action_114) - , (17,alex_action_114) - , (16,alex_action_114) - , (15,alex_action_114) - , (14,alex_action_114) - , (13,alex_action_114) - , (12,alex_action_114) - , (11,alex_action_114) - , (10,alex_action_114) - , (9,alex_action_114) - , (8,alex_action_114) - , (7,alex_action_114) - , (6,alex_action_114) - , (5,alex_action_114) - , (4,alex_action_114) - , (3,alex_action_114) - , (2,alex_action_114) - , (1,alex_action_114) - , (0,alex_action_114) - ] - -{-# LINE 239 "src/full/Agda/Syntax/Parser/Lexer.x" #-} - - --- | This is the initial state for parsing a regular, non-literate file. -normal :: LexState -normal = 0 - - -{-| The layout state. Entered when we see a layout keyword ('withLayout') and - exited either when seeing an open brace ('openBrace') or at the next token - ('newLayoutContext'). - - Update: we don't use braces for layout anymore. --} -layout :: LexState -layout = layout_ - - -{-| The state inside a pragma. --} -pragma :: LexState -pragma = pragma_ - --- | The state inside a FOREIGN pragma. This needs to be different so that we don't --- lex further strings as pragma keywords. -fpragma :: LexState -fpragma = fpragma_ - -{-| We enter this state from 'newLayoutContext' when the token following a - layout keyword is to the left of (or at the same column as) the current - layout context. Example: - - > data Empty : Set where - > foo : Empty -> Nat - - Here the second line is not part of the @where@ clause since it is has the - same indentation as the @data@ definition. What we have to do is insert an - empty layout block @{}@ after the @where@. The only thing that can happen - in this state is that 'emptyLayout' is executed, generating the closing - brace. The open brace is generated when entering by 'newLayoutContext'. --} -empty_layout :: LexState -empty_layout = empty_layout_ - - --- | This state is entered at the beginning of each line. You can't lex --- anything in this state, and to exit you have to check the layout rule. --- Done with 'offsideRule'. -bol :: LexState -bol = bol_ - - --- | This state can only be entered by the parser. In this state you can only --- lex the keywords @using@, @hiding@, @renaming@ and @to@. Moreover they are --- only keywords in this particular state. The lexer will never enter this --- state by itself, that has to be done in the parser. -imp_dir :: LexState -imp_dir = imp_dir_ - - --- | Return the next token. This is the function used by Happy in the parser. --- --- @lexer k = 'lexToken' >>= k@ -lexer :: (Token -> Parser a) -> Parser a -lexer k = lexToken >>= k - --- | Do not use this function; it sets the 'ParseFlags' to --- 'undefined'. -alexScan :: AlexInput -> Int -> AlexReturn (LexAction Token) - --- | This is the main lexing function generated by Alex. -alexScanUser :: ([LexState], ParseFlags) -> AlexInput -> Int -> AlexReturn (LexAction Token) - - - -bol_,code,empty_layout_,fpragma_,imp_dir_,layout_,pragma_ :: Int -bol_ = 1 -code = 2 -empty_layout_ = 3 -fpragma_ = 4 -imp_dir_ = 5 -layout_ = 6 -pragma_ = 7 -alex_action_2 = beginWith pragma $ symbol SymOpenPragma -alex_action_3 = beginWith fpragma $ symbol SymOpenPragma -alex_action_4 = endWith $ symbol SymClosePragma -alex_action_5 = keyword KwBUILTIN -alex_action_6 = keyword KwCATCHALL -alex_action_7 = endWith $ beginWith fpragma $ keyword KwCOMPILE -alex_action_8 = endWith $ beginWith fpragma $ keyword KwFOREIGN -alex_action_9 = keyword KwDISPLAY -alex_action_10 = keyword KwETA -alex_action_11 = keyword KwIMPOSSIBLE -alex_action_12 = keyword KwINJECTIVE -alex_action_13 = keyword KwINLINE -alex_action_14 = keyword KwNOINLINE -alex_action_15 = keyword KwLINE -alex_action_16 = keyword KwMEASURE -alex_action_17 = keyword KwNO_POSITIVITY_CHECK -alex_action_18 = keyword KwNO_TERMINATION_CHECK -alex_action_19 = keyword KwNO_UNIVERSE_CHECK -alex_action_20 = keyword KwNON_TERMINATING -alex_action_21 = keyword KwOPTIONS -alex_action_22 = keyword KwPOLARITY -alex_action_23 = keyword KwREWRITE -alex_action_24 = keyword KwSTATIC -alex_action_25 = keyword KwTERMINATING -alex_action_26 = keyword KwWARNING_ON_USAGE -alex_action_27 = withInterval $ TokString -alex_action_28 = withInterval $ TokString -alex_action_29 = nestedComment -alex_action_30 = symbol SymEndComment -alex_action_31 = symbol SymEndComment -alex_action_32 = withInterval TokComment -alex_action_34 = begin bol_ -alex_action_36 = offsideRule -alex_action_38 = endWith newLayoutContext -alex_action_39 = emptyLayout -alex_action_40 = keyword KwLet -alex_action_41 = keyword KwIn -alex_action_42 = keyword KwWhere -alex_action_43 = keyword KwDo -alex_action_44 = keyword KwField -alex_action_45 = keyword KwWith -alex_action_46 = keyword KwRewrite -alex_action_47 = keyword KwPostulate -alex_action_48 = keyword KwPrimitive -alex_action_49 = keyword KwOpen -alex_action_50 = keyword KwImport -alex_action_51 = keyword KwModule -alex_action_52 = keyword KwData -alex_action_53 = keyword KwCoData -alex_action_54 = keyword KwRecord -alex_action_55 = keyword KwConstructor -alex_action_56 = keyword KwInductive -alex_action_57 = keyword KwCoInductive -alex_action_58 = keyword KwEta -alex_action_59 = keyword KwNoEta -alex_action_60 = keyword KwInfix -alex_action_61 = keyword KwInfixL -alex_action_62 = keyword KwInfixR -alex_action_63 = keyword KwMutual -alex_action_64 = keyword KwAbstract -alex_action_65 = keyword KwPrivate -alex_action_66 = keyword KwInstance -alex_action_67 = keyword KwOverlap -alex_action_68 = keyword KwMacro -alex_action_69 = keyword KwSet -alex_action_70 = keyword KwProp -alex_action_71 = keyword KwForall -alex_action_72 = withInterval' (read . drop 3) TokSetN -alex_action_73 = withInterval' (read . drop 4) TokPropN -alex_action_74 = keyword KwQuoteGoal -alex_action_75 = keyword KwQuoteContext -alex_action_76 = keyword KwQuote -alex_action_77 = keyword KwQuoteTerm -alex_action_78 = keyword KwUnquote -alex_action_79 = keyword KwUnquoteDecl -alex_action_80 = keyword KwUnquoteDef -alex_action_81 = keyword KwTactic -alex_action_82 = keyword KwSyntax -alex_action_83 = keyword KwPatternSyn -alex_action_84 = keyword KwVariable -alex_action_85 = keyword KwUsing -alex_action_86 = keyword KwHiding -alex_action_87 = keyword KwRenaming -alex_action_88 = endWith $ keyword KwTo -alex_action_89 = keyword KwPublic -alex_action_90 = hole -alex_action_91 = symbol SymEllipsis -alex_action_92 = symbol SymDotDot -alex_action_93 = symbol SymDot -alex_action_94 = symbol SymSemi -alex_action_95 = symbol SymColon -alex_action_96 = symbol SymEqual -alex_action_97 = symbol SymUnderscore -alex_action_98 = symbol SymQuestionMark -alex_action_99 = symbol SymBar -alex_action_100 = symbol SymOpenIdiomBracket -alex_action_101 = symbol SymCloseIdiomBracket -alex_action_102 = symbol SymOpenParen -alex_action_103 = symbol SymCloseParen -alex_action_104 = symbol SymArrow -alex_action_105 = symbol SymLambda -alex_action_106 = symbol SymAs -alex_action_107 = symbol SymDoubleOpenBrace -alex_action_108 = symbol SymOpenBrace -alex_action_109 = symbol SymCloseBrace -alex_action_110 = litChar -alex_action_111 = litString -alex_action_112 = literal LitNat -alex_action_113 = literal LitFloat -alex_action_114 = identifier +#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# + "\xf7\xff\xff\xff\x6c\x00\x00\x00\xe1\x00\x00\x00\x55\x01\x00\x00\xcb\x01\x00\x00\xc1\x02\x00\x00\x36\x03\x00\x00\xac\x03\x00\x00\x73\x00\x00\x00\xd8\xff\xff\xff\x8b\x04\x00\x00\xe9\x04\x00\x00\x47\x05\x00\x00\xcc\x01\x00\x00\xa3\x05\x00\x00\xff\x05\x00\x00\x54\x06\x00\x00\x53\x06\x00\x00\xd3\x06\x00\x00\x53\x07\x00\x00\x32\x08\x00\x00\x31\x08\x00\x00\xb1\x08\x00\x00\x31\x09\x00\x00\xb1\x09\x00\x00\x90\x0a\x00\x00\xec\x0a\x00\x00\xeb\x0a\x00\x00\x00\x00\x00\x00\x5c\x0b\x00\x00\x00\x00\x00\x00\xcd\x0b\x00\x00\x00\x00\x00\x00\x3e\x0c\x00\x00\x00\x00\x00\x00\xaf\x0c\x00\x00\x00\x00\x00\x00\xf0\x0c\x00\x00\x00\x00\x00\x00\x31\x0d\x00\x00\x00\x00\x00\x00\x72\x0d\x00\x00\x00\x00\x00\x00\xb3\x0d\x00\x00\x92\x0e\x00\x00\x11\x0f\x00\x00\xd1\x0e\x00\x00\x00\x00\x00\x00\xd1\x0f\x00\x00\x91\x0f\x00\x00\x00\x00\x00\x00\x91\x10\x00\x00\x51\x10\x00\x00\x00\x00\x00\x00\x51\x11\x00\x00\xc7\x11\x00\x00\x35\x11\x00\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x12\x00\x00\xb5\x13\x00\x00\xac\x14\x00\x00\xa3\x15\x00\x00\x9a\x16\x00\x00\x91\x17\x00\x00\x88\x18\x00\x00\x7f\x19\x00\x00\x76\x1a\x00\x00\x6d\x1b\x00\x00\x64\x1c\x00\x00\x5b\x1d\x00\x00\x52\x1e\x00\x00\x49\x1f\x00\x00\x40\x20\x00\x00\x37\x21\x00\x00\x2e\x22\x00\x00\x25\x23\x00\x00\x1c\x24\x00\x00\x13\x25\x00\x00\x0a\x26\x00\x00\x01\x27\x00\x00\xf8\x27\x00\x00\xef\x28\x00\x00\xe6\x29\x00\x00\xdd\x2a\x00\x00\xd4\x2b\x00\x00\xcb\x2c\x00\x00\xc2\x2d\x00\x00\xb9\x2e\x00\x00\xb0\x2f\x00\x00\xa7\x30\x00\x00\x9e\x31\x00\x00\x95\x32\x00\x00\x8c\x33\x00\x00\x83\x34\x00\x00\x7a\x35\x00\x00\x71\x36\x00\x00\x68\x37\x00\x00\x5f\x38\x00\x00\x56\x39\x00\x00\x4d\x3a\x00\x00\x44\x3b\x00\x00\x3b\x3c\x00\x00\x32\x3d\x00\x00\x29\x3e\x00\x00\x20\x3f\x00\x00\x17\x40\x00\x00\x0e\x41\x00\x00\x05\x42\x00\x00\xfc\x42\x00\x00\xf3\x43\x00\x00\xea\x44\x00\x00\xe1\x45\x00\x00\xd8\x46\x00\x00\xcf\x47\x00\x00\xc6\x48\x00\x00\xbd\x49\x00\x00\xb4\x4a\x00\x00\xab\x4b\x00\x00\xa2\x4c\x00\x00\x99\x4d\x00\x00\x90\x4e\x00\x00\x87\x4f\x00\x00\x7e\x50\x00\x00\x75\x51\x00\x00\x6c\x52\x00\x00\x63\x53\x00\x00\x5a\x54\x00\x00\x51\x55\x00\x00\x48\x56\x00\x00\x3f\x57\x00\x00\x36\x58\x00\x00\x2d\x59\x00\x00\x24\x5a\x00\x00\x1b\x5b\x00\x00\x12\x5c\x00\x00\x09\x5d\x00\x00\x00\x5e\x00\x00\xf7\x5e\x00\x00\xee\x5f\x00\x00\xe5\x60\x00\x00\xdc\x61\x00\x00\xd3\x62\x00\x00\xca\x63\x00\x00\xc1\x64\x00\x00\xb8\x65\x00\x00\xaf\x66\x00\x00\xa6\x67\x00\x00\x9d\x68\x00\x00\x94\x69\x00\x00\x8b\x6a\x00\x00\x82\x6b\x00\x00\x79\x6c\x00\x00\x70\x6d\x00\x00\x67\x6e\x00\x00\x5e\x6f\x00\x00\x55\x70\x00\x00\x4c\x71\x00\x00\x43\x72\x00\x00\x3a\x73\x00\x00\x31\x74\x00\x00\x28\x75\x00\x00\x1f\x76\x00\x00\x16\x77\x00\x00\x0d\x78\x00\x00\x04\x79\x00\x00\xfb\x79\x00\x00\xf2\x7a\x00\x00\xe9\x7b\x00\x00\xe0\x7c\x00\x00\xd7\x7d\x00\x00\xce\x7e\x00\x00\xc5\x7f\x00\x00\xbc\x80\x00\x00\xb3\x81\x00\x00\xaa\x82\x00\x00\xa1\x83\x00\x00\x98\x84\x00\x00\x8f\x85\x00\x00\x86\x86\x00\x00\x7d\x87\x00\x00\x74\x88\x00\x00\x6b\x89\x00\x00\x62\x8a\x00\x00\x59\x8b\x00\x00\x50\x8c\x00\x00\x47\x8d\x00\x00\x3e\x8e\x00\x00\x35\x8f\x00\x00\x2c\x90\x00\x00\x23\x91\x00\x00\x1a\x92\x00\x00\x11\x93\x00\x00\x08\x94\x00\x00\xff\x94\x00\x00\xf6\x95\x00\x00\xed\x96\x00\x00\xe4\x97\x00\x00\xdb\x98\x00\x00\xd2\x99\x00\x00\xc9\x9a\x00\x00\xc0\x9b\x00\x00\xb7\x9c\x00\x00\xae\x9d\x00\x00\xa5\x9e\x00\x00\x9c\x9f\x00\x00\x93\xa0\x00\x00\x8a\xa1\x00\x00\x81\xa2\x00\x00\x78\xa3\x00\x00\x6f\xa4\x00\x00\x66\xa5\x00\x00\x5d\xa6\x00\x00\x54\xa7\x00\x00\x4b\xa8\x00\x00\x42\xa9\x00\x00\x39\xaa\x00\x00\x30\xab\x00\x00\x27\xac\x00\x00\x1e\xad\x00\x00\x15\xae\x00\x00\x0c\xaf\x00\x00\x03\xb0\x00\x00\xfa\xb0\x00\x00\xf1\xb1\x00\x00\xe8\xb2\x00\x00\xdf\xb3\x00\x00\xd6\xb4\x00\x00\xcd\xb5\x00\x00\xc4\xb6\x00\x00\xbb\xb7\x00\x00\xb2\xb8\x00\x00\xa9\xb9\x00\x00\xa0\xba\x00\x00\x97\xbb\x00\x00\x8e\xbc\x00\x00\x85\xbd\x00\x00\x7c\xbe\x00\x00\x73\xbf\x00\x00\x6a\xc0\x00\x00\x61\xc1\x00\x00\x58\xc2\x00\x00\x4f\xc3\x00\x00\x46\xc4\x00\x00\x3d\xc5\x00\x00\x34\xc6\x00\x00\x2b\xc7\x00\x00\x22\xc8\x00\x00\x19\xc9\x00\x00\x10\xca\x00\x00\x07\xcb\x00\x00\xfe\xcb\x00\x00\xf5\xcc\x00\x00\xec\xcd\x00\x00\xe3\xce\x00\x00\xda\xcf\x00\x00\xd1\xd0\x00\x00\xc8\xd1\x00\x00\xbf\xd2\x00\x00\xb6\xd3\x00\x00\xad\xd4\x00\x00\xa4\xd5\x00\x00\x9b\xd6\x00\x00\x92\xd7\x00\x00\x89\xd8\x00\x00\x80\xd9\x00\x00\x77\xda\x00\x00\x6e\xdb\x00\x00\x65\xdc\x00\x00\x5c\xdd\x00\x00\x53\xde\x00\x00\x4a\xdf\x00\x00\x41\xe0\x00\x00\x38\xe1\x00\x00\x2f\xe2\x00\x00\x26\xe3\x00\x00\x1d\xe4\x00\x00\x14\xe5\x00\x00\x0b\xe6\x00\x00\x02\xe7\x00\x00\xf9\xe7\x00\x00\xf0\xe8\x00\x00\xe3\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\xe9\x00\x00\xe6\xea\x00\x00\xe6\xeb\x00\x00\xdc\xec\x00\x00\xdc\xed\x00\x00\xd2\xee\x00\x00\xd2\xef\x00\x00\xd2\xf0\x00\x00\xd2\xf1\x00\x00\xd2\xf2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xac\x13\x00\x00\xa3\x14\x00\x00\x15\xe5\x00\x00\x02\xe6\x00\x00\xe7\xe8\x00\x00\xd0\xe9\x00\x00\xc6\xec\x00\x00\xb1\xf3\x00\x00\x0d\xf4\x00\x00\x69\xf4\x00\x00\xc5\xf4\x00\x00\x21\xf5\x00\x00\x7d\xf5\x00\x00\xd9\xf5\x00\x00\x35\xf6\x00\x00\x91\xf6\x00\x00\xed\xf6\x00\x00\x49\xf7\x00\x00\xa5\xf7\x00\x00\x01\xf8\x00\x00\x5d\xf8\x00\x00\xb9\xf8\x00\x00\x15\xf9\x00\x00\x71\xf9\x00\x00\xcd\xf9\x00\x00\x29\xfa\x00\x00\x85\xfa\x00\x00\xe1\xfa\x00\x00\x3d\xfb\x00\x00\x99\xfb\x00\x00\xf5\xfb\x00\x00\x51\xfc\x00\x00\xad\xfc\x00\x00\x09\xfd\x00\x00\x65\xfd\x00\x00\xc1\xfd\x00\x00\x1d\xfe\x00\x00\x79\xfe\x00\x00\xd5\xfe\x00\x00\x31\xff\x00\x00\x8d\xff\x00\x00\xe9\xff\x00\x00\x45\x00\x01\x00\xa1\x00\x01\x00\xfd\x00\x01\x00\x59\x01\x01\x00\xb5\x01\x01\x00\x11\x02\x01\x00\x6d\x02\x01\x00\xc9\x02\x01\x00\x25\x03\x01\x00\x81\x03\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\xff\xff\xff\xda\xff\xff\xff\x00\x00\x00\x00\xdd\x03\x01\x00\x39\x04\x01\x00\xf4\xe6\x00\x00\x95\x04\x01\x00\xf1\x04\x01\x00\xe0\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x8e\xff\xff\xff\x00\x00\x00\x00\x4d\x05\x01\x00\xeb\xe7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa9\x05\x01\x00\x05\x06\x01\x00\x61\x06\x01\x00\xbd\x06\x01\x00\x19\x07\x01\x00\x75\x07\x01\x00\xd1\x07\x01\x00\x2d\x08\x01\x00\x89\x08\x01\x00\xe5\x08\x01\x00\x41\x09\x01\x00\x9d\x09\x01\x00\xf9\x09\x01\x00\x55\x0a\x01\x00\xb1\x0a\x01\x00\x0d\x0b\x01\x00\x69\x0b\x01\x00\xc5\x0b\x01\x00\x21\x0c\x01\x00\x7d\x0c\x01\x00\xdb\x0c\x01\x00\x39\x0d\x01\x00\x97\x0d\x01\x00\xf5\x0d\x01\x00\x53\x0e\x01\x00\xb1\x0e\x01\x00\x0f\x0f\x01\x00\x6b\x0f\x01\x00\xc7\x0f\x01\x00\x23\x10\x01\x00\x7f\x10\x01\x00\xdb\x10\x01\x00\x37\x11\x01\x00\x93\x11\x01\x00\xef\x11\x01\x00\x4b\x12\x01\x00\xa7\x12\x01\x00\x03\x13\x01\x00\x5f\x13\x01\x00\xbb\x13\x01\x00\x17\x14\x01\x00\x73\x14\x01\x00\xcf\x14\x01\x00\x2b\x15\x01\x00\x87\x15\x01\x00\xe3\x15\x01\x00\x3f\x16\x01\x00\x9b\x16\x01\x00\xf7\x16\x01\x00\x53\x17\x01\x00\xaf\x17\x01\x00\x0b\x18\x01\x00\x67\x18\x01\x00\xc3\x18\x01\x00\x1f\x19\x01\x00\x7b\x19\x01\x00\xd7\x19\x01\x00\x33\x1a\x01\x00\x8f\x1a\x01\x00\xeb\x1a\x01\x00\x47\x1b\x01\x00\xa3\x1b\x01\x00\xff\x1b\x01\x00\x5b\x1c\x01\x00\xb7\x1c\x01\x00\x13\x1d\x01\x00\x6f\x1d\x01\x00\xcb\x1d\x01\x00\x27\x1e\x01\x00\x83\x1e\x01\x00\xdf\x1e\x01\x00\x3b\x1f\x01\x00\x97\x1f\x01\x00\xf3\x1f\x01\x00\x4f\x20\x01\x00\xab\x20\x01\x00\x07\x21\x01\x00\x63\x21\x01\x00\xbf\x21\x01\x00\x1b\x22\x01\x00\x77\x22\x01\x00\xd3\x22\x01\x00\x2f\x23\x01\x00\x8b\x23\x01\x00\xe7\x23\x01\x00\x43\x24\x01\x00\x9f\x24\x01\x00\xfb\x24\x01\x00\x57\x25\x01\x00\xb3\x25\x01\x00\x0f\x26\x01\x00\x6b\x26\x01\x00\xc7\x26\x01\x00\x23\x27\x01\x00\x7f\x27\x01\x00\xdb\x27\x01\x00\x37\x28\x01\x00\x93\x28\x01\x00\xef\x28\x01\x00\x4b\x29\x01\x00\xa7\x29\x01\x00\x03\x2a\x01\x00\x5f\x2a\x01\x00\xbb\x2a\x01\x00\x17\x2b\x01\x00\x73\x2b\x01\x00\xcf\x2b\x01\x00\x2b\x2c\x01\x00\x87\x2c\x01\x00\xe3\x2c\x01\x00\x3f\x2d\x01\x00\x9b\x2d\x01\x00\xf7\x2d\x01\x00\x53\x2e\x01\x00\xaf\x2e\x01\x00\x0b\x2f\x01\x00\x67\x2f\x01\x00\xc3\x2f\x01\x00\x1f\x30\x01\x00\x7b\x30\x01\x00\xd7\x30\x01\x00\x33\x31\x01\x00\x8f\x31\x01\x00\xeb\x31\x01\x00\x47\x32\x01\x00\xa3\x32\x01\x00\xff\x32\x01\x00\x5b\x33\x01\x00\xb7\x33\x01\x00\x13\x34\x01\x00\x6f\x34\x01\x00\xcb\x34\x01\x00\x27\x35\x01\x00\x83\x35\x01\x00\xdf\x35\x01\x00\x3b\x36\x01\x00\x97\x36\x01\x00\xf3\x36\x01\x00\x4f\x37\x01\x00\xab\x37\x01\x00\x07\x38\x01\x00\x63\x38\x01\x00\xbf\x38\x01\x00\x1b\x39\x01\x00\x77\x39\x01\x00\xd3\x39\x01\x00\x2f\x3a\x01\x00\x8b\x3a\x01\x00\xe7\x3a\x01\x00\x43\x3b\x01\x00\x9f\x3b\x01\x00\xfb\x3b\x01\x00\x57\x3c\x01\x00\xb3\x3c\x01\x00\x0f\x3d\x01\x00\x6b\x3d\x01\x00\xc7\x3d\x01\x00\x23\x3e\x01\x00\x7f\x3e\x01\x00\xdb\x3e\x01\x00\x37\x3f\x01\x00\x93\x3f\x01\x00\xef\x3f\x01\x00\x4b\x40\x01\x00\xa7\x40\x01\x00\x03\x41\x01\x00\x5f\x41\x01\x00\xbb\x41\x01\x00\x17\x42\x01\x00\x73\x42\x01\x00\xcf\x42\x01\x00\x2b\x43\x01\x00\x87\x43\x01\x00\xe3\x43\x01\x00\x3f\x44\x01\x00\x9b\x44\x01\x00\xf7\x44\x01\x00\x53\x45\x01\x00\xaf\x45\x01\x00\x0b\x46\x01\x00\x67\x46\x01\x00\xc3\x46\x01\x00\x1f\x47\x01\x00\x7b\x47\x01\x00\xd7\x47\x01\x00\x33\x48\x01\x00\x8f\x48\x01\x00\xeb\x48\x01\x00\x47\x49\x01\x00\xa3\x49\x01\x00\xff\x49\x01\x00\x5b\x4a\x01\x00\xb7\x4a\x01\x00\x13\x4b\x01\x00\x6f\x4b\x01\x00\xcb\x4b\x01\x00\x27\x4c\x01\x00\x83\x4c\x01\x00\xdf\x4c\x01\x00\x3b\x4d\x01\x00\x97\x4d\x01\x00\xf3\x4d\x01\x00\x4f\x4e\x01\x00\xab\x4e\x01\x00\x07\x4f\x01\x00\x63\x4f\x01\x00\xbf\x4f\x01\x00\x1b\x50\x01\x00\x77\x50\x01\x00\xd3\x50\x01\x00\x2f\x51\x01\x00\x8b\x51\x01\x00\xe7\x51\x01\x00\x43\x52\x01\x00\x9f\x52\x01\x00\xfb\x52\x01\x00\x57\x53\x01\x00\xb3\x53\x01\x00\x0f\x54\x01\x00\x6b\x54\x01\x00\xc7\x54\x01\x00\x23\x55\x01\x00\x7f\x55\x01\x00\xdb\x55\x01\x00\x37\x56\x01\x00\x93\x56\x01\x00\xef\x56\x01\x00\x4b\x57\x01\x00\xa7\x57\x01\x00\x03\x58\x01\x00\x5f\x58\x01\x00\xbb\x58\x01\x00\x17\x59\x01\x00\x73\x59\x01\x00\xcf\x59\x01\x00"# + +alex_table :: AlexAddr +alex_table = AlexA# + "\x00\x00\x2b\x01\x3a\x00\x3a\x00\x3a\x00\x1e\x01\x3d\x00\x63\x01\x64\x01\x6e\x01\x6c\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\x3a\x00\x01\x02\x78\x01\x01\x02\x01\x02\x01\x02\x01\x02\x77\x01\x6f\x01\x70\x01\x01\x02\x01\x02\x01\x02\x8d\x01\x65\x01\x01\x02\x7f\x01\x7d\x01\x7d\x01\x7d\x01\x7d\x01\x7d\x01\x7d\x01\x7d\x01\x7d\x01\x7d\x01\x67\x01\x66\x01\x01\x02\x68\x01\x01\x02\x6a\x01\x73\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x25\x02\x01\x02\x01\x02\xb4\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x72\x01\x01\x02\x01\x02\x69\x01\x01\x02\x05\x02\x01\x02\xe1\x01\x94\x01\x03\x02\xd4\x01\x01\x02\xee\x01\x62\x02\x01\x02\x01\x02\xac\x01\xd8\x01\x00\x02\x29\x02\xf0\x01\xd9\x01\xe2\x01\xec\x01\xeb\x01\xdd\x01\xf9\x01\xbc\x01\x01\x02\x01\x02\x01\x02\x75\x01\x6b\x01\x76\x01\x01\x02\x2c\x01\x3a\x00\x3a\x00\x3a\x00\x00\x00\x00\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x3a\x00\x3a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x3b\x00\x00\x00\x00\x00\x14\x00\x14\x00\x14\x00\x0a\x00\x3a\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x1a\x00\x14\x00\x14\x00\x19\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x09\x00\x14\x00\x00\x00\x14\x00\x2b\x01\x3a\x00\x3a\x00\x3a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x01\x02\x78\x01\x01\x02\x01\x02\x01\x02\x01\x02\x77\x01\x6f\x01\x70\x01\x01\x02\x01\x02\x01\x02\x8d\x01\x65\x01\x01\x02\x7f\x01\x7d\x01\x7d\x01\x7d\x01\x7d\x01\x7d\x01\x7d\x01\x7d\x01\x7d\x01\x7d\x01\x67\x01\x66\x01\x01\x02\x68\x01\x01\x02\x6a\x01\x73\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x25\x02\x01\x02\x01\x02\xb4\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x72\x01\x01\x02\x01\x02\x69\x01\x01\x02\x05\x02\x01\x02\xe1\x01\x94\x01\x03\x02\xd4\x01\x01\x02\xee\x01\x62\x02\x01\x02\x01\x02\xac\x01\xd8\x01\x00\x02\x29\x02\xf0\x01\xd9\x01\xe2\x01\xec\x01\xeb\x01\xdd\x01\xf9\x01\xbc\x01\x01\x02\x01\x02\x01\x02\x75\x01\x6b\x01\x76\x01\x01\x02\x3a\x00\x3a\x00\x3a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x00\x00\x00\x00\x14\x00\x14\x00\x14\x00\x0a\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x1a\x00\x14\x00\x14\x00\x19\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x09\x00\x14\x00\x00\x00\x14\x00\xff\xff\x3c\x00\x3c\x00\x3c\x00\x3c\x00\x62\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1d\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3c\x00\x00\x00\x01\x02\x1b\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\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\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x74\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\x1a\x01\x00\x00\x01\x02\x00\x00\x01\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\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\x31\x00\x13\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x27\x00\x18\x00\x1e\x00\x1e\x00\x1e\x00\x1f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2b\x01\x3a\x00\x3a\x00\x3a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x8c\x01\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x0d\x00\x01\x02\x01\x02\x0c\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xaa\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x09\x00\x01\x02\x00\x00\x01\x02\x2d\x01\x3a\x00\x3a\x00\x3a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3a\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x00\x00\x00\x00\x14\x00\x14\x00\x14\x00\x0a\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x1a\x00\x14\x00\x14\x00\x19\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x09\x00\x14\x00\x00\x00\x14\x00\xff\xff\x3c\x00\x3c\x00\x3c\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\x3c\x00\x00\x00\x78\x01\x71\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\xa5\x00\xa7\x00\x11\x01\xa6\x00\x00\x00\x00\x00\xee\x00\x00\x00\x00\x00\x80\x00\xab\x00\xb2\x00\xe7\x00\xb7\x00\x00\x00\xaf\x00\xeb\x00\xc5\x00\x00\x00\x00\x00\xd1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\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\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x00\x00\x14\x00\x14\x00\x14\x00\x22\x01\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x1f\x01\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x00\x00\x14\x00\x14\x00\x14\x00\x0b\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x20\x01\x14\x00\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x44\x02\x01\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\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\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x44\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\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x0f\x00\x44\x02\x44\x02\x0e\x00\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x44\x02\x00\x00\x44\x02\x36\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x30\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\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\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x00\x00\x14\x00\x14\x00\x14\x00\x0b\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x00\x00\x14\x00\x2d\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x11\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x13\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x14\x00\x00\x00\x14\x00\x14\x00\x14\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\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x14\x00\x14\x00\x14\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\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x14\x00\x15\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x25\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\x27\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\x29\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\x2b\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\x2e\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\x31\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\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\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x00\x00\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x44\x02\x8a\x01\x88\x01\x88\x01\x88\x01\x88\x01\x88\x01\x88\x01\x88\x01\x88\x01\x88\x01\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x0f\x00\x44\x02\x44\x02\x0e\x00\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x44\x02\x00\x00\x44\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x36\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x39\x00\x38\x00\x11\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2a\x00\x2b\x00\x16\x00\x22\x00\x22\x00\x22\x00\x23\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\xff\xff\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x00\x00\x01\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x30\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\x31\x00\x13\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x27\x00\x18\x00\x1e\x00\x1e\x00\x1e\x00\x1f\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\xff\xff\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xf1\x01\x01\x02\xaf\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x0c\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x00\x00\x01\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x30\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\x31\x00\x13\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x27\x00\x18\x00\x1e\x00\x1e\x00\x1e\x00\x1f\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\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\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x49\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x50\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x56\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0f\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0b\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x75\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x76\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x77\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x87\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf1\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x93\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x95\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x98\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaa\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe5\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xde\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xdb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcb\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xd2\x00\xd7\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd4\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xce\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xca\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xba\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xec\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x94\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x91\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe2\x00\xfa\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x89\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa9\x00\x00\x00\x7e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x72\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x68\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x16\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x33\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x35\x00\x34\x00\x12\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x28\x00\x29\x00\x17\x00\x20\x00\x20\x00\x20\x00\x21\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x02\x3f\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x00\x00\x01\x02\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\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\x31\x00\x13\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x27\x00\x18\x00\x1e\x00\x1e\x00\x1e\x00\x1f\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\xff\xff\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x00\x00\x01\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x00\x00\x00\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\x30\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\x31\x00\x13\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x27\x00\x18\x00\x1e\x00\x1e\x00\x1e\x00\x1f\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x18\x01\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\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\x31\x00\x13\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x27\x00\x18\x00\x1e\x00\x1e\x00\x1e\x00\x1f\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\xff\xff\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x19\x01\x01\x02\x01\x02\x01\x02\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\x01\x02\x01\x02\x01\x02\x01\x02\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\x01\x02\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\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\x31\x00\x13\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x27\x00\x18\x00\x1e\x00\x1e\x00\x1e\x00\x1f\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\xff\xff\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x00\x00\x01\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x30\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\x31\x00\x13\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x26\x00\x27\x00\x18\x00\x1e\x00\x1e\x00\x1e\x00\x1f\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\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2e\x00\x15\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x25\x00\x1b\x00\x1c\x00\x1c\x00\x1c\x00\x1d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\xff\xff\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x00\x00\x24\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x24\x01\x24\x01\x00\x00\x00\x00\x00\x00\x22\x01\x24\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\x24\x01\x00\x00\x00\x00\x00\x00\x00\x00\x24\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\x24\x01\x00\x00\x21\x01\x00\x00\x24\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2e\x00\x15\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x25\x00\x1b\x00\x1c\x00\x1c\x00\x1c\x00\x1d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\xff\xff\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x00\x00\x24\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x24\x01\x24\x01\x00\x00\x00\x00\x00\x00\x22\x01\x24\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\x24\x01\x00\x00\x00\x00\x00\x00\x00\x00\x24\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\x24\x01\x00\x00\x24\x01\x00\x00\x24\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2e\x00\x15\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x25\x00\x1b\x00\x1c\x00\x1c\x00\x1c\x00\x1d\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\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2e\x00\x15\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x25\x00\x1b\x00\x1c\x00\x1c\x00\x1c\x00\x1d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\xff\xff\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x00\x00\x24\x01\x00\x00\x00\x00\x00\x00\x00\x00\x24\x01\x24\x01\x24\x01\x00\x00\x00\x00\x00\x00\x00\x00\x24\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\x24\x01\x00\x00\x00\x00\x00\x00\x00\x00\x24\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\x26\x01\x00\x00\x00\x00\x27\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\x24\x01\x00\x00\x24\x01\x00\x00\x24\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2e\x00\x15\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x25\x00\x1b\x00\x1c\x00\x1c\x00\x1c\x00\x1d\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x00\x00\x2a\x01\x2a\x01\x2a\x01\x2a\x01\x2a\x01\x00\x00\x00\x00\x2a\x01\x2a\x01\x2a\x01\x2a\x01\x00\x00\x2a\x01\x2a\x01\x2a\x01\x2a\x01\x2a\x01\x2a\x01\x2a\x01\x2a\x01\x2a\x01\x2a\x01\x2a\x01\x2a\x01\x00\x00\x2a\x01\x2a\x01\x2a\x01\x2a\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\x2a\x01\x2a\x01\x2a\x01\x2a\x01\x00\x00\x2a\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\x2a\x01\x00\x00\x2a\x01\x00\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\x2d\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2e\x00\x15\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x25\x00\x1b\x00\x1c\x00\x1c\x00\x1c\x00\x1d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\xff\xff\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x00\x00\x24\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x24\x01\x24\x01\x00\x00\x00\x00\x00\x00\x00\x00\x24\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\x24\x01\x00\x00\x00\x00\x00\x00\x00\x00\x24\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\x24\x01\x00\x00\x24\x01\x00\x00\x24\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2e\x00\x15\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x25\x00\x1b\x00\x1c\x00\x1c\x00\x1c\x00\x1d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\xff\xff\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x00\x00\x24\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x24\x01\x24\x01\x00\x00\x00\x00\x00\x00\x28\x01\x25\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\x24\x01\x00\x00\x00\x00\x00\x00\x00\x00\x24\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\x24\x01\x00\x00\x21\x01\x00\x00\x24\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2e\x00\x15\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x25\x00\x1b\x00\x1c\x00\x1c\x00\x1c\x00\x1d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\xff\xff\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x00\x00\x24\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x24\x01\x24\x01\x00\x00\x00\x00\x00\x00\x28\x01\x25\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\x24\x01\x00\x00\x00\x00\x00\x00\x00\x00\x24\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\x24\x01\x00\x00\x24\x01\x00\x00\x24\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2e\x00\x15\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x25\x00\x1b\x00\x1c\x00\x1c\x00\x1c\x00\x1d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\xff\xff\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x24\x01\x00\x00\x24\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x24\x01\x24\x01\x00\x00\x00\x00\x00\x00\x00\x00\x25\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\x24\x01\x00\x00\x00\x00\x00\x00\x00\x00\x24\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\x24\x01\x00\x00\x24\x01\x00\x00\x24\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2f\x00\x2e\x00\x15\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x24\x00\x25\x00\x1b\x00\x1c\x00\x1c\x00\x1c\x00\x1d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x43\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x44\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x50\x01\x4f\x01\x4f\x01\x4f\x01\x4f\x01\x4f\x01\x4f\x01\x4f\x01\x4f\x01\x4f\x01\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x53\x01\x52\x01\x52\x01\x52\x01\x52\x01\x52\x01\x52\x01\x52\x01\x52\x01\x52\x01\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x4f\x01\x4f\x01\x4f\x01\x4f\x01\x4f\x01\x4f\x01\x4f\x01\x4f\x01\x4f\x01\x4f\x01\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x4f\x01\x4f\x01\x4f\x01\x4f\x01\x4f\x01\x4f\x01\x4f\x01\x4f\x01\x4f\x01\x4f\x01\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x54\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x51\x01\x51\x01\x51\x01\x51\x01\x51\x01\x51\x01\x51\x01\x51\x01\x51\x01\x51\x01\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x51\x01\x51\x01\x51\x01\x51\x01\x51\x01\x51\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x51\x01\x51\x01\x51\x01\x51\x01\x51\x01\x51\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x52\x01\x52\x01\x52\x01\x52\x01\x52\x01\x52\x01\x52\x01\x52\x01\x52\x01\x52\x01\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x52\x01\x52\x01\x52\x01\x52\x01\x52\x01\x52\x01\x52\x01\x52\x01\x52\x01\x52\x01\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x53\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xce\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\xb6\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x6d\x01\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x49\x02\x01\x02\x92\x01\x2c\x00\x01\x02\x7c\x01\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x79\x01\x7a\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x79\x01\x7a\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x2c\x00\x01\x02\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x79\x01\x7a\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x79\x01\x7a\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x2c\x00\x01\x02\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x2c\x00\x01\x02\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x79\x01\x7a\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x79\x01\x7a\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x45\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x2c\x00\x01\x02\x7d\x01\x7d\x01\x7d\x01\x7d\x01\x7d\x01\x7d\x01\x7d\x01\x7d\x01\x7d\x01\x7d\x01\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x48\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x4e\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x48\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x2c\x00\x01\x02\x7e\x01\x7e\x01\x7e\x01\x7e\x01\x7e\x01\x7e\x01\x7e\x01\x7e\x01\x7e\x01\x7e\x01\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x4e\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x2c\x00\x01\x02\x7d\x01\x7d\x01\x7d\x01\x7d\x01\x7d\x01\x7d\x01\x7d\x01\x7d\x01\x7d\x01\x7d\x01\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x48\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x4e\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x48\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x4d\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x2c\x00\x01\x02\x7e\x01\x7e\x01\x7e\x01\x7e\x01\x7e\x01\x7e\x01\x7e\x01\x7e\x01\x7e\x01\x7e\x01\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x4e\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x4c\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x81\x01\x81\x01\x81\x01\x81\x01\x81\x01\x81\x01\x81\x01\x81\x01\x81\x01\x81\x01\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x81\x01\x81\x01\x81\x01\x81\x01\x81\x01\x81\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x81\x01\x81\x01\x81\x01\x81\x01\x81\x01\x81\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x44\x02\x01\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x00\x00\x44\x02\x4b\x02\x44\x02\x4b\x02\x10\x00\x44\x02\x85\x01\x83\x01\x83\x01\x83\x01\x83\x01\x83\x01\x83\x01\x83\x01\x83\x01\x83\x01\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x83\x01\x83\x01\x83\x01\x83\x01\x82\x01\x83\x01\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x83\x01\x83\x01\x83\x01\x83\x01\x82\x01\x83\x01\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x10\x00\x44\x02\x83\x01\x83\x01\x83\x01\x83\x01\x83\x01\x83\x01\x83\x01\x83\x01\x83\x01\x83\x01\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x83\x01\x83\x01\x83\x01\x83\x01\x82\x01\x83\x01\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x83\x01\x83\x01\x83\x01\x83\x01\x82\x01\x83\x01\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x10\x00\x44\x02\x84\x01\x84\x01\x84\x01\x84\x01\x84\x01\x84\x01\x84\x01\x84\x01\x84\x01\x84\x01\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x84\x01\x84\x01\x84\x01\x84\x01\x84\x01\x84\x01\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x84\x01\x84\x01\x84\x01\x84\x01\x84\x01\x84\x01\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x10\x00\x44\x02\x83\x01\x83\x01\x83\x01\x83\x01\x83\x01\x83\x01\x83\x01\x83\x01\x83\x01\x83\x01\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x83\x01\x83\x01\x83\x01\x83\x01\x82\x01\x83\x01\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x83\x01\x83\x01\x83\x01\x83\x01\x82\x01\x83\x01\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x46\x02\x44\x02\x44\x02\x00\x00\x44\x02\x01\x02\x44\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x86\x01\x86\x01\x86\x01\x86\x01\x86\x01\x86\x01\x86\x01\x86\x01\x86\x01\x86\x01\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x86\x01\x86\x01\x86\x01\x86\x01\x86\x01\x86\x01\x86\x01\x86\x01\x86\x01\x86\x01\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x45\x02\x01\x02\x01\x02\x00\x00\x01\x02\x44\x02\x01\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x10\x00\x44\x02\x88\x01\x88\x01\x88\x01\x88\x01\x88\x01\x88\x01\x88\x01\x88\x01\x88\x01\x88\x01\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x4a\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x4a\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x10\x00\x44\x02\x89\x01\x89\x01\x89\x01\x89\x01\x89\x01\x89\x01\x89\x01\x89\x01\x89\x01\x89\x01\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x10\x00\x44\x02\x88\x01\x88\x01\x88\x01\x88\x01\x88\x01\x88\x01\x88\x01\x88\x01\x88\x01\x88\x01\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x4a\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x4a\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x47\x02\x44\x02\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x10\x00\x44\x02\x89\x01\x89\x01\x89\x01\x89\x01\x89\x01\x89\x01\x89\x01\x89\x01\x89\x01\x89\x01\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x46\x02\x44\x02\x44\x02\x00\x00\x44\x02\x01\x02\x44\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x28\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x1f\x01\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x28\x01\x10\x00\x01\x02\x80\x01\x7e\x01\x7e\x01\x7e\x01\x7e\x01\x7e\x01\x7e\x01\x7e\x01\x7e\x01\x7e\x01\x01\x02\x00\x00\x01\x02\x01\x02\x71\x01\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x1f\x01\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xf7\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x20\x01\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xf8\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x20\x01\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x02\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x20\x01\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x20\x01\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x87\x01\x86\x01\x86\x01\x86\x01\x86\x01\x86\x01\x86\x01\x86\x01\x86\x01\x86\x01\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x20\x01\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x30\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x3b\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x31\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x34\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x35\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x36\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x39\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x3a\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x3b\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x3e\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x3f\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x40\x01\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x41\x01\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x47\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x48\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x4a\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x54\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x55\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x56\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x59\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x5c\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x5d\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x5e\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x5f\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x60\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x61\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x63\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x5f\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x5c\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x5b\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x5a\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x59\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xa0\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x58\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x57\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x56\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x51\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xa5\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x50\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xab\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x43\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x42\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xba\x01\x41\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x40\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x3f\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x3e\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x3d\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x3c\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x3a\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x39\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x38\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x37\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x36\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x35\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xb0\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xb1\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x34\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x33\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x32\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x31\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x30\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x2f\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x2e\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x2c\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x2b\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x2a\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xbb\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x12\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xc3\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xef\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x20\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x28\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x27\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xcb\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x1c\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x16\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xcd\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xcf\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x24\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x22\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xea\x01\x01\x02\x01\x02\x01\x02\x01\x02\xd1\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xd3\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x1f\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x1e\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x1b\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xd5\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xd6\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x1a\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x19\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x18\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x17\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x14\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x13\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xda\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xdb\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x11\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xdc\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x0f\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xde\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x0b\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xf6\x01\x01\x02\x01\x02\xe8\x01\x01\x02\x01\x02\x0e\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xe4\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xe5\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xe6\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xe7\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x0d\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x0a\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xf3\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xf4\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x08\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x07\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x8e\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x8f\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xfb\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xfc\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x90\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xff\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xfe\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xfd\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x06\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xf5\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xf2\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x09\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xed\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xe3\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xdf\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x10\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xd7\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x15\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x21\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xd2\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xd0\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x23\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xcc\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x26\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xe0\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xca\x01\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xc9\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xc8\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xc7\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xc6\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xc5\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xc4\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xc2\x01\x01\x02\x01\x02\x01\x02\x01\x02\x04\x02\x01\x02\x01\x02\x01\x02\x01\x02\xfa\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xc1\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xc0\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xbf\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xbe\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xbd\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xb9\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x2d\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xb8\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xb7\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xb5\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xb3\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xb2\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xae\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xad\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xe9\x01\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xa9\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xa8\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xa7\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xa6\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x4f\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xa4\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xa3\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xa2\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x55\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\xa1\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x9f\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x9e\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x9d\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x9c\x01\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x9b\x01\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x5d\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x9a\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x99\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x98\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x5e\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x97\x01\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x96\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x95\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x60\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x61\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x93\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x44\x02\x01\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x10\x00\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x44\x02\x01\x02\x44\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x81\x01\x81\x01\x81\x01\x81\x01\x81\x01\x81\x01\x81\x01\x81\x01\x81\x01\x81\x01\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x81\x01\x81\x01\x81\x01\x81\x01\x81\x01\x81\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x81\x01\x81\x01\x81\x01\x81\x01\x81\x01\x81\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x44\x02\x01\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x10\x00\x44\x02\x84\x01\x84\x01\x84\x01\x84\x01\x84\x01\x84\x01\x84\x01\x84\x01\x84\x01\x84\x01\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x84\x01\x84\x01\x84\x01\x84\x01\x84\x01\x84\x01\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x84\x01\x84\x01\x84\x01\x84\x01\x84\x01\x84\x01\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x10\x00\x44\x02\x83\x01\x83\x01\x83\x01\x83\x01\x83\x01\x83\x01\x83\x01\x83\x01\x83\x01\x83\x01\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x83\x01\x83\x01\x83\x01\x83\x01\x83\x01\x83\x01\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x83\x01\x83\x01\x83\x01\x83\x01\x83\x01\x83\x01\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x44\x02\x01\x02\x44\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x49\x02\x01\x02\x92\x01\x10\x00\x01\x02\x87\x01\x86\x01\x86\x01\x86\x01\x86\x01\x86\x01\x86\x01\x86\x01\x86\x01\x86\x01\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x87\x01\x86\x01\x86\x01\x86\x01\x86\x01\x86\x01\x86\x01\x86\x01\x86\x01\x86\x01\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x44\x02\x01\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x00\x00\x44\x02\x4b\x02\x44\x02\x4b\x02\x10\x00\x44\x02\x8b\x01\x89\x01\x89\x01\x89\x01\x89\x01\x89\x01\x89\x01\x89\x01\x89\x01\x89\x01\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x10\x00\x44\x02\x8b\x01\x89\x01\x89\x01\x89\x01\x89\x01\x89\x01\x89\x01\x89\x01\x89\x01\x89\x01\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x44\x02\x00\x00\x44\x02\x01\x02\x44\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x7b\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x7a\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x7e\x01\x7e\x01\x7e\x01\x7e\x01\x7e\x01\x7e\x01\x7e\x01\x7e\x01\x7e\x01\x7e\x01\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x5b\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x5a\x01\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x52\x02\x01\x02\x01\x02\x58\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x57\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x51\x01\x51\x01\x51\x01\x51\x01\x51\x01\x51\x01\x51\x01\x51\x01\x51\x01\x51\x01\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x51\x01\x51\x01\x51\x01\x51\x01\x51\x01\x51\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x51\x01\x51\x01\x51\x01\x51\x01\x51\x01\x51\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x4e\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x4d\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x4c\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x4b\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x49\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x46\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x45\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x42\x01\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x3d\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x3c\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x38\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x37\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x33\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x32\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x1d\x02\x2f\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x00\x00\x01\x02\x01\x02\x01\x02\x91\x01\x10\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x2e\x01\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x01\x02\x00\x00\x01\x02\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x2d\x00\x23\x00\x2e\x00\x2e\x00\x29\x00\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\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\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x20\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x20\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\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\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\xff\xff\x7e\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\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\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\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\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\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\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\xff\xff\x7e\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x21\x00\x23\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\x5c\x00\x5d\x00\x5e\x00\xff\xff\x60\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\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\x7b\x00\xff\xff\x7c\x00\xff\xff\x7e\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x2c\x00\x2d\x00\xff\xff\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\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\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\xff\xff\x7e\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x2c\x00\x2d\x00\xff\xff\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\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\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\xff\xff\x7e\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\x00\x23\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\x42\x00\x43\x00\x44\x00\x45\x00\x46\x00\xff\xff\xff\xff\x49\x00\xff\xff\xff\xff\x4c\x00\x4d\x00\x4e\x00\x4f\x00\x50\x00\xff\xff\x52\x00\x53\x00\x54\x00\xff\xff\xff\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7b\x00\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\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\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\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\xff\xff\x7c\x00\x7d\x00\x7e\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\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\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\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\xff\xff\x7c\x00\x7d\x00\x7e\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\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\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\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\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\x5c\x00\x5d\x00\x5e\x00\xff\xff\x60\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\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x7c\x00\xff\xff\x7e\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\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\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\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\xff\xff\x7c\x00\xff\xff\x7e\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\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\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\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\xff\xff\x7c\x00\xff\xff\x7e\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\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\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\x5c\x00\x5d\x00\x5e\x00\xff\xff\x60\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\x7c\x00\xff\xff\x7e\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\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\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\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\xff\xff\x7c\x00\xff\xff\x7e\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\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\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\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\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\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\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\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\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\x7f\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\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\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\x7f\x00\x0a\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\x21\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xc0\x00\xc1\x00\xc2\x00\xc3\x00\xc4\x00\xc5\x00\xc6\x00\xc7\x00\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\x20\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\x20\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\x00\x23\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x7d\x00\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x59\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x41\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4b\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4b\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4b\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x47\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x47\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x59\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x43\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x47\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x47\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x41\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x43\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x43\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x43\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x47\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x41\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x55\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x41\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x41\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x43\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4d\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x43\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x41\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x43\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x43\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x43\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x41\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x41\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x41\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x55\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4d\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x55\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x41\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\x4f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\x00\xff\xff\xff\xff\xff\xff\xff\xff\x4e\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\x5f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x5f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x5f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x5f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x5f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x59\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x43\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\x54\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4d\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4d\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x5f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x5f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x47\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x41\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x49\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4d\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x50\x00\xff\xff\xff\xff\xff\xff\x54\x00\x55\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4f\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x41\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x52\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x52\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x54\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x56\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x54\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x56\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x52\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x52\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x52\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x54\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4c\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x56\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x54\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x54\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x54\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4d\x00\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x52\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x54\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x52\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x52\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x54\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x52\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x48\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x48\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x48\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4c\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4a\x00\xff\xff\x4c\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x54\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x48\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4c\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x54\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x42\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4c\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x54\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x52\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x54\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x54\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x52\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x56\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4c\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x54\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4c\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4c\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x54\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4c\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x22\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\x4e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\xff\xff\x21\x00\x23\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\xff\xff\x7e\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\x20\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x7d\x00\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x20\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\x2d\x00\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\xff\xff\x7e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x20\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\x2d\x00\x3c\x00\x3d\x00\x3e\x00\x3f\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\x5b\x00\x5c\x00\x5d\x00\x5e\x00\xff\xff\x60\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\x7c\x00\xff\xff\x7e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x09\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\xff\xff\xff\xff\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\x20\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\xff\xff\x7e\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\xff\xff\x7e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\x29\x00\xff\xff\xff\xff\xff\xff\x2d\x00\x2e\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\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x40\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\x7b\x00\xff\xff\x7d\x00\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\x29\x00\xff\xff\xff\xff\xff\xff\x2d\x00\x2e\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\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x40\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\x7b\x00\xff\xff\x7d\x00\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\xff\xff\x7e\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\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\x27\x00\x28\x00\x29\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2e\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\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x40\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\x5c\x00\xff\xff\xff\xff\x5f\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\x7b\x00\xff\xff\x7d\x00\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x0a\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\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\x5c\x00\x5d\x00\x5e\x00\xff\xff\x60\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\x7c\x00\xff\xff\x7e\x00\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\x29\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2e\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\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x40\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\x7b\x00\xff\xff\x7d\x00\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\x29\x00\xff\xff\xff\xff\xff\xff\x2d\x00\x2e\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\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x40\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\x7b\x00\xff\xff\x7d\x00\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\x29\x00\xff\xff\xff\xff\xff\xff\x2d\x00\x2e\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\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x40\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\x7b\x00\xff\xff\x7d\x00\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x1e\x00\x1f\x00\x20\x00\xff\xff\x22\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x28\x00\x29\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2e\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\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x40\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\x7b\x00\xff\xff\x7d\x00\xff\xff\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x9f\x00\xa0\x00\xa1\x00\xa2\x00\xa3\x00\xa4\x00\xa5\x00\xa6\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\xad\x00\xae\x00\xaf\x00\xb0\x00\xb1\x00\xb2\x00\xb3\x00\xb4\x00\xb5\x00\xb6\x00\xb7\x00\xb8\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\xc8\x00\xc9\x00\xca\x00\xcb\x00\xcc\x00\xcd\x00\xce\x00\xcf\x00\xd0\x00\xd1\x00\xd2\x00\xd3\x00\xd4\x00\xd5\x00\xd6\x00\xd7\x00\xd8\x00\xd9\x00\xda\x00\xdb\x00\xdc\x00\xdd\x00\xde\x00\xdf\x00\xe0\x00\xe1\x00\xe2\x00\xe3\x00\xe4\x00\xe5\x00\xe6\x00\xe7\x00\xe8\x00\xe9\x00\xea\x00\xeb\x00\xec\x00\xed\x00\xee\x00\xef\x00\xf0\x00\xf1\x00\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x7d\x00\x7e\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x7d\x00\x7e\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x7d\x00\x7e\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x7d\x00\x7e\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x7d\x00\x7e\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x7d\x00\x7e\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x7d\x00\x7e\x00\x21\x00\xff\xff\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\x21\x00\x7e\x00\x23\x00\x24\x00\x25\x00\x26\x00\x27\x00\xff\xff\xff\xff\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\xff\xff\x3c\x00\x3d\x00\x3e\x00\x3f\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\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\xff\xff\x7c\x00\xff\xff\x7e\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"# + +alex_deflt :: AlexAddr +alex_deflt = AlexA# + "\xff\xff\xff\xff\xff\xff\xff\xff\x1c\x01\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\x24\x00\x24\x00\x26\x00\x26\x00\x28\x00\x28\x00\x2a\x00\x2a\x00\x2f\x00\x2f\x00\x32\x00\x32\x00\x35\x00\x35\x00\x39\x00\x39\x00\xff\xff\x24\x01\x24\x01\x24\x01\x1c\x01\x1c\x01\x1c\x01\xd3\x00\xd3\x00\xd3\x00\x3b\x00\x3b\x00\x3b\x00\x3b\x00\xff\xff\xff\xff\xff\xff\xff\xff\xd3\x00\x1c\x01\x1c\x01\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\xd3\x00\x1c\x01\x1c\x01\x1c\x01\x1c\x01\x1c\x01\xff\xff\xff\xff\xff\xff\xff\xff\x24\x01\x23\x01\x23\x01\x24\x01\x2a\x01\x24\x01\x2a\x01\x29\x01\x29\x01\x2a\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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, 611) + [ AlexAccNone + , AlexAccPred 554 ( not' eof )(AlexAccNone) + , AlexAccNone + , AlexAcc 553 + , AlexAccNone + , AlexAccNone + , AlexAcc 552 + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccNone + , AlexAccSkip + , AlexAccSkip + , AlexAccSkip + , AlexAcc 551 + , AlexAcc 550 + , AlexAcc 549 + , AlexAcc 548 + , AlexAcc 547 + , AlexAcc 546 + , AlexAcc 545 + , AlexAcc 544 + , AlexAcc 543 + , AlexAcc 542 + , AlexAcc 541 + , AlexAcc 540 + , AlexAcc 539 + , AlexAcc 538 + , AlexAcc 537 + , AlexAcc 536 + , AlexAcc 535 + , AlexAcc 534 + , AlexAcc 533 + , AlexAcc 532 + , AlexAcc 531 + , AlexAcc 530 + , AlexAcc 529 + , AlexAcc 528 + , AlexAcc 527 + , AlexAcc 526 + , AlexAcc 525 + , AlexAcc 524 + , AlexAcc 523 + , AlexAcc 522 + , AlexAcc 521 + , AlexAcc 520 + , AlexAcc 519 + , AlexAcc 518 + , AlexAcc 517 + , AlexAcc 516 + , AlexAcc 515 + , AlexAcc 514 + , AlexAcc 513 + , AlexAcc 512 + , AlexAcc 511 + , AlexAcc 510 + , AlexAcc 509 + , AlexAcc 508 + , AlexAcc 507 + , AlexAcc 506 + , AlexAcc 505 + , AlexAcc 504 + , AlexAcc 503 + , AlexAcc 502 + , AlexAcc 501 + , AlexAcc 500 + , AlexAcc 499 + , AlexAcc 498 + , AlexAcc 497 + , AlexAcc 496 + , AlexAcc 495 + , AlexAcc 494 + , AlexAcc 493 + , AlexAcc 492 + , AlexAcc 491 + , AlexAcc 490 + , AlexAcc 489 + , AlexAcc 488 + , AlexAcc 487 + , AlexAcc 486 + , AlexAcc 485 + , AlexAcc 484 + , AlexAcc 483 + , AlexAcc 482 + , AlexAcc 481 + , AlexAcc 480 + , AlexAcc 479 + , AlexAcc 478 + , AlexAcc 477 + , AlexAcc 476 + , AlexAcc 475 + , AlexAcc 474 + , AlexAcc 473 + , AlexAcc 472 + , AlexAcc 471 + , AlexAcc 470 + , AlexAcc 469 + , AlexAcc 468 + , AlexAcc 467 + , AlexAcc 466 + , AlexAcc 465 + , AlexAcc 464 + , AlexAcc 463 + , AlexAcc 462 + , AlexAcc 461 + , AlexAcc 460 + , AlexAcc 459 + , AlexAcc 458 + , AlexAcc 457 + , AlexAcc 456 + , AlexAcc 455 + , AlexAcc 454 + , AlexAcc 453 + , AlexAcc 452 + , AlexAcc 451 + , AlexAcc 450 + , AlexAcc 449 + , AlexAcc 448 + , AlexAcc 447 + , AlexAcc 446 + , AlexAcc 445 + , AlexAcc 444 + , AlexAcc 443 + , AlexAcc 442 + , AlexAcc 441 + , AlexAcc 440 + , AlexAcc 439 + , AlexAcc 438 + , AlexAcc 437 + , AlexAcc 436 + , AlexAcc 435 + , AlexAcc 434 + , AlexAcc 433 + , AlexAcc 432 + , AlexAcc 431 + , AlexAcc 430 + , AlexAcc 429 + , AlexAcc 428 + , AlexAcc 427 + , AlexAcc 426 + , AlexAcc 425 + , AlexAcc 424 + , AlexAcc 423 + , AlexAcc 422 + , AlexAcc 421 + , AlexAcc 420 + , AlexAcc 419 + , AlexAcc 418 + , AlexAcc 417 + , AlexAcc 416 + , AlexAcc 415 + , AlexAcc 414 + , AlexAcc 413 + , AlexAcc 412 + , AlexAcc 411 + , AlexAcc 410 + , AlexAcc 409 + , AlexAcc 408 + , AlexAcc 407 + , AlexAcc 406 + , AlexAcc 405 + , AlexAcc 404 + , AlexAcc 403 + , AlexAcc 402 + , AlexAcc 401 + , AlexAcc 400 + , AlexAcc 399 + , AlexAcc 398 + , AlexAcc 397 + , AlexAcc 396 + , AlexAcc 395 + , AlexAcc 394 + , AlexAcc 393 + , AlexAcc 392 + , AlexAcc 391 + , AlexAcc 390 + , AlexAcc 389 + , AlexAcc 388 + , AlexAcc 387 + , AlexAcc 386 + , AlexAcc 385 + , AlexAcc 384 + , AlexAcc 383 + , AlexAcc 382 + , AlexAcc 381 + , AlexAcc 380 + , AlexAcc 379 + , AlexAcc 378 + , AlexAcc 377 + , AlexAcc 376 + , AlexAcc 375 + , AlexAcc 374 + , AlexAcc 373 + , AlexAcc 372 + , AlexAcc 371 + , AlexAcc 370 + , AlexAcc 369 + , AlexAcc 368 + , AlexAcc 367 + , AlexAcc 366 + , AlexAcc 365 + , AlexAcc 364 + , AlexAcc 363 + , AlexAcc 362 + , AlexAcc 361 + , AlexAcc 360 + , AlexAcc 359 + , AlexAcc 358 + , AlexAcc 357 + , AlexAcc 356 + , AlexAcc 355 + , AlexAcc 354 + , AlexAcc 353 + , AlexAcc 352 + , AlexAcc 351 + , AlexAcc 350 + , AlexAcc 349 + , AlexAcc 348 + , AlexAcc 347 + , AlexAcc 346 + , AlexAcc 345 + , AlexAcc 344 + , AlexAcc 343 + , AlexAcc 342 + , AlexAcc 341 + , AlexAcc 340 + , AlexAcc 339 + , AlexAcc 338 + , AlexAcc 337 + , AlexAcc 336 + , AlexAcc 335 + , AlexAcc 334 + , AlexAcc 333 + , AlexAcc 332 + , AlexAcc 331 + , AlexAcc 330 + , AlexAcc 329 + , AlexAcc 328 + , AlexAccPred 327 ( not' (followedBy '#') )(AlexAccNone) + , AlexAccPred 326 ( not' (followedBy '#') )(AlexAccNone) + , AlexAcc 325 + , AlexAcc 324 + , AlexAcc 323 + , AlexAccPred 322 ( keepComments .&&. (followedBy '\n' .||. eof) )(AlexAccSkipPred ( followedBy '\n' .||. eof )(AlexAccNone)) + , AlexAccPred 321 ( keepComments .&&. (followedBy '\n' .||. eof) )(AlexAccSkipPred ( followedBy '\n' .||. eof )(AlexAccNone)) + , AlexAccPred 320 ( keepComments .&&. (followedBy '\n' .||. eof) )(AlexAccSkipPred ( followedBy '\n' .||. eof )(AlexAccNone)) + , AlexAccPred 319 ( keepComments .&&. (followedBy '\n' .||. eof) )(AlexAccSkipPred ( followedBy '\n' .||. eof )(AlexAccNone)) + , AlexAccPred 318 ( keepComments .&&. (followedBy '\n' .||. eof) )(AlexAccSkipPred ( followedBy '\n' .||. eof )(AlexAccNone)) + , AlexAccPred 317 ( keepComments .&&. (followedBy '\n' .||. eof) )(AlexAccSkipPred ( followedBy '\n' .||. eof )(AlexAccNone)) + , AlexAccPred 316 ( keepComments .&&. (followedBy '\n' .||. eof) )(AlexAccSkipPred ( followedBy '\n' .||. eof )(AlexAcc 315)) + , AlexAccPred 314 ( keepComments .&&. (followedBy '\n' .||. eof) )(AlexAccSkipPred ( followedBy '\n' .||. eof )(AlexAcc 313)) + , AlexAccPred 312 ( keepComments .&&. (followedBy '\n' .||. eof) )(AlexAccSkipPred ( followedBy '\n' .||. eof )(AlexAcc 311)) + , AlexAcc 310 + , AlexAccSkip + , AlexAccSkip + , AlexAcc 309 + , AlexAcc 308 + , AlexAcc 307 + , AlexAcc 306 + , AlexAcc 305 + , AlexAcc 304 + , AlexAcc 303 + , AlexAcc 302 + , AlexAcc 301 + , AlexAcc 300 + , AlexAcc 299 + , AlexAcc 298 + , AlexAcc 297 + , AlexAcc 296 + , AlexAcc 295 + , AlexAcc 294 + , AlexAcc 293 + , AlexAcc 292 + , AlexAcc 291 + , AlexAcc 290 + , AlexAcc 289 + , AlexAcc 288 + , AlexAcc 287 + , AlexAcc 286 + , AlexAcc 285 + , AlexAcc 284 + , AlexAcc 283 + , AlexAcc 282 + , AlexAcc 281 + , AlexAcc 280 + , AlexAcc 279 + , AlexAcc 278 + , AlexAcc 277 + , AlexAcc 276 + , AlexAcc 275 + , AlexAcc 274 + , AlexAcc 273 + , AlexAcc 272 + , AlexAcc 271 + , AlexAcc 270 + , AlexAcc 269 + , AlexAcc 268 + , AlexAcc 267 + , AlexAcc 266 + , AlexAcc 265 + , AlexAcc 264 + , AlexAcc 263 + , AlexAcc 262 + , AlexAcc 261 + , AlexAcc 260 + , AlexAcc 259 + , AlexAcc 258 + , AlexAcc 257 + , AlexAcc 256 + , AlexAcc 255 + , AlexAcc 254 + , AlexAcc 253 + , AlexAcc 252 + , AlexAcc 251 + , AlexAcc 250 + , AlexAcc 249 + , AlexAcc 248 + , AlexAccPred 247 (alexRightContext 8)(AlexAccNone) + , AlexAcc 246 + , AlexAcc 245 + , AlexAcc 244 + , AlexAcc 243 + , AlexAcc 242 + , AlexAcc 241 + , AlexAcc 240 + , AlexAccPred 239 (alexRightContext 55)(AlexAccNone) + , AlexAcc 238 + , AlexAcc 237 + , AlexAcc 236 + , AlexAcc 235 + , AlexAcc 234 + , AlexAcc 233 + , AlexAcc 232 + , AlexAcc 231 + , AlexAcc 230 + , AlexAcc 229 + , AlexAcc 228 + , AlexAcc 227 + , AlexAcc 226 + , AlexAcc 225 + , AlexAcc 224 + , AlexAcc 223 + , AlexAcc 222 + , AlexAcc 221 + , AlexAcc 220 + , AlexAcc 219 + , AlexAcc 218 + , AlexAcc 217 + , AlexAcc 216 + , AlexAcc 215 + , AlexAcc 214 + , AlexAcc 213 + , AlexAcc 212 + , AlexAcc 211 + , AlexAcc 210 + , AlexAcc 209 + , AlexAcc 208 + , AlexAcc 207 + , AlexAcc 206 + , AlexAcc 205 + , AlexAcc 204 + , AlexAcc 203 + , AlexAcc 202 + , AlexAcc 201 + , AlexAcc 200 + , AlexAcc 199 + , AlexAcc 198 + , AlexAcc 197 + , AlexAcc 196 + , AlexAcc 195 + , AlexAcc 194 + , AlexAcc 193 + , AlexAcc 192 + , AlexAcc 191 + , AlexAcc 190 + , AlexAcc 189 + , AlexAcc 188 + , AlexAcc 187 + , AlexAcc 186 + , AlexAcc 185 + , AlexAcc 184 + , AlexAcc 183 + , AlexAcc 182 + , AlexAcc 181 + , AlexAcc 180 + , AlexAcc 179 + , AlexAcc 178 + , AlexAcc 177 + , AlexAcc 176 + , AlexAcc 175 + , AlexAcc 174 + , AlexAcc 173 + , AlexAcc 172 + , AlexAcc 171 + , AlexAcc 170 + , AlexAcc 169 + , AlexAcc 168 + , AlexAcc 167 + , AlexAcc 166 + , AlexAcc 165 + , AlexAcc 164 + , AlexAcc 163 + , AlexAcc 162 + , AlexAcc 161 + , AlexAcc 160 + , AlexAcc 159 + , AlexAcc 158 + , AlexAcc 157 + , AlexAcc 156 + , AlexAcc 155 + , AlexAcc 154 + , AlexAcc 153 + , AlexAcc 152 + , AlexAcc 151 + , AlexAcc 150 + , AlexAcc 149 + , AlexAcc 148 + , AlexAcc 147 + , AlexAcc 146 + , AlexAcc 145 + , AlexAcc 144 + , AlexAcc 143 + , AlexAcc 142 + , AlexAcc 141 + , AlexAcc 140 + , AlexAcc 139 + , AlexAcc 138 + , AlexAcc 137 + , AlexAcc 136 + , AlexAcc 135 + , AlexAcc 134 + , AlexAcc 133 + , AlexAcc 132 + , AlexAcc 131 + , AlexAcc 130 + , AlexAcc 129 + , AlexAcc 128 + , AlexAcc 127 + , AlexAcc 126 + , AlexAcc 125 + , AlexAcc 124 + , AlexAcc 123 + , AlexAcc 122 + , AlexAcc 121 + , AlexAcc 120 + , AlexAcc 119 + , AlexAcc 118 + , AlexAcc 117 + , AlexAcc 116 + , AlexAcc 115 + , AlexAcc 114 + , AlexAcc 113 + , AlexAcc 112 + , AlexAcc 111 + , AlexAcc 110 + , AlexAcc 109 + , AlexAcc 108 + , AlexAcc 107 + , AlexAcc 106 + , AlexAcc 105 + , AlexAcc 104 + , AlexAcc 103 + , AlexAcc 102 + , AlexAcc 101 + , AlexAcc 100 + , AlexAcc 99 + , AlexAcc 98 + , AlexAcc 97 + , AlexAcc 96 + , AlexAcc 95 + , AlexAcc 94 + , AlexAcc 93 + , AlexAcc 92 + , AlexAcc 91 + , AlexAcc 90 + , AlexAcc 89 + , AlexAcc 88 + , AlexAcc 87 + , AlexAcc 86 + , AlexAcc 85 + , AlexAcc 84 + , AlexAcc 83 + , AlexAcc 82 + , AlexAcc 81 + , AlexAcc 80 + , AlexAcc 79 + , AlexAcc 78 + , AlexAcc 77 + , AlexAcc 76 + , AlexAcc 75 + , AlexAcc 74 + , AlexAcc 73 + , AlexAcc 72 + , AlexAcc 71 + , AlexAcc 70 + , AlexAcc 69 + , AlexAcc 68 + , AlexAcc 67 + , AlexAcc 66 + , AlexAcc 65 + , AlexAcc 64 + , AlexAcc 63 + , AlexAcc 62 + , AlexAcc 61 + , AlexAcc 60 + , AlexAcc 59 + , AlexAcc 58 + , AlexAcc 57 + , AlexAcc 56 + , AlexAcc 55 + , AlexAcc 54 + , AlexAcc 53 + , AlexAcc 52 + , AlexAcc 51 + , AlexAcc 50 + , AlexAcc 49 + , AlexAcc 48 + , AlexAcc 47 + , AlexAcc 46 + , AlexAcc 45 + , AlexAcc 44 + , AlexAcc 43 + , AlexAcc 42 + , AlexAcc 41 + , AlexAcc 40 + , AlexAcc 39 + , AlexAcc 38 + , AlexAcc 37 + , AlexAcc 36 + , AlexAcc 35 + , AlexAcc 34 + , AlexAcc 33 + , AlexAcc 32 + , AlexAcc 31 + , AlexAcc 30 + , AlexAcc 29 + , 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 + , AlexAcc 14 + , AlexAcc 13 + , AlexAcc 12 + , AlexAcc 11 + , AlexAcc 10 + , AlexAcc 9 + , AlexAcc 8 + , AlexAcc 7 + , AlexAcc 6 + , AlexAcc 5 + , AlexAcc 4 + , AlexAcc 3 + , AlexAcc 2 + , AlexAcc 1 + , AlexAcc 0 + ] + +alex_actions = array (0 :: Int, 555) + [ (554,alex_action_38) + , (553,alex_action_41) + , (552,alex_action_40) + , (551,alex_action_2) + , (550,alex_action_2) + , (549,alex_action_3) + , (548,alex_action_4) + , (547,alex_action_4) + , (546,alex_action_5) + , (545,alex_action_6) + , (544,alex_action_7) + , (543,alex_action_8) + , (542,alex_action_9) + , (541,alex_action_10) + , (540,alex_action_11) + , (539,alex_action_12) + , (538,alex_action_13) + , (537,alex_action_14) + , (536,alex_action_15) + , (535,alex_action_16) + , (534,alex_action_17) + , (533,alex_action_18) + , (532,alex_action_19) + , (531,alex_action_20) + , (530,alex_action_21) + , (529,alex_action_22) + , (528,alex_action_23) + , (527,alex_action_24) + , (526,alex_action_25) + , (525,alex_action_26) + , (524,alex_action_27) + , (523,alex_action_28) + , (522,alex_action_29) + , (521,alex_action_29) + , (520,alex_action_29) + , (519,alex_action_29) + , (518,alex_action_29) + , (517,alex_action_29) + , (516,alex_action_29) + , (515,alex_action_29) + , (514,alex_action_29) + , (513,alex_action_29) + , (512,alex_action_29) + , (511,alex_action_29) + , (510,alex_action_29) + , (509,alex_action_29) + , (508,alex_action_29) + , (507,alex_action_29) + , (506,alex_action_29) + , (505,alex_action_29) + , (504,alex_action_29) + , (503,alex_action_29) + , (502,alex_action_29) + , (501,alex_action_29) + , (500,alex_action_29) + , (499,alex_action_29) + , (498,alex_action_29) + , (497,alex_action_29) + , (496,alex_action_29) + , (495,alex_action_29) + , (494,alex_action_29) + , (493,alex_action_29) + , (492,alex_action_29) + , (491,alex_action_29) + , (490,alex_action_29) + , (489,alex_action_29) + , (488,alex_action_29) + , (487,alex_action_29) + , (486,alex_action_29) + , (485,alex_action_29) + , (484,alex_action_29) + , (483,alex_action_29) + , (482,alex_action_29) + , (481,alex_action_29) + , (480,alex_action_29) + , (479,alex_action_29) + , (478,alex_action_29) + , (477,alex_action_29) + , (476,alex_action_29) + , (475,alex_action_29) + , (474,alex_action_29) + , (473,alex_action_29) + , (472,alex_action_29) + , (471,alex_action_29) + , (470,alex_action_29) + , (469,alex_action_29) + , (468,alex_action_29) + , (467,alex_action_29) + , (466,alex_action_29) + , (465,alex_action_29) + , (464,alex_action_29) + , (463,alex_action_29) + , (462,alex_action_29) + , (461,alex_action_29) + , (460,alex_action_29) + , (459,alex_action_29) + , (458,alex_action_29) + , (457,alex_action_29) + , (456,alex_action_29) + , (455,alex_action_29) + , (454,alex_action_29) + , (453,alex_action_29) + , (452,alex_action_29) + , (451,alex_action_29) + , (450,alex_action_29) + , (449,alex_action_29) + , (448,alex_action_29) + , (447,alex_action_29) + , (446,alex_action_29) + , (445,alex_action_29) + , (444,alex_action_29) + , (443,alex_action_29) + , (442,alex_action_29) + , (441,alex_action_29) + , (440,alex_action_29) + , (439,alex_action_29) + , (438,alex_action_29) + , (437,alex_action_29) + , (436,alex_action_29) + , (435,alex_action_29) + , (434,alex_action_29) + , (433,alex_action_29) + , (432,alex_action_29) + , (431,alex_action_29) + , (430,alex_action_29) + , (429,alex_action_29) + , (428,alex_action_29) + , (427,alex_action_29) + , (426,alex_action_29) + , (425,alex_action_29) + , (424,alex_action_29) + , (423,alex_action_29) + , (422,alex_action_29) + , (421,alex_action_29) + , (420,alex_action_29) + , (419,alex_action_29) + , (418,alex_action_29) + , (417,alex_action_29) + , (416,alex_action_29) + , (415,alex_action_29) + , (414,alex_action_29) + , (413,alex_action_29) + , (412,alex_action_29) + , (411,alex_action_29) + , (410,alex_action_29) + , (409,alex_action_29) + , (408,alex_action_29) + , (407,alex_action_29) + , (406,alex_action_29) + , (405,alex_action_29) + , (404,alex_action_29) + , (403,alex_action_29) + , (402,alex_action_29) + , (401,alex_action_29) + , (400,alex_action_29) + , (399,alex_action_29) + , (398,alex_action_29) + , (397,alex_action_29) + , (396,alex_action_29) + , (395,alex_action_29) + , (394,alex_action_29) + , (393,alex_action_29) + , (392,alex_action_29) + , (391,alex_action_29) + , (390,alex_action_29) + , (389,alex_action_29) + , (388,alex_action_29) + , (387,alex_action_29) + , (386,alex_action_29) + , (385,alex_action_29) + , (384,alex_action_29) + , (383,alex_action_29) + , (382,alex_action_29) + , (381,alex_action_29) + , (380,alex_action_29) + , (379,alex_action_29) + , (378,alex_action_29) + , (377,alex_action_29) + , (376,alex_action_29) + , (375,alex_action_29) + , (374,alex_action_29) + , (373,alex_action_29) + , (372,alex_action_29) + , (371,alex_action_29) + , (370,alex_action_29) + , (369,alex_action_29) + , (368,alex_action_29) + , (367,alex_action_29) + , (366,alex_action_29) + , (365,alex_action_29) + , (364,alex_action_29) + , (363,alex_action_29) + , (362,alex_action_29) + , (361,alex_action_29) + , (360,alex_action_29) + , (359,alex_action_29) + , (358,alex_action_29) + , (357,alex_action_29) + , (356,alex_action_29) + , (355,alex_action_29) + , (354,alex_action_29) + , (353,alex_action_29) + , (352,alex_action_29) + , (351,alex_action_29) + , (350,alex_action_29) + , (349,alex_action_29) + , (348,alex_action_29) + , (347,alex_action_29) + , (346,alex_action_29) + , (345,alex_action_29) + , (344,alex_action_29) + , (343,alex_action_29) + , (342,alex_action_29) + , (341,alex_action_29) + , (340,alex_action_29) + , (339,alex_action_29) + , (338,alex_action_29) + , (337,alex_action_29) + , (336,alex_action_29) + , (335,alex_action_29) + , (334,alex_action_29) + , (333,alex_action_29) + , (332,alex_action_30) + , (331,alex_action_30) + , (330,alex_action_30) + , (329,alex_action_30) + , (328,alex_action_30) + , (327,alex_action_31) + , (326,alex_action_31) + , (325,alex_action_32) + , (324,alex_action_33) + , (323,alex_action_33) + , (322,alex_action_34) + , (321,alex_action_34) + , (320,alex_action_34) + , (319,alex_action_34) + , (318,alex_action_34) + , (317,alex_action_34) + , (316,alex_action_34) + , (315,alex_action_115) + , (314,alex_action_34) + , (313,alex_action_115) + , (312,alex_action_34) + , (311,alex_action_115) + , (310,alex_action_36) + , (309,alex_action_42) + , (308,alex_action_43) + , (307,alex_action_44) + , (306,alex_action_45) + , (305,alex_action_46) + , (304,alex_action_47) + , (303,alex_action_48) + , (302,alex_action_49) + , (301,alex_action_50) + , (300,alex_action_51) + , (299,alex_action_52) + , (298,alex_action_53) + , (297,alex_action_54) + , (296,alex_action_55) + , (295,alex_action_56) + , (294,alex_action_57) + , (293,alex_action_58) + , (292,alex_action_59) + , (291,alex_action_60) + , (290,alex_action_61) + , (289,alex_action_62) + , (288,alex_action_63) + , (287,alex_action_64) + , (286,alex_action_65) + , (285,alex_action_66) + , (284,alex_action_67) + , (283,alex_action_68) + , (282,alex_action_69) + , (281,alex_action_70) + , (280,alex_action_71) + , (279,alex_action_72) + , (278,alex_action_73) + , (277,alex_action_74) + , (276,alex_action_74) + , (275,alex_action_74) + , (274,alex_action_75) + , (273,alex_action_75) + , (272,alex_action_75) + , (271,alex_action_76) + , (270,alex_action_77) + , (269,alex_action_78) + , (268,alex_action_79) + , (267,alex_action_80) + , (266,alex_action_81) + , (265,alex_action_82) + , (264,alex_action_83) + , (263,alex_action_84) + , (262,alex_action_85) + , (261,alex_action_86) + , (260,alex_action_87) + , (259,alex_action_88) + , (258,alex_action_89) + , (257,alex_action_90) + , (256,alex_action_91) + , (255,alex_action_92) + , (254,alex_action_93) + , (253,alex_action_94) + , (252,alex_action_95) + , (251,alex_action_96) + , (250,alex_action_97) + , (249,alex_action_98) + , (248,alex_action_99) + , (247,alex_action_100) + , (246,alex_action_101) + , (245,alex_action_102) + , (244,alex_action_103) + , (243,alex_action_104) + , (242,alex_action_105) + , (241,alex_action_106) + , (240,alex_action_107) + , (239,alex_action_108) + , (238,alex_action_109) + , (237,alex_action_110) + , (236,alex_action_111) + , (235,alex_action_112) + , (234,alex_action_113) + , (233,alex_action_113) + , (232,alex_action_113) + , (231,alex_action_113) + , (230,alex_action_113) + , (229,alex_action_113) + , (228,alex_action_113) + , (227,alex_action_113) + , (226,alex_action_114) + , (225,alex_action_114) + , (224,alex_action_114) + , (223,alex_action_114) + , (222,alex_action_114) + , (221,alex_action_114) + , (220,alex_action_114) + , (219,alex_action_114) + , (218,alex_action_114) + , (217,alex_action_114) + , (216,alex_action_114) + , (215,alex_action_115) + , (214,alex_action_115) + , (213,alex_action_115) + , (212,alex_action_115) + , (211,alex_action_115) + , (210,alex_action_115) + , (209,alex_action_115) + , (208,alex_action_115) + , (207,alex_action_115) + , (206,alex_action_115) + , (205,alex_action_115) + , (204,alex_action_115) + , (203,alex_action_115) + , (202,alex_action_115) + , (201,alex_action_115) + , (200,alex_action_115) + , (199,alex_action_115) + , (198,alex_action_115) + , (197,alex_action_115) + , (196,alex_action_115) + , (195,alex_action_115) + , (194,alex_action_115) + , (193,alex_action_115) + , (192,alex_action_115) + , (191,alex_action_115) + , (190,alex_action_115) + , (189,alex_action_115) + , (188,alex_action_115) + , (187,alex_action_115) + , (186,alex_action_115) + , (185,alex_action_115) + , (184,alex_action_115) + , (183,alex_action_115) + , (182,alex_action_115) + , (181,alex_action_115) + , (180,alex_action_115) + , (179,alex_action_115) + , (178,alex_action_115) + , (177,alex_action_115) + , (176,alex_action_115) + , (175,alex_action_115) + , (174,alex_action_115) + , (173,alex_action_115) + , (172,alex_action_115) + , (171,alex_action_115) + , (170,alex_action_115) + , (169,alex_action_115) + , (168,alex_action_115) + , (167,alex_action_115) + , (166,alex_action_115) + , (165,alex_action_115) + , (164,alex_action_115) + , (163,alex_action_115) + , (162,alex_action_115) + , (161,alex_action_115) + , (160,alex_action_115) + , (159,alex_action_115) + , (158,alex_action_115) + , (157,alex_action_115) + , (156,alex_action_115) + , (155,alex_action_115) + , (154,alex_action_115) + , (153,alex_action_115) + , (152,alex_action_115) + , (151,alex_action_115) + , (150,alex_action_115) + , (149,alex_action_115) + , (148,alex_action_115) + , (147,alex_action_115) + , (146,alex_action_115) + , (145,alex_action_115) + , (144,alex_action_115) + , (143,alex_action_115) + , (142,alex_action_115) + , (141,alex_action_115) + , (140,alex_action_115) + , (139,alex_action_115) + , (138,alex_action_115) + , (137,alex_action_115) + , (136,alex_action_115) + , (135,alex_action_115) + , (134,alex_action_115) + , (133,alex_action_115) + , (132,alex_action_115) + , (131,alex_action_115) + , (130,alex_action_115) + , (129,alex_action_115) + , (128,alex_action_115) + , (127,alex_action_115) + , (126,alex_action_115) + , (125,alex_action_115) + , (124,alex_action_115) + , (123,alex_action_115) + , (122,alex_action_115) + , (121,alex_action_115) + , (120,alex_action_115) + , (119,alex_action_115) + , (118,alex_action_115) + , (117,alex_action_115) + , (116,alex_action_115) + , (115,alex_action_115) + , (114,alex_action_115) + , (113,alex_action_115) + , (112,alex_action_115) + , (111,alex_action_115) + , (110,alex_action_115) + , (109,alex_action_115) + , (108,alex_action_115) + , (107,alex_action_115) + , (106,alex_action_115) + , (105,alex_action_115) + , (104,alex_action_115) + , (103,alex_action_115) + , (102,alex_action_115) + , (101,alex_action_115) + , (100,alex_action_115) + , (99,alex_action_115) + , (98,alex_action_115) + , (97,alex_action_115) + , (96,alex_action_115) + , (95,alex_action_115) + , (94,alex_action_115) + , (93,alex_action_115) + , (92,alex_action_115) + , (91,alex_action_115) + , (90,alex_action_115) + , (89,alex_action_115) + , (88,alex_action_115) + , (87,alex_action_115) + , (86,alex_action_115) + , (85,alex_action_115) + , (84,alex_action_115) + , (83,alex_action_115) + , (82,alex_action_115) + , (81,alex_action_115) + , (80,alex_action_115) + , (79,alex_action_115) + , (78,alex_action_115) + , (77,alex_action_115) + , (76,alex_action_115) + , (75,alex_action_115) + , (74,alex_action_115) + , (73,alex_action_115) + , (72,alex_action_115) + , (71,alex_action_115) + , (70,alex_action_115) + , (69,alex_action_115) + , (68,alex_action_115) + , (67,alex_action_115) + , (66,alex_action_115) + , (65,alex_action_115) + , (64,alex_action_115) + , (63,alex_action_115) + , (62,alex_action_115) + , (61,alex_action_115) + , (60,alex_action_115) + , (59,alex_action_115) + , (58,alex_action_115) + , (57,alex_action_115) + , (56,alex_action_115) + , (55,alex_action_115) + , (54,alex_action_115) + , (53,alex_action_115) + , (52,alex_action_115) + , (51,alex_action_115) + , (50,alex_action_115) + , (49,alex_action_115) + , (48,alex_action_115) + , (47,alex_action_115) + , (46,alex_action_115) + , (45,alex_action_115) + , (44,alex_action_115) + , (43,alex_action_115) + , (42,alex_action_115) + , (41,alex_action_115) + , (40,alex_action_115) + , (39,alex_action_115) + , (38,alex_action_115) + , (37,alex_action_115) + , (36,alex_action_115) + , (35,alex_action_115) + , (34,alex_action_115) + , (33,alex_action_115) + , (32,alex_action_115) + , (31,alex_action_115) + , (30,alex_action_115) + , (29,alex_action_115) + , (28,alex_action_115) + , (27,alex_action_115) + , (26,alex_action_115) + , (25,alex_action_115) + , (24,alex_action_115) + , (23,alex_action_115) + , (22,alex_action_115) + , (21,alex_action_115) + , (20,alex_action_115) + , (19,alex_action_115) + , (18,alex_action_115) + , (17,alex_action_115) + , (16,alex_action_115) + , (15,alex_action_115) + , (14,alex_action_115) + , (13,alex_action_115) + , (12,alex_action_115) + , (11,alex_action_115) + , (10,alex_action_115) + , (9,alex_action_115) + , (8,alex_action_115) + , (7,alex_action_115) + , (6,alex_action_115) + , (5,alex_action_115) + , (4,alex_action_115) + , (3,alex_action_115) + , (2,alex_action_115) + , (1,alex_action_115) + , (0,alex_action_115) + ] + +{-# LINE 245 "src/full/Agda/Syntax/Parser/Lexer.x" #-} + + +-- | This is the initial state for parsing a regular, non-literate file. +normal :: LexState +normal = 0 + + +{-| The layout state. Entered when we see a layout keyword ('withLayout') and + exited either when seeing an open brace ('openBrace') or at the next token + ('newLayoutContext'). + + Update: we don't use braces for layout anymore. +-} +layout :: LexState +layout = layout_ + + +{-| The state inside a pragma. +-} +pragma :: LexState +pragma = pragma_ + +-- | The state inside a FOREIGN pragma. This needs to be different so that we don't +-- lex further strings as pragma keywords. +fpragma :: LexState +fpragma = fpragma_ + +{-| We enter this state from 'newLayoutContext' when the token following a + layout keyword is to the left of (or at the same column as) the current + layout context. Example: + + > data Empty : Set where + > foo : Empty -> Nat + + Here the second line is not part of the @where@ clause since it is has the + same indentation as the @data@ definition. What we have to do is insert an + empty layout block @{}@ after the @where@. The only thing that can happen + in this state is that 'emptyLayout' is executed, generating the closing + brace. The open brace is generated when entering by 'newLayoutContext'. +-} +empty_layout :: LexState +empty_layout = empty_layout_ + + +-- | This state is entered at the beginning of each line. You can't lex +-- anything in this state, and to exit you have to check the layout rule. +-- Done with 'offsideRule'. +bol :: LexState +bol = bol_ + + +-- | This state can only be entered by the parser. In this state you can only +-- lex the keywords @using@, @hiding@, @renaming@ and @to@. Moreover they are +-- only keywords in this particular state. The lexer will never enter this +-- state by itself, that has to be done in the parser. +imp_dir :: LexState +imp_dir = imp_dir_ + + +-- | Return the next token. This is the function used by Happy in the parser. +-- +-- @lexer k = 'lexToken' >>= k@ +lexer :: (Token -> Parser a) -> Parser a +lexer k = lexToken >>= k + +-- | Do not use this function; it sets the 'ParseFlags' to +-- 'undefined'. +alexScan :: AlexInput -> Int -> AlexReturn (LexAction Token) + +-- | This is the main lexing function generated by Alex. +alexScanUser :: ([LexState], ParseFlags) -> AlexInput -> Int -> AlexReturn (LexAction Token) + + + +bol_,code,empty_layout_,fpragma_,imp_dir_,layout_,pragma_ :: Int +bol_ = 1 +code = 2 +empty_layout_ = 3 +fpragma_ = 4 +imp_dir_ = 5 +layout_ = 6 +pragma_ = 7 +alex_action_2 = beginWith pragma $ symbol SymOpenPragma +alex_action_3 = beginWith fpragma $ symbol SymOpenPragma +alex_action_4 = endWith $ symbol SymClosePragma +alex_action_5 = keyword KwBUILTIN +alex_action_6 = keyword KwCATCHALL +alex_action_7 = endWith $ beginWith fpragma $ keyword KwCOMPILE +alex_action_8 = endWith $ beginWith fpragma $ keyword KwFOREIGN +alex_action_9 = keyword KwDISPLAY +alex_action_10 = keyword KwETA +alex_action_11 = keyword KwIMPOSSIBLE +alex_action_12 = keyword KwINJECTIVE +alex_action_13 = keyword KwINLINE +alex_action_14 = keyword KwNOINLINE +alex_action_15 = keyword KwLINE +alex_action_16 = keyword KwMEASURE +alex_action_17 = keyword KwNO_POSITIVITY_CHECK +alex_action_18 = keyword KwNO_TERMINATION_CHECK +alex_action_19 = keyword KwNO_UNIVERSE_CHECK +alex_action_20 = keyword KwNON_COVERING +alex_action_21 = keyword KwNON_TERMINATING +alex_action_22 = keyword KwOPTIONS +alex_action_23 = keyword KwPOLARITY +alex_action_24 = keyword KwREWRITE +alex_action_25 = keyword KwSTATIC +alex_action_26 = keyword KwTERMINATING +alex_action_27 = keyword KwWARNING_ON_USAGE +alex_action_28 = keyword KwWARNING_ON_IMPORT +alex_action_29 = withInterval $ TokString +alex_action_30 = withInterval $ TokString +alex_action_31 = nestedComment +alex_action_32 = symbol SymEndComment +alex_action_33 = symbol SymEndComment +alex_action_34 = withInterval TokComment +alex_action_36 = begin bol_ +alex_action_38 = offsideRule +alex_action_40 = endWith newLayoutContext +alex_action_41 = emptyLayout +alex_action_42 = keyword KwLet +alex_action_43 = keyword KwIn +alex_action_44 = keyword KwWhere +alex_action_45 = keyword KwDo +alex_action_46 = keyword KwField +alex_action_47 = keyword KwWith +alex_action_48 = keyword KwRewrite +alex_action_49 = keyword KwPostulate +alex_action_50 = keyword KwPrimitive +alex_action_51 = keyword KwOpen +alex_action_52 = keyword KwImport +alex_action_53 = keyword KwModule +alex_action_54 = keyword KwData +alex_action_55 = keyword KwCoData +alex_action_56 = keyword KwRecord +alex_action_57 = keyword KwConstructor +alex_action_58 = keyword KwInductive +alex_action_59 = keyword KwCoInductive +alex_action_60 = keyword KwEta +alex_action_61 = keyword KwNoEta +alex_action_62 = keyword KwInfix +alex_action_63 = keyword KwInfixL +alex_action_64 = keyword KwInfixR +alex_action_65 = keyword KwMutual +alex_action_66 = keyword KwAbstract +alex_action_67 = keyword KwPrivate +alex_action_68 = keyword KwInstance +alex_action_69 = keyword KwOverlap +alex_action_70 = keyword KwMacro +alex_action_71 = keyword KwSet +alex_action_72 = keyword KwProp +alex_action_73 = keyword KwForall +alex_action_74 = withInterval' (read . drop 3) TokSetN +alex_action_75 = withInterval' (read . drop 4) TokPropN +alex_action_76 = keyword KwQuote +alex_action_77 = keyword KwQuoteTerm +alex_action_78 = keyword KwUnquote +alex_action_79 = keyword KwUnquoteDecl +alex_action_80 = keyword KwUnquoteDef +alex_action_81 = keyword KwTactic +alex_action_82 = keyword KwSyntax +alex_action_83 = keyword KwPatternSyn +alex_action_84 = keyword KwVariable +alex_action_85 = keyword KwUsing +alex_action_86 = keyword KwHiding +alex_action_87 = keyword KwRenaming +alex_action_88 = endWith $ keyword KwTo +alex_action_89 = keyword KwPublic +alex_action_90 = hole +alex_action_91 = symbol SymEllipsis +alex_action_92 = symbol SymDotDot +alex_action_93 = symbol SymDot +alex_action_94 = symbol SymSemi +alex_action_95 = symbol SymColon +alex_action_96 = symbol SymEqual +alex_action_97 = symbol SymUnderscore +alex_action_98 = symbol SymQuestionMark +alex_action_99 = symbol SymBar +alex_action_100 = symbol SymOpenIdiomBracket +alex_action_101 = symbol SymCloseIdiomBracket +alex_action_102 = symbol SymEmptyIdiomBracket +alex_action_103 = symbol SymOpenParen +alex_action_104 = symbol SymCloseParen +alex_action_105 = symbol SymArrow +alex_action_106 = symbol SymLambda +alex_action_107 = symbol SymAs +alex_action_108 = symbol SymDoubleOpenBrace +alex_action_109 = symbol SymOpenBrace +alex_action_110 = symbol SymCloseBrace +alex_action_111 = litChar +alex_action_112 = litString +alex_action_113 = literal' integer LitNat +alex_action_114 = literal LitFloat +alex_action_115 = identifier {-# LINE 1 "templates/GenericTemplate.hs" #-} -- ----------------------------------------------------------------------------- -- ALEX TEMPLATE diff --git a/dist/build/Agda/Syntax/Parser/Parser.hs b/dist/build/Agda/Syntax/Parser/Parser.hs --- a/dist/build/Agda/Syntax/Parser/Parser.hs +++ b/dist/build/Agda/Syntax/Parser/Parser.hs @@ -3,8222 +3,8221 @@ #if __GLASGOW_HASKELL__ >= 710 {-# OPTIONS_GHC -XPartialTypeSignatures #-} #endif -{-# LANGUAGE CPP #-} -{-# LANGUAGE PatternGuards #-} - -{-| The parser is generated by Happy (). - - - - Ideally, ranges should be as precise as possible, to get messages that - - emphasize precisely the faulting term(s) upon error. - - - - However, interactive highlighting is only applied at the end of each - - mutual block, keywords are only highlighted once (see - - `TypeChecking.Rules.Decl'). So if the ranges of two declarations - - interleave, one must ensure that keyword ranges are not included in - - the intersection. (Otherwise they are uncolored by the interactive - - highlighting.) - - - -} -module Agda.Syntax.Parser.Parser ( - moduleParser - , moduleNameParser - , exprParser - , exprWhereParser - , tokensParser - , holeContentParser - , splitOnDots -- only used by the internal test-suite - ) where - -import Control.Monad - -import Data.Char -import Data.Functor -import Data.List -import Data.Maybe -import Data.Monoid -import qualified Data.Traversable as T - -import Debug.Trace - -import Agda.Syntax.Position hiding (tests) -import Agda.Syntax.Parser.Monad -import Agda.Syntax.Parser.Lexer -import Agda.Syntax.Parser.Tokens -import Agda.Syntax.Concrete as C -import Agda.Syntax.Concrete.Attribute -import Agda.Syntax.Concrete.Pattern -import Agda.Syntax.Concrete.Pretty () -import Agda.Syntax.Common -import Agda.Syntax.Fixity -import Agda.Syntax.Notation -import Agda.Syntax.Literal - -import Agda.TypeChecking.Positivity.Occurrence hiding (tests) - -import Agda.Utils.Either hiding (tests) -import Agda.Utils.Functor -import Agda.Utils.Hash -import Agda.Utils.List ( spanJust, chopWhen ) -import Agda.Utils.Monad -import Agda.Utils.Pretty -import Agda.Utils.Singleton -import Agda.Utils.Tuple -import qualified Agda.Utils.Maybe.Strict as Strict - -import Agda.Utils.Impossible -#include "undefined.h" -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.19.9 - -newtype HappyAbsSyn = HappyAbsSyn HappyAny -#if __GLASGOW_HASKELL__ >= 607 -type HappyAny = Happy_GHC_Exts.Any -#else -type HappyAny = forall a . a -#endif -happyIn10 :: ([Token]) -> (HappyAbsSyn ) -happyIn10 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn10 #-} -happyOut10 :: (HappyAbsSyn ) -> ([Token]) -happyOut10 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut10 #-} -happyIn11 :: ([Token]) -> (HappyAbsSyn ) -happyIn11 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn11 #-} -happyOut11 :: (HappyAbsSyn ) -> ([Token]) -happyOut11 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut11 #-} -happyIn12 :: (Token) -> (HappyAbsSyn ) -happyIn12 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn12 #-} -happyOut12 :: (HappyAbsSyn ) -> (Token) -happyOut12 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut12 #-} -happyIn13 :: (([Pragma], [Declaration])) -> (HappyAbsSyn ) -happyIn13 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn13 #-} -happyOut13 :: (HappyAbsSyn ) -> (([Pragma], [Declaration])) -happyOut13 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut13 #-} -happyIn14 :: (()) -> (HappyAbsSyn ) -happyIn14 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn14 #-} -happyOut14 :: (HappyAbsSyn ) -> (()) -happyOut14 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut14 #-} -happyIn15 :: (()) -> (HappyAbsSyn ) -happyIn15 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn15 #-} -happyOut15 :: (HappyAbsSyn ) -> (()) -happyOut15 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut15 #-} -happyIn16 :: (Interval) -> (HappyAbsSyn ) -happyIn16 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn16 #-} -happyOut16 :: (HappyAbsSyn ) -> (Interval) -happyOut16 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut16 #-} -happyIn17 :: (()) -> (HappyAbsSyn ) -happyIn17 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn17 #-} -happyOut17 :: (HappyAbsSyn ) -> (()) -happyOut17 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut17 #-} -happyIn18 :: (Integer) -> (HappyAbsSyn ) -happyIn18 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn18 #-} -happyOut18 :: (HappyAbsSyn ) -> (Integer) -happyOut18 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut18 #-} -happyIn19 :: (Name) -> (HappyAbsSyn ) -happyIn19 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn19 #-} -happyOut19 :: (HappyAbsSyn ) -> (Name) -happyOut19 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut19 #-} -happyIn20 :: ([Name]) -> (HappyAbsSyn ) -happyIn20 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn20 #-} -happyOut20 :: (HappyAbsSyn ) -> ([Name]) -happyOut20 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut20 #-} -happyIn21 :: (Range) -> (HappyAbsSyn ) -happyIn21 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn21 #-} -happyOut21 :: (HappyAbsSyn ) -> (Range) -happyOut21 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut21 #-} -happyIn22 :: (Arg Name) -> (HappyAbsSyn ) -happyIn22 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn22 #-} -happyOut22 :: (HappyAbsSyn ) -> (Arg Name) -happyOut22 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut22 #-} -happyIn23 :: ([Arg Name]) -> (HappyAbsSyn ) -happyIn23 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn23 #-} -happyOut23 :: (HappyAbsSyn ) -> ([Arg Name]) -happyOut23 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut23 #-} -happyIn24 :: ([Arg Name]) -> (HappyAbsSyn ) -happyIn24 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn24 #-} -happyOut24 :: (HappyAbsSyn ) -> ([Arg Name]) -happyOut24 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut24 #-} -happyIn25 :: ([Arg Name]) -> (HappyAbsSyn ) -happyIn25 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn25 #-} -happyOut25 :: (HappyAbsSyn ) -> ([Arg Name]) -happyOut25 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut25 #-} -happyIn26 :: (Attr) -> (HappyAbsSyn ) -happyIn26 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn26 #-} -happyOut26 :: (HappyAbsSyn ) -> (Attr) -happyOut26 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut26 #-} -happyIn27 :: ([Attr]) -> (HappyAbsSyn ) -happyIn27 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn27 #-} -happyOut27 :: (HappyAbsSyn ) -> ([Attr]) -happyOut27 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut27 #-} -happyIn28 :: ([Attr]) -> (HappyAbsSyn ) -happyIn28 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn28 #-} -happyOut28 :: (HappyAbsSyn ) -> ([Attr]) -happyOut28 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut28 #-} -happyIn29 :: (QName) -> (HappyAbsSyn ) -happyIn29 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn29 #-} -happyOut29 :: (HappyAbsSyn ) -> (QName) -happyOut29 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut29 #-} -happyIn30 :: (QName) -> (HappyAbsSyn ) -happyIn30 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn30 #-} -happyOut30 :: (HappyAbsSyn ) -> (QName) -happyOut30 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut30 #-} -happyIn31 :: (Name) -> (HappyAbsSyn ) -happyIn31 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn31 #-} -happyOut31 :: (HappyAbsSyn ) -> (Name) -happyOut31 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut31 #-} -happyIn32 :: ([Name]) -> (HappyAbsSyn ) -happyIn32 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn32 #-} -happyOut32 :: (HappyAbsSyn ) -> ([Name]) -happyOut32 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut32 #-} -happyIn33 :: ([NamedArg BoundName]) -> (HappyAbsSyn ) -happyIn33 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn33 #-} -happyOut33 :: (HappyAbsSyn ) -> ([NamedArg BoundName]) -happyOut33 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut33 #-} -happyIn34 :: (Either [NamedArg BoundName] [Expr]) -> (HappyAbsSyn ) -happyIn34 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn34 #-} -happyOut34 :: (HappyAbsSyn ) -> (Either [NamedArg BoundName] [Expr]) -happyOut34 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut34 #-} -happyIn35 :: ([NamedArg BoundName]) -> (HappyAbsSyn ) -happyIn35 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn35 #-} -happyOut35 :: (HappyAbsSyn ) -> ([NamedArg BoundName]) -happyOut35 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut35 #-} -happyIn36 :: ([String]) -> (HappyAbsSyn ) -happyIn36 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn36 #-} -happyOut36 :: (HappyAbsSyn ) -> ([String]) -happyOut36 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut36 #-} -happyIn37 :: (String) -> (HappyAbsSyn ) -happyIn37 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn37 #-} -happyOut37 :: (HappyAbsSyn ) -> (String) -happyOut37 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut37 #-} -happyIn38 :: ([(Interval, String)]) -> (HappyAbsSyn ) -happyIn38 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn38 #-} -happyOut38 :: (HappyAbsSyn ) -> ([(Interval, String)]) -happyOut38 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut38 #-} -happyIn39 :: ([(Interval, String)]) -> (HappyAbsSyn ) -happyIn39 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn39 #-} -happyOut39 :: (HappyAbsSyn ) -> ([(Interval, String)]) -happyOut39 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut39 #-} -happyIn40 :: (Name) -> (HappyAbsSyn ) -happyIn40 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn40 #-} -happyOut40 :: (HappyAbsSyn ) -> (Name) -happyOut40 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut40 #-} -happyIn41 :: (QName) -> (HappyAbsSyn ) -happyIn41 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn41 #-} -happyOut41 :: (HappyAbsSyn ) -> (QName) -happyOut41 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut41 #-} -happyIn42 :: ([QName]) -> (HappyAbsSyn ) -happyIn42 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn42 #-} -happyOut42 :: (HappyAbsSyn ) -> ([QName]) -happyOut42 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut42 #-} -happyIn43 :: (Expr) -> (HappyAbsSyn ) -happyIn43 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn43 #-} -happyOut43 :: (HappyAbsSyn ) -> (Expr) -happyOut43 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut43 #-} -happyIn44 :: (Expr) -> (HappyAbsSyn ) -happyIn44 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn44 #-} -happyOut44 :: (HappyAbsSyn ) -> (Expr) -happyOut44 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut44 #-} -happyIn45 :: ([Expr]) -> (HappyAbsSyn ) -happyIn45 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn45 #-} -happyOut45 :: (HappyAbsSyn ) -> ([Expr]) -happyOut45 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut45 #-} -happyIn46 :: ([Expr]) -> (HappyAbsSyn ) -happyIn46 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn46 #-} -happyOut46 :: (HappyAbsSyn ) -> ([Expr]) -happyOut46 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut46 #-} -happyIn47 :: (Expr) -> (HappyAbsSyn ) -happyIn47 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn47 #-} -happyOut47 :: (HappyAbsSyn ) -> (Expr) -happyOut47 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut47 #-} -happyIn48 :: (Maybe Expr) -> (HappyAbsSyn ) -happyIn48 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn48 #-} -happyOut48 :: (HappyAbsSyn ) -> (Maybe Expr) -happyOut48 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut48 #-} -happyIn49 :: (Expr) -> (HappyAbsSyn ) -happyIn49 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn49 #-} -happyOut49 :: (HappyAbsSyn ) -> (Expr) -happyOut49 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut49 #-} -happyIn50 :: ([Expr]) -> (HappyAbsSyn ) -happyIn50 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn50 #-} -happyOut50 :: (HappyAbsSyn ) -> ([Expr]) -happyOut50 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut50 #-} -happyIn51 :: ([Expr]) -> (HappyAbsSyn ) -happyIn51 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn51 #-} -happyOut51 :: (HappyAbsSyn ) -> ([Expr]) -happyOut51 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut51 #-} -happyIn52 :: (Expr) -> (HappyAbsSyn ) -happyIn52 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn52 #-} -happyOut52 :: (HappyAbsSyn ) -> (Expr) -happyOut52 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut52 #-} -happyIn53 :: (Expr) -> (HappyAbsSyn ) -happyIn53 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn53 #-} -happyOut53 :: (HappyAbsSyn ) -> (Expr) -happyOut53 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut53 #-} -happyIn54 :: (Expr) -> (HappyAbsSyn ) -happyIn54 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn54 #-} -happyOut54 :: (HappyAbsSyn ) -> (Expr) -happyOut54 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut54 #-} -happyIn55 :: (Expr) -> (HappyAbsSyn ) -happyIn55 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn55 #-} -happyOut55 :: (HappyAbsSyn ) -> (Expr) -happyOut55 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut55 #-} -happyIn56 :: (RecordAssignments) -> (HappyAbsSyn ) -happyIn56 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn56 #-} -happyOut56 :: (HappyAbsSyn ) -> (RecordAssignments) -happyOut56 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut56 #-} -happyIn57 :: (RecordAssignments) -> (HappyAbsSyn ) -happyIn57 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn57 #-} -happyOut57 :: (HappyAbsSyn ) -> (RecordAssignments) -happyOut57 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut57 #-} -happyIn58 :: (RecordAssignment) -> (HappyAbsSyn ) -happyIn58 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn58 #-} -happyOut58 :: (HappyAbsSyn ) -> (RecordAssignment) -happyOut58 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut58 #-} -happyIn59 :: (ModuleAssignment) -> (HappyAbsSyn ) -happyIn59 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn59 #-} -happyOut59 :: (HappyAbsSyn ) -> (ModuleAssignment) -happyOut59 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut59 #-} -happyIn60 :: ([FieldAssignment]) -> (HappyAbsSyn ) -happyIn60 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn60 #-} -happyOut60 :: (HappyAbsSyn ) -> ([FieldAssignment]) -happyOut60 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut60 #-} -happyIn61 :: ([FieldAssignment]) -> (HappyAbsSyn ) -happyIn61 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn61 #-} -happyOut61 :: (HappyAbsSyn ) -> ([FieldAssignment]) -happyOut61 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut61 #-} -happyIn62 :: (FieldAssignment) -> (HappyAbsSyn ) -happyIn62 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn62 #-} -happyOut62 :: (HappyAbsSyn ) -> (FieldAssignment) -happyOut62 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut62 #-} -happyIn63 :: (Telescope) -> (HappyAbsSyn ) -happyIn63 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn63 #-} -happyOut63 :: (HappyAbsSyn ) -> (Telescope) -happyOut63 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut63 #-} -happyIn64 :: (Telescope) -> (HappyAbsSyn ) -happyIn64 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn64 #-} -happyOut64 :: (HappyAbsSyn ) -> (Telescope) -happyOut64 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut64 #-} -happyIn65 :: ([TypedBinding]) -> (HappyAbsSyn ) -happyIn65 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn65 #-} -happyOut65 :: (HappyAbsSyn ) -> ([TypedBinding]) -happyOut65 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut65 #-} -happyIn66 :: (TypedBinding) -> (HappyAbsSyn ) -happyIn66 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn66 #-} -happyOut66 :: (HappyAbsSyn ) -> (TypedBinding) -happyOut66 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut66 #-} -happyIn67 :: (TypedBinding) -> (HappyAbsSyn ) -happyIn67 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn67 #-} -happyOut67 :: (HappyAbsSyn ) -> (TypedBinding) -happyOut67 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut67 #-} -happyIn68 :: (TypedBinding) -> (HappyAbsSyn ) -happyIn68 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn68 #-} -happyOut68 :: (HappyAbsSyn ) -> (TypedBinding) -happyOut68 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut68 #-} -happyIn69 :: (TypedBinding) -> (HappyAbsSyn ) -happyIn69 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn69 #-} -happyOut69 :: (HappyAbsSyn ) -> (TypedBinding) -happyOut69 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut69 #-} -happyIn70 :: (TypedBinding) -> (HappyAbsSyn ) -happyIn70 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn70 #-} -happyOut70 :: (HappyAbsSyn ) -> (TypedBinding) -happyOut70 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut70 #-} -happyIn71 :: ([LamBinding]) -> (HappyAbsSyn ) -happyIn71 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn71 #-} -happyOut71 :: (HappyAbsSyn ) -> ([LamBinding]) -happyOut71 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut71 #-} -happyIn72 :: (Either ([LamBinding], Hiding) [Expr]) -> (HappyAbsSyn ) -happyIn72 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn72 #-} -happyOut72 :: (HappyAbsSyn ) -> (Either ([LamBinding], Hiding) [Expr]) -happyOut72 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut72 #-} -happyIn73 :: ([Either Hiding LamBinding]) -> (HappyAbsSyn ) -happyIn73 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn73 #-} -happyOut73 :: (HappyAbsSyn ) -> ([Either Hiding LamBinding]) -happyOut73 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut73 #-} -happyIn74 :: (Either [Either Hiding LamBinding] [Expr]) -> (HappyAbsSyn ) -happyIn74 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn74 #-} -happyOut74 :: (HappyAbsSyn ) -> (Either [Either Hiding LamBinding] [Expr]) -happyOut74 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut74 #-} -happyIn75 :: (LamClause) -> (HappyAbsSyn ) -happyIn75 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn75 #-} -happyOut75 :: (HappyAbsSyn ) -> (LamClause) -happyOut75 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut75 #-} -happyIn76 :: (LamClause) -> (HappyAbsSyn ) -happyIn76 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn76 #-} -happyOut76 :: (HappyAbsSyn ) -> (LamClause) -happyOut76 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut76 #-} -happyIn77 :: (LamClause) -> (HappyAbsSyn ) -happyIn77 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn77 #-} -happyOut77 :: (HappyAbsSyn ) -> (LamClause) -happyOut77 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut77 #-} -happyIn78 :: ([LamClause]) -> (HappyAbsSyn ) -happyIn78 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn78 #-} -happyOut78 :: (HappyAbsSyn ) -> ([LamClause]) -happyOut78 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut78 #-} -happyIn79 :: ([LamClause]) -> (HappyAbsSyn ) -happyIn79 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn79 #-} -happyOut79 :: (HappyAbsSyn ) -> ([LamClause]) -happyOut79 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut79 #-} -happyIn80 :: ([LamBinding]) -> (HappyAbsSyn ) -happyIn80 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn80 #-} -happyOut80 :: (HappyAbsSyn ) -> ([LamBinding]) -happyOut80 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut80 #-} -happyIn81 :: ([LamBinding]) -> (HappyAbsSyn ) -happyIn81 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn81 #-} -happyOut81 :: (HappyAbsSyn ) -> ([LamBinding]) -happyOut81 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut81 #-} -happyIn82 :: ([LamBinding]) -> (HappyAbsSyn ) -happyIn82 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn82 #-} -happyOut82 :: (HappyAbsSyn ) -> ([LamBinding]) -happyOut82 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut82 #-} -happyIn83 :: ([LamBinding]) -> (HappyAbsSyn ) -happyIn83 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn83 #-} -happyOut83 :: (HappyAbsSyn ) -> ([LamBinding]) -happyOut83 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut83 #-} -happyIn84 :: (Either [LamBinding] [Expr]) -> (HappyAbsSyn ) -happyIn84 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn84 #-} -happyOut84 :: (HappyAbsSyn ) -> (Either [LamBinding] [Expr]) -happyOut84 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut84 #-} -happyIn85 :: ([DoStmt]) -> (HappyAbsSyn ) -happyIn85 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn85 #-} -happyOut85 :: (HappyAbsSyn ) -> ([DoStmt]) -happyOut85 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut85 #-} -happyIn86 :: (DoStmt) -> (HappyAbsSyn ) -happyIn86 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn86 #-} -happyOut86 :: (HappyAbsSyn ) -> (DoStmt) -happyOut86 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut86 #-} -happyIn87 :: ([LamClause]) -> (HappyAbsSyn ) -happyIn87 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn87 #-} -happyOut87 :: (HappyAbsSyn ) -> ([LamClause]) -happyOut87 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut87 #-} -happyIn88 :: (ImportDirective) -> (HappyAbsSyn ) -happyIn88 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn88 #-} -happyOut88 :: (HappyAbsSyn ) -> (ImportDirective) -happyOut88 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut88 #-} -happyIn89 :: ([ImportDirective]) -> (HappyAbsSyn ) -happyIn89 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn89 #-} -happyOut89 :: (HappyAbsSyn ) -> ([ImportDirective]) -happyOut89 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut89 #-} -happyIn90 :: (ImportDirective) -> (HappyAbsSyn ) -happyIn90 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn90 #-} -happyOut90 :: (HappyAbsSyn ) -> (ImportDirective) -happyOut90 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut90 #-} -happyIn91 :: ((Using, Range)) -> (HappyAbsSyn ) -happyIn91 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn91 #-} -happyOut91 :: (HappyAbsSyn ) -> ((Using, Range)) -happyOut91 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut91 #-} -happyIn92 :: (([ImportedName], Range)) -> (HappyAbsSyn ) -happyIn92 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn92 #-} -happyOut92 :: (HappyAbsSyn ) -> (([ImportedName], Range)) -happyOut92 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut92 #-} -happyIn93 :: (([Renaming] , Range)) -> (HappyAbsSyn ) -happyIn93 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn93 #-} -happyOut93 :: (HappyAbsSyn ) -> (([Renaming] , Range)) -happyOut93 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut93 #-} -happyIn94 :: ([Renaming]) -> (HappyAbsSyn ) -happyIn94 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn94 #-} -happyOut94 :: (HappyAbsSyn ) -> ([Renaming]) -happyOut94 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut94 #-} -happyIn95 :: (Renaming) -> (HappyAbsSyn ) -happyIn95 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn95 #-} -happyOut95 :: (HappyAbsSyn ) -> (Renaming) -happyOut95 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut95 #-} -happyIn96 :: (ImportedName) -> (HappyAbsSyn ) -happyIn96 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn96 #-} -happyOut96 :: (HappyAbsSyn ) -> (ImportedName) -happyOut96 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut96 #-} -happyIn97 :: (ImportedName) -> (HappyAbsSyn ) -happyIn97 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn97 #-} -happyOut97 :: (HappyAbsSyn ) -> (ImportedName) -happyOut97 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut97 #-} -happyIn98 :: ([ImportedName]) -> (HappyAbsSyn ) -happyIn98 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn98 #-} -happyOut98 :: (HappyAbsSyn ) -> ([ImportedName]) -happyOut98 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut98 #-} -happyIn99 :: ([ImportedName]) -> (HappyAbsSyn ) -happyIn99 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn99 #-} -happyOut99 :: (HappyAbsSyn ) -> ([ImportedName]) -happyOut99 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut99 #-} -happyIn100 :: (LHS) -> (HappyAbsSyn ) -happyIn100 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn100 #-} -happyOut100 :: (HappyAbsSyn ) -> (LHS) -happyOut100 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut100 #-} -happyIn101 :: ([Expr]) -> (HappyAbsSyn ) -happyIn101 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn101 #-} -happyOut101 :: (HappyAbsSyn ) -> ([Expr]) -happyOut101 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut101 #-} -happyIn102 :: ([Expr]) -> (HappyAbsSyn ) -happyIn102 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn102 #-} -happyOut102 :: (HappyAbsSyn ) -> ([Expr]) -happyOut102 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut102 #-} -happyIn103 :: (HoleContent) -> (HappyAbsSyn ) -happyIn103 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn103 #-} -happyOut103 :: (HappyAbsSyn ) -> (HoleContent) -happyOut103 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut103 #-} -happyIn104 :: (WhereClause) -> (HappyAbsSyn ) -happyIn104 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn104 #-} -happyOut104 :: (HappyAbsSyn ) -> (WhereClause) -happyOut104 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut104 #-} -happyIn105 :: (ExprWhere) -> (HappyAbsSyn ) -happyIn105 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn105 #-} -happyOut105 :: (HappyAbsSyn ) -> (ExprWhere) -happyOut105 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut105 #-} -happyIn106 :: ([Declaration]) -> (HappyAbsSyn ) -happyIn106 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn106 #-} -happyOut106 :: (HappyAbsSyn ) -> ([Declaration]) -happyOut106 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut106 #-} -happyIn107 :: ([Declaration]) -> (HappyAbsSyn ) -happyIn107 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn107 #-} -happyOut107 :: (HappyAbsSyn ) -> ([Declaration]) -happyOut107 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut107 #-} -happyIn108 :: ([Arg Declaration]) -> (HappyAbsSyn ) -happyIn108 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn108 #-} -happyOut108 :: (HappyAbsSyn ) -> ([Arg Declaration]) -happyOut108 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut108 #-} -happyIn109 :: ([Declaration]) -> (HappyAbsSyn ) -happyIn109 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn109 #-} -happyOut109 :: (HappyAbsSyn ) -> ([Declaration]) -happyOut109 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut109 #-} -happyIn110 :: (RHSOrTypeSigs) -> (HappyAbsSyn ) -happyIn110 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn110 #-} -happyOut110 :: (HappyAbsSyn ) -> (RHSOrTypeSigs) -happyOut110 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut110 #-} -happyIn111 :: (Declaration) -> (HappyAbsSyn ) -happyIn111 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn111 #-} -happyOut111 :: (HappyAbsSyn ) -> (Declaration) -happyOut111 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut111 #-} -happyIn112 :: (Declaration) -> (HappyAbsSyn ) -happyIn112 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn112 #-} -happyOut112 :: (HappyAbsSyn ) -> (Declaration) -happyOut112 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut112 #-} -happyIn113 :: (Declaration) -> (HappyAbsSyn ) -happyIn113 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn113 #-} -happyOut113 :: (HappyAbsSyn ) -> (Declaration) -happyOut113 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut113 #-} -happyIn114 :: (Declaration) -> (HappyAbsSyn ) -happyIn114 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn114 #-} -happyOut114 :: (HappyAbsSyn ) -> (Declaration) -happyOut114 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut114 #-} -happyIn115 :: ((Name, IsInstance)) -> (HappyAbsSyn ) -happyIn115 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn115 #-} -happyOut115 :: (HappyAbsSyn ) -> ((Name, IsInstance)) -happyOut115 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut115 #-} -happyIn116 :: (Declaration) -> (HappyAbsSyn ) -happyIn116 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn116 #-} -happyOut116 :: (HappyAbsSyn ) -> (Declaration) -happyOut116 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut116 #-} -happyIn117 :: ([Declaration]) -> (HappyAbsSyn ) -happyIn117 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn117 #-} -happyOut117 :: (HappyAbsSyn ) -> ([Declaration]) -happyOut117 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut117 #-} -happyIn118 :: ([Declaration]) -> (HappyAbsSyn ) -happyIn118 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn118 #-} -happyOut118 :: (HappyAbsSyn ) -> ([Declaration]) -happyOut118 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut118 #-} -happyIn119 :: (Declaration) -> (HappyAbsSyn ) -happyIn119 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn119 #-} -happyOut119 :: (HappyAbsSyn ) -> (Declaration) -happyOut119 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut119 #-} -happyIn120 :: (Declaration) -> (HappyAbsSyn ) -happyIn120 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn120 #-} -happyOut120 :: (HappyAbsSyn ) -> (Declaration) -happyOut120 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut120 #-} -happyIn121 :: (Declaration) -> (HappyAbsSyn ) -happyIn121 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn121 #-} -happyOut121 :: (HappyAbsSyn ) -> (Declaration) -happyOut121 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut121 #-} -happyIn122 :: (Declaration) -> (HappyAbsSyn ) -happyIn122 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn122 #-} -happyOut122 :: (HappyAbsSyn ) -> (Declaration) -happyOut122 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut122 #-} -happyIn123 :: (Declaration) -> (HappyAbsSyn ) -happyIn123 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn123 #-} -happyOut123 :: (HappyAbsSyn ) -> (Declaration) -happyOut123 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut123 #-} -happyIn124 :: (Declaration) -> (HappyAbsSyn ) -happyIn124 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn124 #-} -happyOut124 :: (HappyAbsSyn ) -> (Declaration) -happyOut124 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut124 #-} -happyIn125 :: (Declaration) -> (HappyAbsSyn ) -happyIn125 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn125 #-} -happyOut125 :: (HappyAbsSyn ) -> (Declaration) -happyOut125 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut125 #-} -happyIn126 :: (Declaration) -> (HappyAbsSyn ) -happyIn126 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn126 #-} -happyOut126 :: (HappyAbsSyn ) -> (Declaration) -happyOut126 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut126 #-} -happyIn127 :: (Declaration) -> (HappyAbsSyn ) -happyIn127 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn127 #-} -happyOut127 :: (HappyAbsSyn ) -> (Declaration) -happyOut127 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut127 #-} -happyIn128 :: (Declaration) -> (HappyAbsSyn ) -happyIn128 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn128 #-} -happyOut128 :: (HappyAbsSyn ) -> (Declaration) -happyOut128 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut128 #-} -happyIn129 :: ([Arg Name]) -> (HappyAbsSyn ) -happyIn129 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn129 #-} -happyOut129 :: (HappyAbsSyn ) -> ([Arg Name]) -happyOut129 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut129 #-} -happyIn130 :: ([RString]) -> (HappyAbsSyn ) -happyIn130 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn130 #-} -happyOut130 :: (HappyAbsSyn ) -> ([RString]) -happyOut130 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut130 #-} -happyIn131 :: ([NamedArg HoleName]) -> (HappyAbsSyn ) -happyIn131 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn131 #-} -happyOut131 :: (HappyAbsSyn ) -> ([NamedArg HoleName]) -happyOut131 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut131 #-} -happyIn132 :: (NamedArg HoleName) -> (HappyAbsSyn ) -happyIn132 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn132 #-} -happyOut132 :: (HappyAbsSyn ) -> (NamedArg HoleName) -happyOut132 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut132 #-} -happyIn133 :: (HoleName) -> (HappyAbsSyn ) -happyIn133 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn133 #-} -happyOut133 :: (HappyAbsSyn ) -> (HoleName) -happyOut133 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut133 #-} -happyIn134 :: (HoleName) -> (HappyAbsSyn ) -happyIn134 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn134 #-} -happyOut134 :: (HappyAbsSyn ) -> (HoleName) -happyOut134 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut134 #-} -happyIn135 :: (RString) -> (HappyAbsSyn ) -happyIn135 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn135 #-} -happyOut135 :: (HappyAbsSyn ) -> (RString) -happyOut135 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut135 #-} -happyIn136 :: (Maybe Range) -> (HappyAbsSyn ) -happyIn136 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn136 #-} -happyOut136 :: (HappyAbsSyn ) -> (Maybe Range) -happyOut136 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut136 #-} -happyIn137 :: ([Declaration]) -> (HappyAbsSyn ) -happyIn137 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn137 #-} -happyOut137 :: (HappyAbsSyn ) -> ([Declaration]) -happyOut137 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut137 #-} -happyIn138 :: ([Expr]) -> (HappyAbsSyn ) -happyIn138 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn138 #-} -happyOut138 :: (HappyAbsSyn ) -> ([Expr]) -happyOut138 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut138 #-} -happyIn139 :: (Telescope -> Parser ModuleApplication) -> (HappyAbsSyn ) -happyIn139 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn139 #-} -happyOut139 :: (HappyAbsSyn ) -> (Telescope -> Parser ModuleApplication) -happyOut139 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut139 #-} -happyIn140 :: (Declaration) -> (HappyAbsSyn ) -happyIn140 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn140 #-} -happyOut140 :: (HappyAbsSyn ) -> (Declaration) -happyOut140 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut140 #-} -happyIn141 :: (Declaration) -> (HappyAbsSyn ) -happyIn141 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn141 #-} -happyOut141 :: (HappyAbsSyn ) -> (Declaration) -happyOut141 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut141 #-} -happyIn142 :: (Name) -> (HappyAbsSyn ) -happyIn142 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn142 #-} -happyOut142 :: (HappyAbsSyn ) -> (Name) -happyOut142 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut142 #-} -happyIn143 :: ([Declaration]) -> (HappyAbsSyn ) -happyIn143 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn143 #-} -happyOut143 :: (HappyAbsSyn ) -> ([Declaration]) -happyOut143 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut143 #-} -happyIn144 :: (Declaration) -> (HappyAbsSyn ) -happyIn144 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn144 #-} -happyOut144 :: (HappyAbsSyn ) -> (Declaration) -happyOut144 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut144 #-} -happyIn145 :: (Pragma) -> (HappyAbsSyn ) -happyIn145 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn145 #-} -happyOut145 :: (HappyAbsSyn ) -> (Pragma) -happyOut145 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut145 #-} -happyIn146 :: (Pragma) -> (HappyAbsSyn ) -happyIn146 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn146 #-} -happyOut146 :: (HappyAbsSyn ) -> (Pragma) -happyOut146 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut146 #-} -happyIn147 :: (Pragma) -> (HappyAbsSyn ) -happyIn147 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn147 #-} -happyOut147 :: (HappyAbsSyn ) -> (Pragma) -happyOut147 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut147 #-} -happyIn148 :: (Pragma) -> (HappyAbsSyn ) -happyIn148 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn148 #-} -happyOut148 :: (HappyAbsSyn ) -> (Pragma) -happyOut148 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut148 #-} -happyIn149 :: (Pragma) -> (HappyAbsSyn ) -happyIn149 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn149 #-} -happyOut149 :: (HappyAbsSyn ) -> (Pragma) -happyOut149 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut149 #-} -happyIn150 :: (Pragma) -> (HappyAbsSyn ) -happyIn150 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn150 #-} -happyOut150 :: (HappyAbsSyn ) -> (Pragma) -happyOut150 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut150 #-} -happyIn151 :: (Pragma) -> (HappyAbsSyn ) -happyIn151 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn151 #-} -happyOut151 :: (HappyAbsSyn ) -> (Pragma) -happyOut151 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut151 #-} -happyIn152 :: (Pragma) -> (HappyAbsSyn ) -happyIn152 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn152 #-} -happyOut152 :: (HappyAbsSyn ) -> (Pragma) -happyOut152 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut152 #-} -happyIn153 :: (Pragma) -> (HappyAbsSyn ) -happyIn153 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn153 #-} -happyOut153 :: (HappyAbsSyn ) -> (Pragma) -happyOut153 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut153 #-} -happyIn154 :: (Pragma) -> (HappyAbsSyn ) -happyIn154 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn154 #-} -happyOut154 :: (HappyAbsSyn ) -> (Pragma) -happyOut154 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut154 #-} -happyIn155 :: (Pragma) -> (HappyAbsSyn ) -happyIn155 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn155 #-} -happyOut155 :: (HappyAbsSyn ) -> (Pragma) -happyOut155 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut155 #-} -happyIn156 :: (Pragma) -> (HappyAbsSyn ) -happyIn156 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn156 #-} -happyOut156 :: (HappyAbsSyn ) -> (Pragma) -happyOut156 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut156 #-} -happyIn157 :: (Pragma) -> (HappyAbsSyn ) -happyIn157 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn157 #-} -happyOut157 :: (HappyAbsSyn ) -> (Pragma) -happyOut157 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut157 #-} -happyIn158 :: (Pragma) -> (HappyAbsSyn ) -happyIn158 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn158 #-} -happyOut158 :: (HappyAbsSyn ) -> (Pragma) -happyOut158 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut158 #-} -happyIn159 :: (Pragma) -> (HappyAbsSyn ) -happyIn159 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn159 #-} -happyOut159 :: (HappyAbsSyn ) -> (Pragma) -happyOut159 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut159 #-} -happyIn160 :: (Pragma) -> (HappyAbsSyn ) -happyIn160 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn160 #-} -happyOut160 :: (HappyAbsSyn ) -> (Pragma) -happyOut160 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut160 #-} -happyIn161 :: (Pragma) -> (HappyAbsSyn ) -happyIn161 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn161 #-} -happyOut161 :: (HappyAbsSyn ) -> (Pragma) -happyOut161 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut161 #-} -happyIn162 :: (Pragma) -> (HappyAbsSyn ) -happyIn162 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn162 #-} -happyOut162 :: (HappyAbsSyn ) -> (Pragma) -happyOut162 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut162 #-} -happyIn163 :: (Pragma) -> (HappyAbsSyn ) -happyIn163 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn163 #-} -happyOut163 :: (HappyAbsSyn ) -> (Pragma) -happyOut163 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut163 #-} -happyIn164 :: (Pragma) -> (HappyAbsSyn ) -happyIn164 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn164 #-} -happyOut164 :: (HappyAbsSyn ) -> (Pragma) -happyOut164 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut164 #-} -happyIn165 :: (Pragma) -> (HappyAbsSyn ) -happyIn165 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn165 #-} -happyOut165 :: (HappyAbsSyn ) -> (Pragma) -happyOut165 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut165 #-} -happyIn166 :: (Pragma) -> (HappyAbsSyn ) -happyIn166 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn166 #-} -happyOut166 :: (HappyAbsSyn ) -> (Pragma) -happyOut166 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut166 #-} -happyIn167 :: ([(Range, Occurrence)]) -> (HappyAbsSyn ) -happyIn167 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn167 #-} -happyOut167 :: (HappyAbsSyn ) -> ([(Range, Occurrence)]) -happyOut167 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut167 #-} -happyIn168 :: ((Range, Occurrence)) -> (HappyAbsSyn ) -happyIn168 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn168 #-} -happyOut168 :: (HappyAbsSyn ) -> ((Range, Occurrence)) -happyOut168 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut168 #-} -happyIn169 :: ([TypeSignature]) -> (HappyAbsSyn ) -happyIn169 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn169 #-} -happyOut169 :: (HappyAbsSyn ) -> ([TypeSignature]) -happyOut169 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut169 #-} -happyIn170 :: ([TypeSignature]) -> (HappyAbsSyn ) -happyIn170 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn170 #-} -happyOut170 :: (HappyAbsSyn ) -> ([TypeSignature]) -happyOut170 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut170 #-} -happyIn171 :: ([TypeSignature]) -> (HappyAbsSyn ) -happyIn171 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn171 #-} -happyOut171 :: (HappyAbsSyn ) -> ([TypeSignature]) -happyOut171 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut171 #-} -happyIn172 :: ([Arg TypeSignature]) -> (HappyAbsSyn ) -happyIn172 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn172 #-} -happyOut172 :: (HappyAbsSyn ) -> ([Arg TypeSignature]) -happyOut172 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut172 #-} -happyIn173 :: ([Arg TypeSignature]) -> (HappyAbsSyn ) -happyIn173 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn173 #-} -happyOut173 :: (HappyAbsSyn ) -> ([Arg TypeSignature]) -happyOut173 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut173 #-} -happyIn174 :: ([Arg TypeSignature]) -> (HappyAbsSyn ) -happyIn174 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn174 #-} -happyOut174 :: (HappyAbsSyn ) -> ([Arg TypeSignature]) -happyOut174 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut174 #-} -happyIn175 :: ([Arg TypeSignature]) -> (HappyAbsSyn ) -happyIn175 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn175 #-} -happyOut175 :: (HappyAbsSyn ) -> ([Arg TypeSignature]) -happyOut175 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut175 #-} -happyIn176 :: (((Maybe (Ranged Induction), Maybe HasEta, Maybe (Name, IsInstance)), [Declaration])) -> (HappyAbsSyn ) -happyIn176 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn176 #-} -happyOut176 :: (HappyAbsSyn ) -> (((Maybe (Ranged Induction), Maybe HasEta, Maybe (Name, IsInstance)), [Declaration])) -happyOut176 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut176 #-} -happyIn177 :: ([RecordDirective]) -> (HappyAbsSyn ) -happyIn177 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn177 #-} -happyOut177 :: (HappyAbsSyn ) -> ([RecordDirective]) -happyOut177 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut177 #-} -happyIn178 :: (RecordDirective) -> (HappyAbsSyn ) -happyIn178 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn178 #-} -happyOut178 :: (HappyAbsSyn ) -> (RecordDirective) -happyOut178 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut178 #-} -happyIn179 :: (Ranged HasEta) -> (HappyAbsSyn ) -happyIn179 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn179 #-} -happyOut179 :: (HappyAbsSyn ) -> (Ranged HasEta) -happyOut179 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut179 #-} -happyIn180 :: (Ranged Induction) -> (HappyAbsSyn ) -happyIn180 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn180 #-} -happyOut180 :: (HappyAbsSyn ) -> (Ranged Induction) -happyOut180 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut180 #-} -happyIn181 :: ([Declaration]) -> (HappyAbsSyn ) -happyIn181 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn181 #-} -happyOut181 :: (HappyAbsSyn ) -> ([Declaration]) -happyOut181 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut181 #-} -happyIn182 :: ([Declaration]) -> (HappyAbsSyn ) -happyIn182 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn182 #-} -happyOut182 :: (HappyAbsSyn ) -> ([Declaration]) -happyOut182 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut182 #-} -happyIn183 :: ([Declaration]) -> (HappyAbsSyn ) -happyIn183 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn183 #-} -happyOut183 :: (HappyAbsSyn ) -> ([Declaration]) -happyOut183 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut183 #-} -happyIn184 :: ([Declaration]) -> (HappyAbsSyn ) -happyIn184 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyIn184 #-} -happyOut184 :: (HappyAbsSyn ) -> ([Declaration]) -happyOut184 x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyOut184 #-} -happyInTok :: (Token) -> (HappyAbsSyn ) -happyInTok x = Happy_GHC_Exts.unsafeCoerce# x -{-# INLINE happyInTok #-} -happyOutTok :: (HappyAbsSyn ) -> (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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x40\x00\x02\xe8\x53\x21\x00\x00\x30\xc7\x56\x05\x16\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\x01\xf4\xa9\x10\x00\x00\x98\x63\xab\x02\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x04\x20\x80\x3e\x15\x02\x00\x00\x53\x6c\x55\x60\x01\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\x40\xdf\x0a\x01\x00\x80\x39\xb6\x2a\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xda\x44\x00\x00\x00\x4c\x31\x55\x81\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\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\x08\xa0\x4f\x85\x00\x00\xc0\x14\x4b\x15\x58\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\x04\xd0\xa7\x42\x00\x00\x60\x8e\xad\x0a\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x80\x01\x44\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\x30\x82\x28\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\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\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\x80\x36\x11\x00\x00\x00\x53\x0c\x55\x60\x01\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\x40\x9f\x0a\x01\x00\x80\x29\x96\x2a\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x26\x02\x00\x00\x60\x8a\xa1\x0a\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x80\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\xa0\x4d\x04\x00\x00\xc0\x14\x43\x15\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x23\x88\x02\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\x04\x80\x05\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\x08\x7d\x2a\x04\x00\x00\xe6\xd8\xae\xc0\x02\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\x80\x3e\x15\x02\x00\x00\x73\x6c\x55\x60\x01\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\x40\x9f\x0a\x01\x00\x80\x39\xb6\x7a\xb0\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\x08\xa0\x4f\x85\x00\x00\xc0\x1c\x5b\x35\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xfa\x54\x08\x00\x00\x4c\xb1\x55\x81\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\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\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\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\xd0\x26\x02\x00\x00\x60\x8a\xa1\x0a\x2c\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\xe8\x53\x21\x00\x00\x30\xc7\x76\x05\x16\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\x01\xf4\xa9\x10\x00\x00\x98\x63\xab\x07\x0b\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\xfa\x54\x08\x00\x00\xcc\xb1\x55\x83\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\xe1\xbd\xdf\xe7\x4e\x00\x00\x60\x8a\xad\x0a\x2d\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\x10\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\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\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\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\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\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\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\x10\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\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\x80\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\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\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\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\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\xb4\x89\x00\x00\x00\x98\x62\xa8\x02\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x04\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\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\xfc\xff\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\x40\x00\x02\xe8\x53\x21\x00\x00\x30\xc7\x56\x05\x16\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\x01\xf4\xa9\x10\x00\x00\x98\x63\xab\x02\x0b\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\xfa\x54\x08\x00\x00\x4c\xb1\x54\x81\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\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\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\x01\x08\xa0\x4f\x85\x00\x00\xc0\x14\x5b\x15\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x20\x00\x01\xf4\xa9\x10\x00\x00\x98\x62\xab\x02\x0b\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\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\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\x10\x80\x00\xfa\x54\x08\x00\x00\xcc\xb1\x55\x81\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x82\x28\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\x01\x08\xa0\x4f\x85\x00\x00\xc0\x1c\x5b\x15\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x80\x11\x44\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x82\x28\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\x41\x14\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\x40\x00\x42\xe8\x53\x21\x00\x00\x30\xc5\x76\x05\x16\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\x01\xf4\xa9\x10\x00\x00\x98\x62\xab\x07\x0b\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\xfa\x54\x08\x00\x00\x4c\xb1\x55\xa3\x05\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\x00\x7d\x2a\x04\x00\x00\xe6\xd8\xae\xc0\x02\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\x80\x3e\x15\x02\x00\x00\x73\x6c\xf5\x60\x01\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\x40\x9f\x0a\x01\x00\x80\x39\xb6\x6a\xb0\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\x08\xa0\x4f\x85\x00\x00\xc0\x14\x4b\x15\x58\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\x04\xd0\xa7\x42\x00\x00\x60\x8a\xa5\x0a\x2c\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\xe8\x53\x21\x00\x00\x30\xc5\x52\x05\x16\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\x01\xf4\xa9\x10\x00\x00\x98\x63\xab\x02\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x6d\x22\x00\x00\x00\xa6\x18\xaa\xc0\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\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\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\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\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\xc0\x74\x78\xef\xf7\xb9\x13\x00\x00\x98\x62\xab\x42\x0b\x00\x00\x00\x00\x00\x00\x00\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\x11\x44\x81\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\x00\x7d\x2a\x04\x00\x00\xe6\xd8\xaa\xc0\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\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\x30\x82\x28\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\x80\x00\x84\xd0\xa7\x42\x00\x00\x60\x8a\xad\x0a\x2c\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\xe8\x53\x21\x00\x00\x30\xc5\x56\x05\x16\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\x01\xf4\xa9\x10\x00\x00\x98\x62\xab\x02\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x04\x20\x84\x3e\x15\x02\x00\x00\x53\x6c\x55\x60\x01\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\x40\x9f\x0a\x01\x00\x80\x29\xb6\x2a\xb0\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\x08\xa0\x4f\x85\x00\x00\xc0\x14\x5b\x15\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x7d\x2a\x04\x00\x00\xe6\xd8\xaa\xc0\x02\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\x80\x3e\x15\x02\x00\x00\x73\x6c\x55\x60\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\x00\x00\x00\x00\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\x4d\x04\x00\x00\xc0\x14\x43\x15\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x04\xd0\xa7\x42\x00\x00\x60\x8e\xad\x0a\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xfa\x54\x08\x00\x00\x4c\xb1\x55\x81\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\x00\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\x80\x3e\x15\x02\x00\x00\x53\x2c\x55\x60\x01\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\x40\x9f\x0a\x01\x00\x80\x29\xb6\x2a\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x04\xd0\xa7\x42\x00\x00\x60\x8a\xa5\x0a\x2c\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\xe8\x53\x21\x00\x00\x30\xc5\x52\x05\x16\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\x01\xf4\xa9\x10\x00\x00\x98\x62\xa9\x02\x0b\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\xfa\x54\x08\x00\x00\x4c\xb1\x55\x81\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\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\x04\x20\x80\x3e\x15\x02\x00\x00\x53\x6c\x55\x60\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\x80\x00\x50\x00\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\x08\xa0\x4f\x85\x00\x00\xc0\x14\x5b\x15\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\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\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\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\x80\x00\x04\xd0\xa7\x42\x00\x00\x60\x8e\xad\x0a\x2c\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\xe8\x53\x21\x00\x00\x30\xc7\x56\x05\x16\x00\x00\x00\x00\x00\x00\x00\x00\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\xda\x44\x00\x00\x00\x4c\x31\x54\x81\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\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\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\x02\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\x01\xf4\xa9\x10\x00\x00\x98\x62\xa9\x02\x0b\x00\x00\x00\x00\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\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\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\x80\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\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\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\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\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\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\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\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\x02\x10\x40\x9f\x0a\x01\x00\x80\x29\x96\x2a\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x08\x00\x48\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\x01\xf4\xa9\x10\x00\x00\x98\x62\xa9\x02\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x80\x00\x04\xd0\xa7\x42\x00\x00\x60\x8a\xa5\x0a\x2c\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\xe8\x53\x21\x00\x00\x30\xc5\x52\x05\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xfa\x54\x08\x00\x00\x4c\xb1\x54\x81\x05\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\x00\x7d\x2a\x04\x00\x00\xa6\x58\xaa\xc0\x02\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\x80\x3e\x15\x02\x00\x00\x53\x2c\x55\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\x30\x82\x28\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\x8c\x20\x0a\x04\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\x42\xe8\x53\x21\x00\x00\x30\xc5\x76\x05\x16\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\x01\xf4\xa9\x10\x00\x00\x98\x62\xab\x07\x0b\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\xfa\x54\x08\x00\x00\x4c\xb1\x55\x83\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x4d\x04\x00\x00\xc0\x14\x43\x15\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\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\x08\x40\x00\x7d\x2a\x04\x00\x00\xe6\xd8\xaa\xc0\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\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\x40\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\x08\x40\x00\x7d\x2a\x04\x00\x00\xe6\xd8\xaa\xc0\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\x04\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\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\x20\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\x40\x00\x02\xe8\x53\x21\x00\x00\x30\xc7\x56\x05\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\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\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\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\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\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\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\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\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\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\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\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\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\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\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\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\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\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\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\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\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\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\x20\x00\x01\xf4\xa9\x10\x00\x00\x98\x63\xab\x02\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x81\x00\x00\x00\x00\x00\x00\x00\x00\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\x08\xa2\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\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa6\xc3\x7b\xbf\xcf\x9d\x00\x00\xc0\x14\x5b\x95\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\xc0\x08\xa2\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\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\x18\x41\x14\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\x8c\x20\x0a\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\x08\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\x02\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\x01\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\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\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\xc0\x08\xa2\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\x60\x04\x51\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\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x74\x78\xef\xf7\xb9\x13\x00\x00\x98\x62\xab\x42\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\xda\x44\x00\x00\x00\x4c\x31\x54\x81\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\xc0\x08\xa2\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\x01\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\x30\x82\x28\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\x40\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\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\x06\x04\x05\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\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\x02\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\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\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\x20\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\x80\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\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\x01\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\x30\x82\x28\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\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\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\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\x01\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x40\x00\x02\xe8\x53\x21\x00\x00\x30\xc5\x56\x05\x16\x00\x00\x00\x00\x00\x00\x00\x00\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\x02\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\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\x08\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\x04\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\x10\x80\x00\xfa\x54\x08\x00\x00\xcc\xb1\x55\x81\x05\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\x00\x7d\x2a\x04\x00\x00\xe6\xd8\xaa\xc0\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\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\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\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\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\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\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\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\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\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\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\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\x20\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\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\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\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\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\x10\x80\x00\xfa\x54\x08\x00\x00\xcc\xb1\x55\x81\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xe8\x53\x21\x00\x00\x30\xc7\x56\x05\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x22\x00\x00\x00\xa6\x18\xaa\xc0\x02\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\x41\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\x02\x10\x40\x9f\x0a\x01\x00\x80\x39\xb6\x7a\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x10\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\x10\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\x08\x00\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\x04\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\x02\x40\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\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\x01\x08\xa0\x4f\x85\x00\x00\xc0\x14\x4b\x15\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\xf4\xa9\x10\x00\x00\x98\x62\xa9\x42\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x7d\x2a\x04\x00\x00\xe6\xd8\xaa\xc0\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\x10\x80\x00\xfa\x54\x08\x00\x00\xcc\xb1\x55\x81\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\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\x04\x00\x40\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\x80\x00\x04\xd0\xa7\x42\x00\x00\x60\x8e\xad\x0a\x2c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\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\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\x01\x00\x10\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\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\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\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\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\x08\x40\x00\x7d\x2a\x04\x00\x00\xa6\x58\xaa\xd0\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\x40\x00\x02\xe8\x53\x21\x00\x00\x30\xc7\x56\x05\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x08\xa0\x4f\x85\x00\x00\xc0\x14\x4b\x15\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\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\x20\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\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\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\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\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\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\x08\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\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\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\x01\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\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\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\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\x08\x40\x00\x7d\x2a\x04\x00\x00\xe6\xd8\xaa\xc0\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\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\x08\xa0\x4f\x85\x00\x00\xc0\x1c\x5b\x15\x58\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\x04\xd0\xa7\x42\x00\x00\x60\x8e\xad\x0a\x2c\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\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\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\x60\x00\x50\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\x0a\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\x05\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\x03\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\x80\x01\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\x08\x40\x00\x7d\x2a\x04\x00\x00\xe6\xd8\xaa\xc0\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\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\x02\x10\x40\x9f\x0a\x01\x00\x80\x39\xb6\x2a\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x02\xe8\x53\x21\x00\x00\x30\xc7\x56\x05\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x04\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\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\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\xc0\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\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\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\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\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\x40\x00\x02\xe8\x53\x21\x00\x00\x30\xc7\x56\x05\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6d\x22\x00\x00\x00\xa6\x18\xaa\xc0\x02\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\x41\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\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\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\xf8\x8f\xef\xff\x3e\x77\x02\x00\x00\x53\x6c\x55\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\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\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\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\x01\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\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\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\x10\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\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\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\x40\x00\x00\x04\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\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\x40\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\x10\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\x08\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\x04\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\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\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\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\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\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\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\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\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\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\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\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\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\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\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\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\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\x80\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\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\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\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\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\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\x01\x00\x10\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\x08\x40\x00\x7d\x2a\x04\x00\x00\xe6\xd8\xea\xc1\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\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\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\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\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\x03\x80\x02\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\x80\x01\x40\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x80\x01\x40\x81\x00\x00\x00\x00\x00\x00\x00\x00\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\xa0\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\x60\x00\x50\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\x30\x00\x28\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\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x76\x78\xef\xf7\xb9\x13\x00\x00\x98\x62\xab\x52\x0b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xc7\xf7\x7f\x9f\x3b\x01\x00\x80\x29\xb6\x2a\xb4\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\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\x40\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\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\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\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\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"# - -{-# NOINLINE happyExpListPerState #-} -happyExpListPerState st = - token_strs_expected - where token_strs = ["error","%dummy","%start_tokensParser","%start_exprParser","%start_exprWhereParser","%start_moduleParser","%start_moduleNameParser","%start_funclauseParser","%start_holeContentParser","Tokens","TokensR","Token","File","maybe_vclose","close","semi","beginImpDir","Int","Id","SpaceIds","DoubleCloseBrace","MaybeDottedId","MaybeDottedIds","ArgIds","ModalArgIds","Attribute","Attributes","Attributes1","QId","ModuleName","BId","SpaceBIds","CommaBIds","CommaBIdAndAbsurds","BIdsWithHiding","PragmaStrings","PragmaString","Strings","ForeignCode","PragmaName","PragmaQName","PragmaQNames","Expr","Expr1","WithExprs","Application","Expr2","LetBody","ExtendedOrAbsurdLam","Application3","Application3PossiblyEmpty","Expr3Curly","Expr3NoCurly","ExprOrAttr","Expr3","RecordAssignments","RecordAssignments1","RecordAssignment","ModuleAssignment","FieldAssignments","FieldAssignments1","FieldAssignment","TeleArrow","Telescope1","TypedBindings","TypedBinding","TBind","ModalTBind","TBindWithHiding","ModalTBindWithHiding","LamBindings","AbsurdLamBindings","LamBinds","LamBindsAbsurd","NonAbsurdLamClause","AbsurdLamClause","LamClause","LamClauses","LamWhereClauses","ForallBindings","TypedUntypedBindings1","TypedUntypedBindings","DomainFreeBinding","DomainFreeBindingAbsurd","DoStmts","DoStmt","DoWhere","ImportDirective","ImportDirectives","ImportDirective1","Using","Hiding","RenamingDir","Renamings","Renaming","ImportName_","ImportName","CommaImportNames","CommaImportNames1","LHS","WithExpressions","RewriteEquations","HoleContent","WhereClause","ExprWhere","Declaration","TypeSigs","ArgTypeSigs","FunClause","RHS","Data","DataSig","Record","RecordSig","RecordConstructorName","Infix","Fields","Generalize","Mutual","Abstract","Private","Instance","Macro","Postulate","Primitive","UnquoteDecl","Syntax","PatternSyn","PatternSynArgs","SimpleIds","HoleNames","HoleName","SimpleTopHole","SimpleHole","SimpleId","MaybeOpen","Open","OpenArgs","ModuleApplication","ModuleMacro","Module","Underscore","TopLevel","Pragma","DeclarationPragma","OptionsPragma","BuiltinPragma","RewritePragma","ForeignPragma","CompilePragma","StaticPragma","InlinePragma","NoInlinePragma","InjectivePragma","DisplayPragma","EtaPragma","NoTerminationCheckPragma","NonTerminatingPragma","TerminatingPragma","MeasurePragma","CatchallPragma","ImpossiblePragma","NoPositivityCheckPragma","NoUniverseCheckPragma","PolarityPragma","WarningOnUsagePragma","Polarities","Polarity","TypeSignatures0","TypeSignatures","TypeSignatures1","ArgTypeSignatures","ArgTypeSignatures1","ArgTypeSignaturesOrEmpty","ArgTypeSignatures0","RecordDeclarations","RecordDirectives","RecordDirective","RecordEta","RecordInduction","Declarations","Declarations0","Declarations1","TopDeclarations","'abstract'","'codata'","'coinductive'","'constructor'","'data'","'eta-equality'","'field'","'forall'","'variable'","'hiding'","'import'","'in'","'inductive'","'infix'","'infixl'","'infixr'","'instance'","'overlap'","'let'","'macro'","'module'","'mutual'","'no-eta-equality'","'open'","'pattern'","'postulate'","'primitive'","'private'","'Prop'","'public'","'quote'","'quoteContext'","'quoteGoal'","'quoteTerm'","'record'","'renaming'","'rewrite'","'Set'","'syntax'","'tactic'","'to'","'unquote'","'unquoteDecl'","'unquoteDef'","'using'","'where'","'do'","'with'","'BUILTIN'","'CATCHALL'","'DISPLAY'","'ETA'","'FOREIGN'","'COMPILE'","'IMPOSSIBLE'","'INJECTIVE'","'INLINE'","'NOINLINE'","'MEASURE'","'NO_TERMINATION_CHECK'","'NO_POSITIVITY_CHECK'","'NO_UNIVERSE_CHECK'","'NON_TERMINATING'","'OPTIONS'","'POLARITY'","'WARNING_ON_USAGE'","'REWRITE'","'STATIC'","'TERMINATING'","setN","propN","tex","comment","'...'","'..'","'.'","';'","':'","'='","'_'","'?'","'->'","'\\\\'","'@'","'|'","'('","')'","'(|'","'|)'","'{{'","'}}'","'{'","'}'","vopen","vclose","vsemi","'{-#'","'#-}'","id","q_id","string","literal","%eof"] - bit_start = st * 287 - bit_end = (st + 1) * 287 - read_bit = readArrayBit happyExpList - bits = map read_bit [bit_start..bit_end - 1] - bits_indexed = zip bits [0..286] - token_strs_expected = concatMap f bits_indexed - f (False, _) = [] - f (True, nr) = [token_strs !! nr] - -happyActOffsets :: HappyAddr -happyActOffsets = HappyA# "\x00\x00\x53\x0c\x53\x0c\xb2\xff\x4d\x00\x3c\x0f\x13\x09\x00\x00\x66\x05\xc4\xff\x00\x00\x10\x14\x00\x00\x00\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x00\x00\x00\x00\x00\x00\x00\x9d\x0c\xe9\x0c\xeb\xff\x00\x00\xf0\x02\x00\x00\xe1\xff\x14\x06\x3c\x00\x00\x00\x00\x00\x00\x00\x47\x00\x00\x00\x5a\x14\x22\x12\x00\x00\x75\x14\x00\x00\x7d\x00\x00\x00\x00\x00\x00\x00\x11\x01\xbd\x14\x00\x00\x00\x00\xbb\x01\x49\x03\x48\x07\xe9\x0c\x92\x07\x5d\x09\x00\x00\x00\x00\x00\x00\x3c\x0f\xc4\x00\xbf\x00\x25\x02\x92\x00\xd8\x14\xaa\x09\xdf\x07\xf4\x09\x00\x00\x00\x00\x92\x00\x92\x00\xff\x04\x10\x00\x92\x00\x92\x00\x92\x00\x00\x00\xfa\x00\xde\x00\x8e\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\x63\x01\x00\x00\x00\x00\x00\x00\x1d\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\x42\x01\x22\x01\x22\x01\x47\x01\x71\x01\x5b\x01\x5b\x01\x5b\x01\x78\x01\x78\x01\x02\x01\x78\x01\xa4\x00\x25\x01\x81\x01\xc3\x01\xc6\x01\x20\x15\xb1\x01\xc7\xff\xb1\x01\x8a\x0a\x04\x02\x00\x00\x00\x00\xe8\x00\x00\x00\x37\x02\x40\x02\x00\x00\x00\x00\x10\x00\xe9\x0c\xe9\x0c\x22\x12\x6a\x02\x00\x00\x25\x02\x86\x0f\x61\x02\x65\x02\x00\x00\xbc\xff\x5b\x02\x60\x02\x7c\x02\xe8\x00\xe8\x00\x77\x02\xd0\x0f\xa7\x02\xbe\xff\xa8\x02\xaf\x02\xb7\x02\xbe\x02\x75\x02\x00\x00\xe9\x0c\x00\x00\x00\x00\x7f\x04\xe9\x0c\x00\x00\xdf\x02\x00\x00\x17\x06\xae\x05\xe9\x02\xa6\x02\x41\x03\x00\x00\x41\x0a\x8b\x0a\xd8\x0a\x25\x0b\x2c\x08\x6f\x0b\x22\x12\x6c\x12\x6c\x12\xe9\x0c\x0c\x03\x3b\x15\x00\x00\xed\x02\x75\x02\x7e\x03\x8a\x03\xfe\x06\x7a\x06\xe9\x0c\x36\x03\x7a\x06\x00\x00\x33\x0d\x1a\x10\x1a\x10\x00\x00\xc3\x02\x7d\x0d\x1a\x10\x1a\x10\x00\x00\x00\x00\x00\x00\x00\x00\xc7\x0d\xc7\x0d\x3e\x03\x3b\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc7\x0d\x00\x00\x00\x00\x1a\x10\x00\x00\xb6\x12\x64\x10\x00\x00\xb6\x12\x00\x13\x00\x13\xae\x10\x3b\x03\xae\x10\x11\x02\xae\x10\x45\x03\x47\x03\x00\x00\x00\x00\x00\x00\x00\x00\x1d\x00\x00\x00\xc7\x0d\xc7\x0d\x63\x03\x3b\x15\x5e\x03\x00\x00\x74\x03\x00\x00\x00\x00\x64\x03\x4a\x13\xac\x03\x1d\x00\x93\x01\x8c\x03\xe8\x00\x9c\x03\xa8\x03\xe8\x00\x9f\x03\x7b\x00\x8f\x03\xf8\x10\x00\x00\xaf\x01\x7d\x01\x4a\x13\xb9\x03\xdc\x03\xc7\x03\xcf\x03\x00\x00\x94\x13\x94\x13\x00\x00\x94\x13\x94\x13\x44\x11\xe0\x06\xd1\x03\xe0\x06\xbc\x0b\x06\x0c\x11\x0e\x00\x00\x00\x00\xd3\x03\x83\x15\xf8\xff\x00\x00\x00\x00\x00\x00\x5e\x0e\xd9\x03\x00\x00\x00\x00\x00\x00\x75\x01\x00\x00\x00\x00\x5e\x0e\xa1\x01\xe7\x03\x10\x00\x00\x00\x5e\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc6\xff\xcc\x03\xeb\x03\xfb\x03\xfe\x03\x18\x04\x1f\x04\x22\x04\x22\x04\x22\x04\x3a\x04\x2b\x04\x49\x04\x4e\x04\x55\x04\x5d\x04\x62\x04\x75\x04\x79\x04\x8d\x04\x92\x04\x98\x04\xfa\x03\x35\x04\x5e\x0e\xc8\x03\xe3\x06\x00\x00\x00\x00\x99\x04\x00\x00\x00\x00\x1a\x00\x00\x00\xd4\x09\xa6\x04\x00\x00\x21\x0a\x21\x0a\x00\x00\x00\x00\x00\x00\xb3\x01\x00\x00\xb3\x01\xb3\x01\x00\x00\xb6\x01\x00\x00\xe1\x02\x21\x0a\x21\x0a\x00\x00\x00\x00\x00\x00\xa1\x02\xfe\x06\x00\x00\x98\x06\x00\x00\x66\x04\xe3\x04\xb8\x04\xb8\x04\x00\x00\x9e\x15\x21\x0a\x7e\x00\x21\x0a\x88\x00\xcf\x04\x45\x02\x00\x00\xe1\x00\xce\x04\x00\x00\x00\x00\xe1\x00\xb3\x01\x00\x00\x00\x00\x00\x00\x09\x05\x11\x00\x21\x0a\x00\x00\xfb\x04\x00\x00\x00\x05\x00\x00\xe1\x00\x00\x00\x00\x00\x00\x00\xa6\x00\x8e\x11\x53\x02\x00\x00\x00\x00\x00\x00\xfe\x04\xe9\xff\xe9\xff\x00\x00\x00\x00\x5e\x0e\x5e\x0e\x00\x00\x00\x00\xf2\x04\x00\x00\x00\x00\xf4\x04\xf3\x04\xf9\x04\x00\x00\x00\x00\xf8\x04\xfc\x04\x00\x00\x00\x00\x00\x00\x00\x00\x02\x05\x74\x05\x76\x05\x7c\x05\x00\x00\x85\x05\xe0\x02\x93\x05\x97\x05\x00\x00\x9a\x05\x9a\x05\x00\x00\x00\x00\x5e\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x0e\x00\x00\x00\x00\x9e\x15\x59\x01\x79\x08\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe1\x00\xe7\x00\x11\x02\x07\x01\x11\x02\x00\x00\xb1\x05\xd8\x11\x00\x00\x00\x00\xd8\x11\x00\x00\x5e\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x0e\xa8\x0e\x00\x00\x00\x00\xa9\x05\x00\x00\xc8\x05\xbe\x05\x00\x00\xd1\x05\xa1\x02\x00\x00\x59\x01\xf2\x0e\x00\x00\x00\x00\x00\x00\x00\x00\xca\x05\x00\x00\x15\x02\x00\x00\xc6\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x01\x00\x00\x00\x00\x00\x00\xcf\x05\x00\x00\xd5\x05\xd8\x05\x00\x00\xc4\x05\x00\x00\xd8\x11\x00\x00\x00\x00\x00\x00\x00\x00\xf2\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd8\x11\xe8\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe2\x05\xee\x05\xf9\x05\x00\x00\x06\x06\xe0\x02\xe0\x02\x04\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x01\x0d\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x15\x06\x27\x06\xb8\x01\xd6\x05\x2c\x06\xb9\x01\x00\x00\x1a\x06\x24\x00\x23\x06\xf2\x0e\x00\x00\x21\x06\xf2\x0e\xf2\x0e\x38\x06\x2b\x06\xa1\x02\x2b\x06\x00\x00\x00\x00\x28\x03\x3d\x06\x00\x00\x00\x00\x28\x03\x00\x00\x2f\x04\x00\x00\x00\x00\xc4\x02\x2f\x03\x8e\x00\x8e\x00\xf2\x0e\x2f\x06\xf2\x0e\x00\x00\x2f\x06\xf2\x0e\x00\x00\x59\x01\x00\x00\x00\x00\x00\x00\x61\x06\x00\x00\x62\x06\x00\x00\x00\x00\x8e\x00\x34\x06\x31\x06\x31\x06\xe8\x00\x00\x00\x31\x06\x31\x06\x00\x00\x31\x06\x31\x06\x00\x00\x00\x00\xf2\x0e\x00\x00\x00\x00\xe6\x15\x59\x01\x00\x00\x01\x03\x00\x00\x00\x00\x00\x00\x69\x06\x00\x00\xcc\x05\x39\x06\x00\x00\x49\x06\x50\x06\xe9\xff\x00\x00\x52\x06\x53\x06\xe9\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x48\x06\x00\x00\x4d\x06\x00\x00\x00\x00\x00\x00\x00\x00\x59\x01\x00\x00\x00\x00\xe1\x00\x00\x00\xee\xff\xfe\xff\xee\xff\x00\x00\x00\x00\x6f\x06\x5f\x06\x00\x00\x5a\x06\x5a\x06\x71\x06\x7e\x06\xa3\x06\x00\x00\x00\x00\x76\x06\x00\x00\x00\x00\xe0\x02\x00\x00\x72\x06\x00\x00\x6b\x06\x6b\x06\x7c\x06\x75\x06\x75\x06\x00\x00\x00\x00\xe1\x00\x00\x00\x00\x00\x00\x00\x1d\x00\x00\x00\x77\x06\x00\x00\x00\x00\x7b\x06\x00\x00\x7d\x06\x59\x01\x00\x00\x00\x00\xc6\x08\x00\x00\x7f\x06\xe8\x00\x83\x06\xe8\x00\x2f\x04\x2f\x04\x00\x00\x85\x06\x85\x06\x00\x00\x00\x00\x00\x00\x00\x00\x2f\x04\x2f\x04\x2f\x04\x2f\x04\xe8\x00\x00\x00\x00\x00\x32\x04\x00\x00\x00\x00\x00\x00\x32\x06\x8a\x06\x8e\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x84\x06\x84\x06\xd1\x06\x00\x00\x00\x00\x00\x00\x00\x00\xee\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1d\x00\x87\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x90\x06\x00\x00\x00\x00\x00\x00"# - -happyGotoOffsets :: HappyAddr -happyGotoOffsets = HappyA# "\x68\x03\x3e\x19\xe5\x03\xea\x06\x95\x01\xdf\x13\xec\x13\xf0\x06\xf1\x06\x00\x00\x00\x00\x0f\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcf\x08\x5e\x19\x00\x00\x00\x00\x35\x03\x00\x00\x00\x00\x19\x03\x4a\x06\x00\x00\x00\x00\x00\x00\xed\x06\x00\x00\xce\x01\xe8\x07\x00\x00\x4e\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc2\x00\x00\x00\x00\x00\x27\x04\x57\x01\x08\x03\x7e\x19\xc2\x16\xed\x16\x00\x00\x00\x00\x00\x00\x28\x14\x9b\x06\x00\x00\x96\x06\x00\x00\xc2\x00\x9e\x19\x1e\x19\xbe\x19\x00\x00\x00\x00\x00\x00\x00\x00\x90\x00\x9f\x06\x00\x00\x00\x00\x00\x00\x00\x00\x19\x00\x29\x03\xfb\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\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\x53\x03\xf9\x06\x02\x07\x6e\x06\x78\x06\x0d\x07\x1a\x07\x1b\x07\xab\x03\xbd\x03\x27\x00\xbf\x03\x7f\x02\x1e\x07\xc3\x03\xe0\x03\xe4\x03\xeb\x02\x28\x07\x93\x04\x9c\x04\x00\x00\x00\x00\x00\x00\x00\x00\x27\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\x06\xde\x19\xfe\x19\x35\x08\xdc\x06\x00\x00\xd4\x06\xf7\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x07\x33\x07\x00\x00\x62\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x97\x06\x7f\x02\x00\x00\x1e\x1a\x00\x00\x00\x00\x68\x02\x3e\x1a\x00\x00\x00\x00\x00\x00\x99\x03\x00\x00\x00\x00\xca\x00\xce\x00\x00\x00\xa1\x03\x3d\x17\x7c\x03\x91\x16\x22\x18\x4c\x18\x71\x02\x73\x18\x7e\x18\x31\x16\x00\x00\xd3\x01\x00\x00\x00\x00\x4a\x07\x00\x00\x21\x07\x54\x02\xba\x03\x5e\x1a\x00\x00\xdf\x03\x00\x00\xa1\x03\x81\x17\xa0\x17\x00\x00\x00\x00\xc0\x03\xbf\x17\xde\x17\x00\x00\x00\x00\x00\x00\x00\x00\x7e\x1a\x9e\x1a\x00\x00\xa2\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\xbe\x1a\x00\x00\x00\x00\x67\x1d\x00\x00\xb3\x09\xb7\x1d\x00\x00\xa4\x07\x9b\x18\xa6\x18\x72\x1d\x00\x00\x91\x1d\x36\x07\xa1\x1d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x44\x07\x00\x00\xde\x1a\xfe\x1a\x00\x00\x2d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x00\x82\x08\xff\x06\x46\x07\x47\x07\x00\x00\x4c\x07\x00\x00\x00\x00\x4e\x07\x00\x00\x00\x00\x00\x00\x1c\x09\x00\x00\x4f\x07\x56\x07\x6f\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc3\x18\xce\x18\x00\x00\xeb\x18\xf6\x18\x08\x00\xa7\x03\x00\x00\x23\x04\xa1\x03\x62\x17\xfd\x17\x00\x00\x00\x00\x00\x00\x4a\x00\x40\x07\x00\x00\x00\x00\x00\x00\x1e\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x02\x00\x00\x00\x00\x3e\x1b\x5c\x02\x00\x00\x0e\x07\x00\x00\x5e\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x50\x07\x00\x00\x00\x00\x00\x00\x52\x07\x57\x07\x5d\x07\x5f\x07\x00\x00\x00\x00\x00\x00\x00\x00\x53\x07\x6d\x07\x6e\x07\x8a\x02\x71\x07\x00\x00\xb4\x04\x00\x00\x00\x00\x7e\x1b\x9b\x03\xee\x02\x00\x00\x00\x00\xfc\xff\x00\x00\x00\x00\xfd\xff\x00\x00\x2a\x01\x83\x07\x00\x00\x8e\x04\xf0\x04\x00\x00\x00\x00\x00\x00\x2f\x02\x00\x00\x84\x03\xa2\x03\x00\x00\x03\x00\x00\x00\xf9\xff\xf5\x04\xf4\x05\x00\x00\x00\x00\x00\x00\xe6\x03\xe8\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x04\x31\x04\x00\x00\xba\x00\x89\x06\x00\x00\xc0\x06\x00\x00\x00\x00\x21\x04\x00\x00\xfd\x04\xef\x06\x4f\x02\x00\x00\x06\x05\xc1\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1e\x05\x00\x00\x00\x00\x00\x00\x00\x00\x18\x17\x08\x02\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x04\x7a\x04\x00\x00\x00\x00\x9e\x1b\xbe\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x07\x00\x00\xfa\x06\x00\x00\x00\x00\x7c\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7e\x07\x84\x07\x00\x00\x89\x07\x00\x00\x87\x07\x88\x07\x00\x00\x00\x00\xde\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfe\x1b\x00\x00\x00\x00\xdf\x00\x24\x04\x1e\x19\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x30\x05\x00\x00\x9d\x07\x00\x00\x9e\x07\x00\x00\x00\x00\x2f\x01\x00\x00\x00\x00\xcb\x01\x00\x00\x1e\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf4\x02\x00\x00\xe1\x04\x3e\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf1\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9e\x00\x00\x00\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x02\xa5\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\x07\x9c\x07\xa1\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x20\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x07\x00\x00\x00\x00\x43\x07\x00\x00\x27\x01\x00\x00\x24\x07\x7e\x1c\x00\x00\x3a\x00\x9e\x1c\xbe\x1c\x00\x00\x90\x04\x25\x00\xa1\x04\x00\x00\x00\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\xb6\x03\x00\x00\x00\x00\xc3\x07\xc4\x07\x04\x01\x34\x02\xde\x1c\xb1\x04\xfe\x1c\x00\x00\x45\x05\x1e\x1d\x00\x00\xbd\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc8\x02\x00\x00\xc9\x07\xca\x07\xcb\x07\x00\x00\x3e\x05\xf8\x05\x00\x00\xfc\x05\x0b\x06\x00\x00\x00\x00\x3e\x1d\x00\x00\x00\x00\x55\x01\x31\x07\x00\x00\x2e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x24\x01\x58\x07\x00\x00\x00\x00\x00\x00\x9d\x05\x00\x00\x00\x00\x00\x00\xad\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\x37\x07\x00\x00\x00\x00\x51\x06\x00\x00\x77\x00\xdb\x00\x44\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xce\x07\xd1\x07\x00\x00\x00\x00\x00\x00\xcd\x07\x00\x00\x00\x00\x00\x00\x00\x00\xbe\x07\x00\x00\x00\x00\x00\x00\x63\x07\x64\x07\x00\x00\x67\x07\x6c\x07\x00\x00\x00\x00\x60\x06\x00\x00\x00\x00\x00\x00\xe6\x07\x00\x00\xe7\x07\x00\x00\x00\x00\xc0\x05\x00\x00\x4d\x07\x74\x07\x00\x00\x00\x00\x1e\x19\x00\x00\x00\x00\xe9\x07\x00\x00\xec\x07\xd2\x03\xf4\x03\x00\x00\xc9\x05\xd4\x05\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x04\xc4\x04\xd8\x04\xe2\x04\xee\x07\x00\x00\x00\x00\xfc\xff\x00\x00\x00\x00\x00\x00\xc0\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xf1\x07\xf4\x07\x6e\x01\x00\x00\x00\x00\x00\x00\x00\x00\xe2\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfe\x07\xfb\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"# - -happyAdjustOffset :: Happy_GHC_Exts.Int# -> Happy_GHC_Exts.Int# -happyAdjustOffset off = off - -happyDefActions :: HappyAddr -happyDefActions = HappyA# "\xf6\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa6\xfe\x00\x00\xf8\xff\x67\xff\x6a\xff\x00\x00\x1d\xff\xa4\xfe\x4b\xff\x4a\xff\x48\xff\x47\xff\x44\xff\x00\x00\x1a\xff\x19\xff\x1e\xff\x40\xff\x00\x00\x00\x00\x0b\xff\x09\xff\xa3\xfe\x00\x00\x00\x00\x00\x00\x2f\xff\x2d\xff\x2b\xff\x00\x00\x2c\xff\x00\x00\x00\x00\x2e\xff\x00\x00\x2a\xff\x00\x00\x29\xff\x28\xff\x1f\xff\x00\x00\x00\x00\x30\xff\x31\xff\x00\x00\x00\x00\x50\xfe\x00\x00\x00\x00\x00\x00\x86\xff\x68\xff\x1c\xff\x00\x00\xa6\xfe\x00\x00\x7f\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x67\xff\x66\xff\x00\x00\x00\x00\x50\xfe\xa2\xfe\x00\x00\x00\x00\x00\x00\x9e\xfe\x00\x00\x00\x00\xf5\xfd\x9c\xfe\x9b\xfe\x9a\xfe\x99\xfe\x98\xfe\x97\xfe\x9d\xfe\x96\xfe\x95\xfe\x94\xfe\x93\xfe\x92\xfe\x91\xfe\x90\xfe\x8f\xfe\x88\xfe\x8a\xfe\x89\xfe\x00\x00\x8e\xfe\x8d\xfe\x8c\xfe\x8e\xff\x8b\xfe\x42\xfe\x2d\xfe\x41\xfe\x40\xfe\x3e\xfe\x3f\xfe\x3d\xfe\x3b\xfe\x3a\xfe\x3c\xfe\x32\xfe\x31\xfe\x36\xfe\x37\xfe\x38\xfe\x34\xfe\x33\xfe\x39\xfe\x30\xfe\x2f\xfe\x2e\xfe\x35\xfe\xf3\xfd\x43\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\x51\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x32\xff\x24\xff\x00\x00\x83\xff\x00\x00\x00\x00\x25\xff\x22\xff\xa2\xfe\x00\x00\x00\x00\x00\x00\xa8\xfe\x69\xff\x7f\xfe\x00\x00\x1d\xff\x00\x00\x61\xff\x60\xff\x00\x00\x00\x00\x30\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5b\xff\x00\x00\x00\x00\x00\x00\x00\x00\x51\xfe\x6d\xff\x00\x00\x65\xff\xd2\xfe\xea\xfe\x00\x00\x38\xff\x00\x00\xf5\xfe\xf2\xfe\xeb\xfe\x00\x00\x00\x00\x00\x00\x64\xff\x50\xfe\x00\x00\x35\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3e\xff\x37\xff\xa5\xfe\x00\x00\x18\xff\x00\x00\x3b\xff\x50\xfe\xd7\xfe\x00\x00\x00\x00\xd8\xfe\xd3\xfe\x50\xfe\x00\x00\x00\x00\x0a\xff\x00\x00\x50\xfe\x00\x00\x00\x00\x0c\xff\x4f\xff\x46\xff\x36\xff\x00\x00\x00\x00\x00\x00\x00\x00\xf7\xff\xf5\xff\xf4\xff\xf3\xff\xf2\xff\xf1\xff\xf0\xff\xef\xff\xee\xff\xed\xff\xec\xff\xeb\xff\xea\xff\xe9\xff\xe8\xff\xe7\xff\xe6\xff\xe5\xff\xe4\xff\xe3\xff\xe2\xff\xe1\xff\xe0\xff\xdf\xff\xde\xff\xdd\xff\xdc\xff\xdb\xff\xda\xff\xd9\xff\xd8\xff\xd7\xff\xd6\xff\xd5\xff\xd4\xff\xd3\xff\xd2\xff\xd1\xff\xd0\xff\xcf\xff\xce\xff\xcd\xff\xcc\xff\xcb\xff\xca\xff\xc9\xff\xc8\xff\xc7\xff\xc6\xff\xc5\xff\xc4\xff\xc3\xff\xc2\xff\xc1\xff\xc0\xff\xbf\xff\xbe\xff\xbd\xff\xbc\xff\xbb\xff\xba\xff\xb9\xff\xb8\xff\xb7\xff\xb6\xff\xb5\xff\xb1\xff\xb4\xff\xb3\xff\xb2\xff\xb0\xff\xaf\xff\xae\xff\xad\xff\xac\xff\xab\xff\xaa\xff\xa9\xff\xa8\xff\xa7\xff\xa6\xff\xa5\xff\xa4\xff\xa3\xff\xa2\xff\xa1\xff\xa0\xff\x9f\xff\x9e\xff\x9d\xff\x9c\xff\x9b\xff\x9a\xff\x99\xff\x98\xff\x97\xff\x96\xff\x95\xff\x94\xff\x93\xff\x92\xff\x91\xff\x90\xff\x23\xff\x00\x00\x4c\xff\x4e\xff\x00\x00\x60\xff\x40\xff\x00\x00\x5b\xff\x00\x00\x00\x00\x00\x00\x00\x00\x61\xff\x00\x00\x00\x00\x00\x00\x00\x00\x5b\xff\xda\xfe\xdb\xfe\x43\xff\xd9\xfe\x00\x00\x42\xff\x00\x00\x00\x00\x67\xff\x4c\xfe\x00\x00\x17\xff\x16\xff\x13\xff\x14\xff\x11\xff\x00\x00\xc1\xfe\x00\x00\xc5\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe4\xfe\x00\x00\x40\xff\xde\xfe\x00\x00\x00\x00\x35\xff\xe8\xfe\x00\x00\xe7\xfe\xe9\xfe\xd1\xfe\x00\x00\x00\x00\xd0\xfe\x00\x00\x00\x00\x35\xff\xf1\xfe\xed\xfe\xf2\xfe\x50\xfe\x00\x00\x00\x00\xf6\xfe\x45\xff\xec\xfe\x4c\xfe\x3b\xff\xfc\xfe\x01\xff\x02\xff\x00\x00\x00\x00\x26\xff\xff\xfe\x00\xff\x00\x00\xfd\xfe\xfe\xfe\x00\x00\x00\x00\x00\x00\xa2\xfe\xa9\xfe\x00\x00\x49\xff\x81\xfe\x80\xfe\x83\xfe\x1b\xff\x82\xff\x27\xff\x33\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\xff\x00\x00\x00\x00\x57\xff\x00\x00\x00\x00\x84\xff\x00\x00\x00\x00\x00\x00\x00\x00\xd4\xfe\xf8\xfd\x6d\xfe\x00\x00\x69\xfe\x12\xfe\x00\x00\x6a\xfe\x63\xfe\x00\x00\x6f\xfe\xd4\xfe\xd4\xfe\x44\xfe\x6b\xfe\x6c\xfe\x00\x00\x87\xff\x00\x00\x00\x00\x70\xfe\x08\xfe\x71\xfe\x6c\xff\xd4\xfe\xd4\xfe\x6e\xfe\x8f\xff\x8d\xff\x00\x00\x50\xfe\x8a\xff\xf6\xfd\xa1\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xf7\xfd\x4c\xfe\xd4\xfe\x00\x00\xd4\xfe\x00\x00\x00\x00\x00\x00\x0c\xfe\x00\x00\x00\x00\x6c\xff\x09\xfe\x00\x00\x62\xff\x74\xfe\x73\xfe\x72\xfe\x00\x00\x00\x00\xd4\xfe\x62\xfe\x00\x00\x13\xfe\x00\x00\x0f\xfe\x00\x00\x8b\xff\x8c\xff\xf9\xfd\x00\x00\x11\xff\x00\x00\x5f\xfe\x5d\xfe\x58\xfe\x00\x00\x00\x00\x00\x00\x52\xfe\x68\xfe\x00\x00\x00\x00\x85\xff\x1e\xfe\x00\x00\x51\xff\x50\xff\x00\x00\x57\xff\x00\x00\x16\xfe\x52\xff\x00\x00\x5a\xff\x1f\xfe\x19\xfe\x1a\xfe\x20\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x1b\xfe\x00\x00\x55\xff\x00\x00\x5a\xff\x1c\xfe\x00\x00\x00\x00\xa7\xfe\x82\xfe\x00\x00\x5f\xff\x5d\xff\xfa\xfe\x5e\xff\x5c\xff\x00\x00\xf8\xfe\xfb\xfe\x4c\xfe\xbd\xfe\x00\x00\xef\xfe\xee\xfe\xf0\xfe\xf4\xfe\xf3\xfe\xe4\xfe\xe2\xfe\xe1\xfe\xdc\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe3\xfe\x00\x00\x35\xff\x3a\xff\x89\xff\x35\xff\x34\xff\x00\x00\x08\xff\x06\xff\x07\xff\x05\xff\x03\xff\x04\xff\x00\x00\xc4\xfe\x41\xff\xc2\xfe\x00\x00\x3d\xff\x00\x00\x00\x00\x10\xff\x0f\xff\x00\x00\x21\xff\xbd\xfe\x00\x00\x3f\xff\x3c\xff\xfa\xfd\xcf\xfe\x00\x00\xcb\xfe\x00\x00\xcd\xfe\x61\xff\x4d\xff\xcc\xfe\xca\xfe\xce\xfe\x0d\xff\x12\xff\xbf\xfe\xbd\xfe\xbb\xfe\xba\xfe\xb9\xfe\x00\x00\xbc\xfe\x00\x00\x00\x00\x15\xff\x00\x00\x20\xff\x35\xff\xc3\xfe\xe6\xfe\xdf\xfe\xe0\xfe\x00\x00\xc8\xfe\xc9\xfe\xc6\xfe\xc7\xfe\x39\xff\x35\xff\x1f\xff\x4e\xfe\x4b\xfe\xf7\xfe\xf9\xfe\x00\x00\x00\x00\x00\x00\x21\xfe\x00\x00\x55\xff\x55\xff\x5a\xff\x23\xfe\x25\xfe\x24\xfe\x1d\xfe\x59\xff\x2c\xfe\x00\x00\x00\x00\x56\xff\x29\xfe\x26\xfe\x66\xfe\x67\xfe\x00\x00\x55\xfe\x00\x00\x00\x00\x55\xfe\x00\x00\x5e\xfe\x00\x00\x67\xff\x00\x00\x00\x00\x11\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x63\xff\x0b\xfe\x6c\xff\x00\x00\x84\xfe\x0e\xfe\x6c\xff\x7f\xff\x7b\xff\x6e\xff\x6b\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd6\xfe\x00\x00\x00\x00\xd5\xfe\xbd\xfe\xa0\xfe\x9f\xfe\x4f\xfe\x00\x00\x7b\xfe\x7a\xfe\x7c\xfe\x86\xfe\x7d\xff\x00\x00\x00\x00\x00\x00\x00\x00\x80\xff\x00\x00\x00\x00\x81\xff\x00\x00\x00\x00\x7c\xff\x0d\xfe\x00\x00\x0a\xfe\x45\xfe\x4c\xfe\xbd\xfe\x46\xfe\x00\x00\x64\xfe\x87\xfe\x10\xfe\x77\xfe\x78\xfe\x04\xfe\x65\xfe\x61\xfe\x00\x00\x00\x00\x00\x00\x5b\xfe\x00\x00\x00\x00\x00\x00\x5c\xfe\x17\xfe\x15\xfe\x18\xfe\x14\xfe\x00\x00\x54\xff\x00\x00\x28\xfe\x22\xfe\x2a\xfe\x2b\xfe\xbd\xfe\xdd\xfe\xe5\xfe\x00\x00\x0e\xff\xad\xfe\x88\xff\xad\xfe\xbe\xfe\xaf\xfe\xab\xfe\x00\x00\xac\xfe\x00\x00\x00\x00\x00\x00\xb3\xfe\x00\x00\x88\xff\xb5\xfe\x00\x00\xc0\xfe\x4d\xfe\x55\xff\x27\xfe\x00\x00\x55\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\xfe\x01\xfe\x00\x00\x02\xfe\xff\xfd\x00\xfe\x00\x00\xfb\xfd\x00\x00\xfe\xfd\xfc\xfd\x00\x00\xfd\xfd\x00\x00\xbd\xfe\x48\xfe\x49\xfe\x00\x00\x85\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x79\xff\x77\xff\x7e\xff\x00\x00\x00\x00\x7d\xfe\x7e\xfe\x78\xff\x7a\xff\x73\xff\x75\xff\x6f\xff\x71\xff\x1f\xff\x47\xfe\x79\xfe\x00\x00\x76\xfe\x05\xfe\x07\xfe\x50\xfe\x00\x00\x00\x00\x59\xfe\x54\xfe\x53\xfe\x5a\xfe\x53\xff\xb8\xfe\x00\x00\x00\x00\x88\xff\xb6\xfe\xb1\xfe\xae\xfe\xb7\xfe\x00\x00\xaa\xfe\xb4\xfe\xb2\xfe\xb0\xfe\x56\xfe\x57\xfe\x03\xfe\x00\x00\x00\x00\x4a\xfe\x72\xff\x70\xff\x76\xff\x74\xff\x00\x00\x06\xfe\x75\xfe"# - -happyCheck :: HappyAddr -happyCheck = HappyA# "\xff\xff\x05\x00\x05\x00\x15\x00\x0c\x00\x09\x00\x09\x00\x0a\x00\x0f\x00\x43\x00\x11\x00\x4f\x00\x10\x00\x4f\x00\x12\x00\x13\x00\x5e\x00\x09\x00\x0f\x00\x15\x00\x11\x00\x57\x00\x4f\x00\x5b\x00\x54\x00\x5d\x00\x00\x00\x13\x00\x09\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x09\x00\x27\x00\x28\x00\x15\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x63\x00\x65\x00\x24\x00\x25\x00\x09\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x09\x00\x09\x00\x13\x00\x14\x00\x13\x00\x14\x00\x53\x00\x52\x00\x2e\x00\x2e\x00\x13\x00\x13\x00\x14\x00\x09\x00\x0a\x00\x32\x00\x33\x00\x34\x00\x67\x00\x41\x00\x42\x00\x43\x00\x63\x00\x45\x00\x0f\x00\x57\x00\x11\x00\x63\x00\x0f\x00\x09\x00\x11\x00\x57\x00\x5a\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x62\x00\x60\x00\x13\x00\x61\x00\x63\x00\x4f\x00\x65\x00\x66\x00\x67\x00\x68\x00\x62\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\x4f\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x54\x00\x5f\x00\x7e\x00\x7f\x00\x5f\x00\x63\x00\x82\x00\x83\x00\x09\x00\x4f\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x09\x00\x5e\x00\x61\x00\xa3\x00\x84\x00\xa1\x00\x97\x00\x10\x00\x62\x00\x12\x00\x13\x00\x09\x00\x62\x00\x81\x00\x09\x00\xa5\x00\xad\x00\x63\x00\x84\x00\x2e\x00\x80\x00\x13\x00\x81\x00\x63\x00\x64\x00\x22\x00\x23\x00\x24\x00\x25\x00\x2e\x00\x27\x00\x28\x00\x15\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x52\x00\x24\x00\x25\x00\x55\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x4e\x00\x80\x00\x09\x00\x4e\x00\x13\x00\x57\x00\x58\x00\x59\x00\x33\x00\x34\x00\x09\x00\x2e\x00\x13\x00\x4e\x00\x09\x00\x5d\x00\x4b\x00\x4c\x00\x5e\x00\x41\x00\x42\x00\x43\x00\x15\x00\x45\x00\x00\x00\x07\x00\x15\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x09\x00\x25\x00\x5a\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x60\x00\x63\x00\x13\x00\x63\x00\x4e\x00\x65\x00\x66\x00\x67\x00\x68\x00\x67\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\x63\x00\x64\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x09\x00\x7e\x00\x7f\x00\x0c\x00\x0d\x00\x82\x00\x83\x00\x55\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x09\x00\x4d\x00\x54\x00\x55\x00\x56\x00\x97\x00\x09\x00\x10\x00\x4e\x00\x12\x00\x13\x00\x09\x00\x57\x00\x80\x00\x59\x00\x5e\x00\xad\x00\xae\x00\x15\x00\x5f\x00\x60\x00\x13\x00\x5b\x00\x5d\x00\x5d\x00\x22\x00\x23\x00\x24\x00\x25\x00\x50\x00\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x50\x00\x24\x00\x25\x00\x4e\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x63\x00\x09\x00\x80\x00\x09\x00\x13\x00\x38\x00\x0a\x00\x5d\x00\x63\x00\x64\x00\x56\x00\x13\x00\x3f\x00\x13\x00\x5a\x00\x62\x00\x5c\x00\x0b\x00\x65\x00\x41\x00\x42\x00\x43\x00\x49\x00\x4a\x00\x07\x00\x28\x00\x1e\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x5f\x00\x24\x00\x5a\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2c\x00\x60\x00\x63\x00\x2d\x00\x63\x00\x63\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\x57\x00\x58\x00\x59\x00\x09\x00\x78\x00\x5e\x00\x77\x00\x7e\x00\x7f\x00\x7d\x00\x5e\x00\x82\x00\x83\x00\x13\x00\x14\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x66\x00\x54\x00\x55\x00\x56\x00\x50\x00\x97\x00\x11\x00\x12\x00\x09\x00\x4d\x00\xa7\x00\xa8\x00\xa9\x00\xaa\x00\x5e\x00\x10\x00\xad\x00\x12\x00\x13\x00\x09\x00\x80\x00\x5e\x00\x09\x00\x63\x00\x64\x00\x5d\x00\x4d\x00\x09\x00\x60\x00\x13\x00\x5e\x00\x4d\x00\x13\x00\x22\x00\x23\x00\x24\x00\x25\x00\x13\x00\x27\x00\x28\x00\x2e\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x60\x00\x24\x00\x25\x00\x50\x00\x27\x00\x60\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2b\x00\x2c\x00\x28\x00\x4d\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x4b\x00\x4c\x00\x50\x00\x63\x00\x64\x00\x4b\x00\x4c\x00\x50\x00\x50\x00\x54\x00\x50\x00\x41\x00\x42\x00\x43\x00\x60\x00\x5a\x00\x56\x00\x5c\x00\x09\x00\x63\x00\x5a\x00\x63\x00\x5c\x00\x09\x00\x63\x00\x5a\x00\x63\x00\x63\x00\x13\x00\x63\x00\x10\x00\x60\x00\x5e\x00\x13\x00\x63\x00\x5e\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\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x09\x00\x7e\x00\x7f\x00\x0c\x00\x0d\x00\x82\x00\x83\x00\x15\x00\x16\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x09\x00\x0f\x00\x4e\x00\x11\x00\x5d\x00\x97\x00\x4e\x00\x10\x00\x09\x00\x12\x00\x13\x00\xa8\x00\xa9\x00\xaa\x00\x09\x00\x5b\x00\xad\x00\x5d\x00\x13\x00\x5b\x00\x09\x00\x5d\x00\x4e\x00\x4f\x00\x13\x00\x22\x00\x23\x00\x24\x00\x25\x00\x09\x00\x27\x00\x28\x00\x15\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x7a\x00\x7b\x00\x13\x00\x7d\x00\x24\x00\x25\x00\x09\x00\x27\x00\x19\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x4b\x00\x4c\x00\x13\x00\x14\x00\x5d\x00\x24\x00\x25\x00\x57\x00\x27\x00\x54\x00\x30\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x5a\x00\x38\x00\x5c\x00\x4f\x00\x41\x00\x42\x00\x43\x00\x1c\x00\x3f\x00\x63\x00\x56\x00\x20\x00\x09\x00\x3b\x00\x5a\x00\x5a\x00\x5c\x00\x4f\x00\x49\x00\x4a\x00\x4e\x00\x60\x00\x13\x00\x63\x00\x63\x00\x5d\x00\x65\x00\x66\x00\x67\x00\x68\x00\x5d\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\x4f\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x59\x00\x09\x00\x7e\x00\x7f\x00\x0c\x00\x0d\x00\x82\x00\x83\x00\x63\x00\x64\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x09\x00\x11\x00\x12\x00\x09\x00\x4e\x00\x50\x00\x09\x00\x10\x00\x97\x00\x12\x00\x13\x00\x56\x00\x09\x00\x13\x00\x57\x00\x5a\x00\xad\x00\x5c\x00\x15\x00\x63\x00\x64\x00\x57\x00\x13\x00\x14\x00\x63\x00\x22\x00\x23\x00\x24\x00\x25\x00\x57\x00\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x2b\x00\x2c\x00\x10\x00\x56\x00\x12\x00\x13\x00\x5e\x00\x5a\x00\x5a\x00\x5c\x00\x5c\x00\x19\x00\x09\x00\x2f\x00\x30\x00\x31\x00\x38\x00\x63\x00\x34\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x15\x00\x27\x00\x28\x00\x52\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x48\x00\x49\x00\x4a\x00\x11\x00\x12\x00\x4b\x00\x4c\x00\x35\x00\x36\x00\x37\x00\x38\x00\x61\x00\x5a\x00\x3b\x00\x3c\x00\x65\x00\x56\x00\x5e\x00\x60\x00\x5c\x00\x5a\x00\x63\x00\x5c\x00\x65\x00\x66\x00\x67\x00\x68\x00\x38\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\x46\x00\x47\x00\x55\x00\x49\x00\x4a\x00\x63\x00\x64\x00\x7e\x00\x7f\x00\x00\x00\x01\x00\x82\x00\x83\x00\x37\x00\x38\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x09\x00\x7e\x00\x7f\x00\x52\x00\x5a\x00\x0c\x00\x5c\x00\x10\x00\x09\x00\x12\x00\x13\x00\x52\x00\x50\x00\x63\x00\x17\x00\x18\x00\xad\x00\x0c\x00\x56\x00\x5d\x00\x15\x00\x16\x00\x5a\x00\x57\x00\x5c\x00\x57\x00\x56\x00\x24\x00\x25\x00\x09\x00\x27\x00\x63\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x09\x00\x09\x00\x63\x00\x64\x00\x15\x00\x66\x00\x09\x00\x10\x00\x4f\x00\x12\x00\x13\x00\x39\x00\x3a\x00\x15\x00\x16\x00\x18\x00\x19\x00\x5d\x00\x15\x00\x41\x00\x42\x00\x09\x00\x44\x00\x4d\x00\x0c\x00\x09\x00\x0e\x00\x24\x00\x25\x00\x63\x00\x27\x00\x09\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x15\x00\x10\x00\x38\x00\x12\x00\x13\x00\xab\x00\xac\x00\x15\x00\x16\x00\x3f\x00\x19\x00\x2e\x00\x09\x00\x3b\x00\x3c\x00\x0c\x00\x38\x00\x0e\x00\x52\x00\x49\x00\x4a\x00\x24\x00\x25\x00\x3f\x00\x27\x00\x09\x00\x5d\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x09\x00\x09\x00\x49\x00\x4a\x00\x38\x00\x57\x00\x15\x00\x10\x00\x57\x00\x12\x00\x13\x00\x13\x00\x14\x00\x3b\x00\x3c\x00\x09\x00\xab\x00\xac\x00\x0c\x00\x47\x00\x0e\x00\x49\x00\x4a\x00\x5d\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\x52\x00\x27\x00\x28\x00\x32\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x97\x00\x79\x00\x7a\x00\x7b\x00\x38\x00\x7d\x00\x52\x00\x35\x00\x36\x00\x37\x00\x38\x00\x56\x00\x7e\x00\x7f\x00\x52\x00\x5a\x00\x52\x00\x5c\x00\x52\x00\x47\x00\x4e\x00\x49\x00\x4a\x00\x09\x00\x63\x00\x09\x00\x0c\x00\x62\x00\x0e\x00\x09\x00\x10\x00\x00\x00\x01\x00\x02\x00\x4e\x00\x04\x00\x05\x00\x15\x00\x07\x00\x08\x00\x09\x00\x15\x00\x0b\x00\x7e\x00\x7f\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x5f\x00\x13\x00\x14\x00\x15\x00\x16\x00\x4f\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x65\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xab\x00\xac\x00\x26\x00\x27\x00\x28\x00\x38\x00\x2a\x00\x2b\x00\x2c\x00\x38\x00\x65\x00\x2f\x00\x3f\x00\x65\x00\x3d\x00\x3e\x00\x3f\x00\x40\x00\xab\x00\xac\x00\xab\x00\xac\x00\x49\x00\x4a\x00\xab\x00\xac\x00\x49\x00\x4a\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x46\x00\x47\x00\x4b\x00\x4c\x00\x4a\x00\x65\x00\x4c\x00\x9f\x00\xa0\x00\x62\x00\x50\x00\x51\x00\x4f\x00\x53\x00\x54\x00\x65\x00\x56\x00\x5a\x00\x58\x00\x5c\x00\x5a\x00\x62\x00\x5c\x00\xab\x00\xac\x00\x5f\x00\x63\x00\x61\x00\x2e\x00\x63\x00\x64\x00\x09\x00\x66\x00\x00\x00\x01\x00\x02\x00\x09\x00\x0a\x00\x05\x00\x65\x00\x07\x00\x08\x00\x09\x00\x15\x00\x0b\x00\x09\x00\x0a\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x62\x00\x13\x00\x14\x00\x15\x00\x16\x00\x62\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x62\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x09\x00\x0a\x00\x26\x00\x27\x00\x28\x00\x65\x00\x2a\x00\x2b\x00\x2c\x00\x38\x00\x65\x00\x2f\x00\x09\x00\x4b\x00\x4c\x00\x0c\x00\x09\x00\x0e\x00\x50\x00\x0c\x00\x52\x00\x0e\x00\xab\x00\xac\x00\x56\x00\x48\x00\x49\x00\x4a\x00\x5a\x00\x65\x00\x5c\x00\xab\x00\xac\x00\x65\x00\x46\x00\x47\x00\x09\x00\x63\x00\x4a\x00\x0c\x00\x4c\x00\x0e\x00\x7c\x00\x7d\x00\x50\x00\x51\x00\x09\x00\x53\x00\x54\x00\x0c\x00\x56\x00\x0e\x00\x58\x00\x65\x00\x5a\x00\x62\x00\x5c\x00\x7c\x00\x7d\x00\x5f\x00\x09\x00\x61\x00\x63\x00\x63\x00\x64\x00\x09\x00\x66\x00\x01\x00\x02\x00\x05\x00\x06\x00\x05\x00\x15\x00\x07\x00\x08\x00\x09\x00\x63\x00\x15\x00\x05\x00\x06\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x2e\x00\x13\x00\x14\x00\x15\x00\x16\x00\x5e\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x4e\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x05\x00\x06\x00\x26\x00\x27\x00\x28\x00\x38\x00\x2a\x00\x2b\x00\x2c\x00\x5e\x00\x38\x00\x2f\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x05\x00\x06\x00\x2e\x00\x48\x00\x49\x00\x4a\x00\xab\x00\xac\x00\x48\x00\x49\x00\x4a\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x46\x00\x47\x00\x09\x00\x0a\x00\x4a\x00\x4f\x00\x4c\x00\xab\x00\xac\x00\x4e\x00\x50\x00\x51\x00\x53\x00\x53\x00\x54\x00\x62\x00\x56\x00\x62\x00\x58\x00\x65\x00\x5a\x00\x62\x00\x5c\x00\xab\x00\xac\x00\x5f\x00\x66\x00\x61\x00\x65\x00\x63\x00\x64\x00\x62\x00\x66\x00\x67\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\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\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\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x62\x00\x0b\x00\x62\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x62\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x65\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xab\x00\xac\x00\x26\x00\x27\x00\x28\x00\x62\x00\x2a\x00\x2b\x00\x2c\x00\x4b\x00\x4c\x00\x2f\x00\x65\x00\x09\x00\x50\x00\x65\x00\x52\x00\x09\x00\x0a\x00\x52\x00\x56\x00\x09\x00\x0a\x00\x5e\x00\x5a\x00\x15\x00\x5c\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x63\x00\x46\x00\x47\x00\x09\x00\x0a\x00\x4a\x00\x4f\x00\x4c\x00\x7c\x00\x7d\x00\x5d\x00\x50\x00\x51\x00\x4d\x00\x53\x00\x54\x00\x57\x00\x56\x00\x5d\x00\x58\x00\x56\x00\x5a\x00\x63\x00\x5c\x00\x7c\x00\x7d\x00\x56\x00\x38\x00\x61\x00\x56\x00\x63\x00\x64\x00\x5b\x00\x66\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x48\x00\x49\x00\x4a\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x62\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x62\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x05\x00\x06\x00\x26\x00\x27\x00\x28\x00\x62\x00\x2a\x00\x2b\x00\x2c\x00\x4b\x00\x4c\x00\x2f\x00\x4b\x00\x4c\x00\x50\x00\x05\x00\x06\x00\x50\x00\x62\x00\x65\x00\x56\x00\xab\x00\xac\x00\x56\x00\x5a\x00\x62\x00\x5c\x00\x5a\x00\x5d\x00\x5c\x00\xab\x00\xac\x00\x4f\x00\x63\x00\x46\x00\x47\x00\x63\x00\x4f\x00\x4a\x00\x63\x00\x4c\x00\xab\x00\xac\x00\x5e\x00\x50\x00\x51\x00\x63\x00\x53\x00\x54\x00\x4f\x00\x56\x00\x5e\x00\x58\x00\x4e\x00\x5a\x00\x5e\x00\x5c\x00\x2e\x00\x2e\x00\x5d\x00\x09\x00\x61\x00\x63\x00\x63\x00\x64\x00\x2e\x00\x66\x00\x01\x00\x02\x00\x52\x00\x63\x00\x05\x00\x15\x00\x07\x00\x08\x00\x09\x00\x52\x00\x0b\x00\x52\x00\x52\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x62\x00\x13\x00\x14\x00\x15\x00\x16\x00\x62\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x57\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x4d\x00\x63\x00\x26\x00\x27\x00\x28\x00\x38\x00\x2a\x00\x2b\x00\x2c\x00\x4b\x00\x4c\x00\x2f\x00\x57\x00\x09\x00\x50\x00\x4d\x00\x29\x00\x57\x00\x63\x00\x5d\x00\x56\x00\x48\x00\x49\x00\x4a\x00\x5a\x00\x15\x00\x5c\x00\x5b\x00\x63\x00\x5e\x00\x63\x00\x5e\x00\x5d\x00\x63\x00\x46\x00\x47\x00\x5d\x00\x57\x00\x4a\x00\x5e\x00\x4c\x00\x57\x00\x15\x00\x63\x00\x50\x00\x51\x00\x63\x00\x53\x00\x54\x00\x03\x00\x56\x00\x5f\x00\x58\x00\x01\x00\x5a\x00\x02\x00\x5c\x00\xab\x00\x09\x00\x5c\x00\x38\x00\x61\x00\x64\x00\x63\x00\x64\x00\x5e\x00\x66\x00\x01\x00\x02\x00\x06\x00\x09\x00\x05\x00\x04\x00\x07\x00\x08\x00\x09\x00\x48\x00\x49\x00\x4a\x00\x09\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\xa2\x00\x13\x00\x14\x00\x15\x00\x16\x00\x08\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\xa4\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x08\x00\x08\x00\x26\x00\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x4b\x00\x4c\x00\x2f\x00\x4b\x00\x4c\x00\x50\x00\x09\x00\x0b\x00\x50\x00\x09\x00\x5e\x00\x56\x00\x5b\x00\x64\x00\x56\x00\x5a\x00\x0b\x00\x5c\x00\x5a\x00\x0b\x00\x5c\x00\x15\x00\x0b\x00\xab\x00\x63\x00\x46\x00\x47\x00\x63\x00\x26\x00\x4a\x00\x05\x00\x4c\x00\x05\x00\x4d\x00\x06\x00\x50\x00\x51\x00\x08\x00\x53\x00\x54\x00\x09\x00\x56\x00\x06\x00\x58\x00\x0b\x00\x5a\x00\x0b\x00\x5c\x00\x13\x00\x06\x00\x13\x00\x14\x00\x61\x00\x18\x00\x63\x00\x64\x00\x38\x00\x66\x00\x1d\x00\x26\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x5e\x00\x1a\x00\x26\x00\x1f\x00\x28\x00\x1f\x00\x2a\x00\x48\x00\x49\x00\x4a\x00\x1f\x00\x2f\x00\x2e\x00\x2f\x00\x30\x00\x31\x00\x1f\x00\x1e\x00\x34\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x1e\x00\x09\x00\x1f\x00\x46\x00\x47\x00\x1f\x00\xa2\x00\x4a\x00\x4b\x00\x4c\x00\x1c\x00\x1a\x00\x9d\x00\x50\x00\x51\x00\x08\x00\x53\x00\x54\x00\x1f\x00\x56\x00\x57\x00\x58\x00\x1d\x00\x5a\x00\x1a\x00\x5c\x00\x13\x00\x1f\x00\x1f\x00\x0b\x00\x0b\x00\x0b\x00\x63\x00\x64\x00\x09\x00\x66\x00\x1d\x00\x0b\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x1d\x00\x13\x00\x26\x00\x1d\x00\x28\x00\x1a\x00\x2a\x00\x19\x00\x9e\x00\x7d\x00\x7d\x00\x2f\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x24\x00\x25\x00\xa6\x00\x27\x00\x09\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x09\x00\x09\x00\x07\x00\x7d\x00\x0b\x00\x09\x00\x46\x00\x47\x00\x09\x00\x1d\x00\x4a\x00\x4b\x00\x4c\x00\x3b\x00\x7d\x00\x7d\x00\x50\x00\x51\x00\x7d\x00\x53\x00\x54\x00\x08\x00\x56\x00\x7d\x00\x58\x00\x05\x00\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x09\x00\x09\x00\x13\x00\xa6\x00\x0b\x00\x63\x00\x64\x00\x0b\x00\x66\x00\x0b\x00\x09\x00\x13\x00\x1d\x00\x09\x00\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\x05\x00\x09\x00\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\x22\x00\x23\x00\x24\x00\x25\x00\x2f\x00\x27\x00\x28\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\x5c\x00\x5d\x00\xff\xff\x09\x00\x13\x00\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\x13\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\x23\x00\x24\x00\x25\x00\x2f\x00\x27\x00\x28\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\x5c\x00\x5d\x00\xff\xff\x09\x00\x13\x00\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\x13\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\x23\x00\x24\x00\x25\x00\x2f\x00\x27\x00\x28\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\x5c\x00\x5d\x00\xff\xff\x09\x00\x13\x00\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\x13\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\x24\x00\x25\x00\x2f\x00\x27\x00\x28\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\x5c\x00\x5d\x00\xff\xff\x09\x00\x13\x00\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\x13\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\x25\x00\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\x24\x00\x25\x00\x2f\x00\x27\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x08\x00\x53\x00\x54\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\x09\x00\x66\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\x13\x00\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\x25\x00\xff\xff\x27\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x5d\x00\xff\xff\x09\x00\x13\x00\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\x13\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\x24\x00\x25\x00\x2f\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x08\x00\x53\x00\x54\x00\xff\xff\x56\x00\x57\x00\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\x2f\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\xff\xff\xff\xff\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\xff\xff\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x5d\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\x63\x00\x64\x00\x18\x00\x66\x00\xff\xff\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\x2f\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\xff\xff\xff\xff\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\xff\xff\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x08\x00\x53\x00\x54\x00\xff\xff\x56\x00\x57\x00\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\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\xff\xff\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\x5c\x00\x5d\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x5d\x00\xff\xff\xff\xff\x13\x00\x61\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x08\x00\x53\x00\x54\x00\xff\xff\x56\x00\x57\x00\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x5d\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\x63\x00\x64\x00\x18\x00\x66\x00\xff\xff\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x08\x00\x53\x00\x54\x00\xff\xff\x56\x00\x57\x00\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\x5c\x00\x5d\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x08\x00\x53\x00\x54\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x08\x00\x55\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x08\x00\x53\x00\x54\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\x63\x00\x64\x00\xff\xff\x66\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x08\x00\x53\x00\x54\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\x63\x00\x64\x00\xff\xff\x66\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x08\x00\x53\x00\x54\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x08\x00\x53\x00\x54\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x5d\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x08\x00\x53\x00\x54\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x08\x00\x53\x00\x54\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x08\x00\x53\x00\x54\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x08\x00\x53\x00\x54\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x08\x00\x53\x00\x54\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x08\x00\x53\x00\x54\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x08\x00\x53\x00\x54\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x08\x00\x53\x00\x54\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x08\x00\x53\x00\x54\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x08\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x08\x00\x53\x00\xff\xff\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x13\x00\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x08\x00\x53\x00\x54\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x08\x00\x53\x00\xff\xff\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x13\x00\xff\xff\xff\xff\xff\xff\x61\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x08\x00\x53\x00\xff\xff\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x08\x00\x53\x00\xff\xff\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x08\x00\x53\x00\xff\xff\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x08\x00\x53\x00\xff\xff\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x08\x00\x53\x00\xff\xff\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2f\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x09\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x10\x00\x5c\x00\x12\x00\x13\x00\xff\xff\xff\xff\x09\x00\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x09\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x10\x00\x5a\x00\x2a\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x5c\x00\x5d\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\xff\xff\x54\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x09\x00\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\x63\x00\x64\x00\x13\x00\x66\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x19\x00\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\x5a\x00\xff\xff\x2a\x00\xff\xff\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\xff\xff\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\x47\x00\x63\x00\x64\x00\x4a\x00\x66\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\x1d\x00\x66\x00\x1f\x00\x20\x00\xff\xff\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\xff\xff\xff\xff\x2a\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\x1d\x00\xff\xff\x1f\x00\x20\x00\xff\xff\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\x47\x00\x63\x00\x64\x00\x4a\x00\x66\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\x1d\x00\x66\x00\x1f\x00\x20\x00\xff\xff\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\xff\xff\xff\xff\x2a\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\x1d\x00\xff\xff\x1f\x00\x20\x00\xff\xff\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\x47\x00\x63\x00\x64\x00\x4a\x00\x66\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\x1d\x00\x66\x00\x1f\x00\x20\x00\xff\xff\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\xff\xff\xff\xff\x2a\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\x1d\x00\xff\xff\x1f\x00\x20\x00\xff\xff\x22\x00\x23\x00\xff\xff\xff\xff\x26\x00\xff\xff\xff\xff\xff\xff\x2a\x00\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\x47\x00\x63\x00\x64\x00\x4a\x00\x66\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\xff\xff\x5c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x63\x00\x64\x00\x1d\x00\x66\x00\x1f\x00\x20\x00\x10\x00\x22\x00\x23\x00\x13\x00\xff\xff\x26\x00\xff\xff\x17\x00\x18\x00\x2a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\xff\xff\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\xff\xff\x09\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x10\x00\x5c\x00\x12\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\x63\x00\x64\x00\xff\xff\x66\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\x09\x00\x3b\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x3a\x00\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\x25\x00\xff\xff\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x09\x00\xff\xff\x0b\x00\xff\xff\x32\x00\x33\x00\x34\x00\x10\x00\xff\xff\x12\x00\x13\x00\x39\x00\x3a\x00\xff\xff\x17\x00\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\x25\x00\xff\xff\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x09\x00\xff\xff\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\x39\x00\x3a\x00\xff\xff\x17\x00\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\x25\x00\xff\xff\x27\x00\x09\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\xff\xff\x39\x00\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\x25\x00\xff\xff\x27\x00\x09\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\xff\xff\x39\x00\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\x25\x00\xff\xff\x27\x00\x09\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\xff\xff\x39\x00\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\x25\x00\xff\xff\x27\x00\x09\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\xff\xff\x39\x00\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\x25\x00\xff\xff\x27\x00\x09\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\xff\xff\x39\x00\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\x25\x00\xff\xff\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x09\x00\xff\xff\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\x39\x00\x3a\x00\xff\xff\x17\x00\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x13\x00\x09\x00\xff\xff\xff\xff\x17\x00\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x24\x00\x25\x00\xff\xff\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x24\x00\x25\x00\x09\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x39\x00\xff\xff\x13\x00\x09\x00\xff\xff\xff\xff\x17\x00\x18\x00\xff\xff\xff\xff\xff\xff\x39\x00\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x24\x00\x25\x00\xff\xff\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x24\x00\x25\x00\x09\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x39\x00\xff\xff\x13\x00\x09\x00\xff\xff\xff\xff\x17\x00\x18\x00\xff\xff\xff\xff\xff\xff\x39\x00\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x24\x00\x25\x00\xff\xff\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x24\x00\x25\x00\x09\x00\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x39\x00\xff\xff\x13\x00\x09\x00\xff\xff\xff\xff\x17\x00\x18\x00\xff\xff\xff\xff\xff\xff\x39\x00\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x24\x00\x25\x00\xff\xff\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x24\x00\x25\x00\xff\xff\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\x39\x00\xff\xff\xff\xff\x09\x00\xff\xff\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\x39\x00\x12\x00\x13\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\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\x09\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\x25\x00\xff\xff\x27\x00\x28\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\xff\xff\x35\x00\x36\x00\x37\x00\x38\x00\x10\x00\xff\xff\xff\xff\x13\x00\x09\x00\xff\xff\xff\xff\x17\x00\x18\x00\xff\xff\xff\xff\x10\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x24\x00\x25\x00\xff\xff\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x24\x00\x25\x00\xff\xff\x27\x00\x09\x00\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x10\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\xff\xff\x13\x00\x24\x00\x25\x00\xff\xff\x27\x00\x18\x00\x19\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\x25\x00\x10\x00\x27\x00\xff\xff\x13\x00\x2a\x00\x2b\x00\x2c\x00\x2d\x00\xff\xff\x19\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x24\x00\x25\x00\xff\xff\x27\x00\xff\xff\xff\xff\x2a\x00\x2b\x00\x2c\x00\x2d\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\xff\xff\xff\xff\xff\xff\xff\xff"# - -happyTable :: HappyAddr -happyTable = HappyA# "\x00\x00\x17\x02\x11\x02\x29\x03\x71\x01\x09\x00\xcf\x01\x12\x02\x00\x02\x40\x02\x01\x02\x48\xff\x0a\x00\x48\xff\x3b\x00\x0c\x00\x49\x00\x09\x00\x00\x02\x2e\x03\x01\x02\x48\xff\xd3\x01\x48\xff\xf0\x00\x48\xff\x16\x02\x0c\x00\x71\x02\x16\x02\x3c\x00\x0f\x00\x10\x00\x11\x00\xf6\x01\x12\x00\x3d\x00\x4f\x00\x14\x00\x15\x00\x16\x00\x17\x00\x39\x00\x41\x02\x54\x02\x11\x00\x44\x00\x12\x00\x44\x00\x85\x01\x14\x00\x15\x00\x16\x00\x86\x01\x09\x00\x44\x00\x45\x00\xfc\x02\x45\x00\xdf\x01\xbd\x02\xe9\x00\x50\x00\xcb\x02\x0c\x00\x45\x00\xfc\x02\xcf\x01\x12\x02\x72\x02\x73\x02\x74\x02\xff\xff\x55\x02\x56\x02\x57\x02\x22\x02\x58\x02\x00\x02\x4c\x02\x01\x02\x39\x00\x00\x02\x09\x00\x01\x02\x2f\x03\x3e\x00\x14\x00\x15\x00\x16\x00\x4c\x02\x02\x02\x50\x00\x0c\x00\x13\x02\x51\x00\xcc\x02\x52\x00\x53\x00\x54\x00\x55\x00\x06\x02\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\x79\x02\x14\x00\x15\x00\x16\x00\x4c\x02\xf0\x00\x17\x02\x63\x00\x64\x00\x17\x02\x39\x00\x65\x00\x66\x00\x24\x03\xee\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\x09\x00\xdb\x00\x02\x03\x03\x02\xf7\x01\x14\x02\x8a\x01\x0a\x00\xfa\x02\x3b\x00\x0c\x00\x09\x00\xf8\x02\xfd\x02\x71\x02\x07\x02\x6e\x01\x39\x00\xe0\x01\xe1\x02\x77\x02\x0c\x00\x49\x03\x39\x00\x3a\x00\x3c\x00\x0f\x00\x10\x00\x11\x00\xde\x02\x12\x00\x3d\x00\xde\x01\x14\x00\x15\x00\x16\x00\x17\x00\xed\x00\x54\x02\x11\x00\xa4\x00\x12\x00\x09\x00\x85\x01\x14\x00\x15\x00\x16\x00\x86\x01\x60\xff\x4d\x02\x09\x00\xe2\x02\x0c\x00\x25\x03\x2f\x03\x27\x03\x1f\x03\x74\x02\xbc\x00\xc4\x02\x0c\x00\xdf\x02\xbc\x00\x60\xff\xef\x02\xf0\x02\xd3\x00\x55\x02\x56\x02\x57\x02\x92\x01\x1e\x03\x16\x02\x29\x03\x8f\x01\x14\x00\x15\x00\x16\x00\x4c\x02\x09\x00\x27\x00\x3e\x00\x24\x03\x14\x00\x15\x00\x16\x00\x9f\x00\x50\x00\x39\x00\x0c\x00\x51\x00\xc5\x02\x52\x00\x53\x00\x54\x00\x55\x00\xff\xff\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\x39\x00\x3a\x00\x14\x00\x15\x00\x16\x00\x4c\x02\xd4\x02\x63\x00\x64\x00\xec\x02\xf0\x02\x65\x00\x66\x00\xa4\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\x09\x00\xf4\x01\x2a\x03\x2b\x03\x2c\x03\x8a\x01\xbc\x00\x0a\x00\xad\x01\x3b\x00\x0c\x00\x09\x00\x25\x03\xe3\x02\x77\x03\xd8\x01\x7f\x00\x80\x00\xbd\x00\x17\x02\x62\x02\x0c\x00\x9c\x00\x9e\x02\x9d\x00\x3c\x00\x0f\x00\x10\x00\x11\x00\xe2\x01\x12\x00\x3d\x00\x24\x03\x14\x00\x15\x00\x16\x00\x17\x00\xe2\x01\x54\x02\x11\x00\xad\x01\x12\x00\x09\x00\x85\x01\x14\x00\x15\x00\x16\x00\x86\x01\x39\x00\x09\x00\xa2\x02\x44\x00\x0c\x00\x96\x01\x8e\x02\x9c\x02\x39\x00\x3a\x00\xd0\x00\x0c\x00\x0f\x02\x0c\x00\xd1\x00\x13\x03\xd2\x00\xf2\x01\x14\x03\x55\x02\x56\x02\x98\x02\x98\x01\xdf\x00\x29\x03\xd3\x00\x8f\x02\x14\x00\x15\x00\x16\x00\xd4\x00\xf1\x01\x90\x02\x3e\x00\x14\x00\x15\x00\x16\x00\x4c\x02\xba\x00\x50\x00\x39\x00\x91\x02\x51\x00\x39\x00\x52\x00\x53\x00\x54\x00\x55\x00\x3c\x03\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\x25\x03\x26\x03\x27\x03\x44\x00\x06\x03\xd8\x01\x10\x02\x63\x00\x64\x00\x07\x03\xec\x01\x65\x00\x66\x00\x45\x00\x46\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\xe6\x01\x78\x03\x2b\x03\x2c\x03\x49\x02\x8a\x01\x05\x02\x06\x02\x09\x00\xf4\x01\x3d\x03\x3e\x03\x3f\x03\x40\x03\xea\x01\x0a\x00\x41\x03\x3b\x00\x0c\x00\x09\x00\x4b\x03\xd8\x01\x09\x00\x39\x00\x3a\x00\x61\x02\xf4\x01\x09\x00\x62\x02\x0c\x00\xd8\x01\xf4\x01\x0c\x00\x3c\x00\x0f\x00\x10\x00\x11\x00\x0c\x00\x12\x00\x3d\x00\xc6\x00\x14\x00\x15\x00\x16\x00\x17\x00\xf5\x01\x54\x02\x11\x00\x46\x02\x12\x00\x6d\x02\x85\x01\x14\x00\x15\x00\x16\x00\x86\x01\xd6\x00\x16\x00\xeb\x00\xf4\x01\x14\x00\x15\x00\x16\x00\xd4\x00\x6c\xff\x6c\xff\xc9\x00\x39\x00\x3a\x00\xc7\x00\xc8\x00\x0e\x03\x0a\x03\x6c\xff\xc9\x00\x55\x02\x56\x02\x97\x02\x62\x02\x6c\xff\xca\x00\x6c\xff\x44\x00\x39\x00\xcb\x00\x39\x00\xcc\x00\x09\x00\x6c\xff\x3e\x00\x22\x02\x22\x02\x47\x02\x39\x00\xa5\x00\x50\x00\xdb\x01\x0c\x00\x51\x00\xd8\x01\x52\x00\x53\x00\x54\x00\x55\x00\x3c\x03\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\xee\x00\xbc\x00\x14\x00\x15\x00\x16\x00\xd4\x00\xd4\x02\x63\x00\x64\x00\xec\x02\xed\x02\x65\x00\x66\x00\x08\x02\x0b\x02\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\x09\x00\xd0\x02\xad\x01\x01\x02\xba\x01\x8a\x01\x44\x02\x0a\x00\x44\x00\x3b\x00\x0c\x00\x7d\x03\x3f\x03\x40\x03\x09\x00\x9c\x00\x7e\x03\x9d\x00\x44\x02\x9c\x00\xbc\x00\x9d\x00\xa2\x00\xa3\x00\x0c\x00\x3c\x00\x0f\x00\x10\x00\x11\x00\x09\x00\x12\x00\x3d\x00\xbd\x00\x14\x00\x15\x00\x16\x00\x17\x00\xc0\x02\x1c\x02\x0c\x00\x1d\x02\x54\x02\x11\x00\x44\x00\x12\x00\xb3\x00\x85\x01\x14\x00\x15\x00\x16\x00\x86\x01\xd9\x02\xda\x02\x45\x00\x9f\x01\xb8\x01\x5f\x01\x11\x00\xb7\x01\x12\x00\x34\x00\xb2\x01\x14\x00\x15\x00\x16\x00\x5d\x01\xdb\x02\x96\x01\xdc\x02\xc2\x02\x55\x02\x56\x02\x1c\x03\x29\x02\x9e\x01\x39\x00\x1f\x02\x2a\x02\x09\x00\x80\x01\x20\x02\x3e\x00\x21\x02\xae\x01\x98\x01\xdf\x00\xad\x01\x50\x00\x0c\x00\x22\x02\x51\x00\xac\x01\x52\x00\x53\x00\x54\x00\x55\x00\xab\x01\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\xaa\x01\x14\x00\x15\x00\x16\x00\x57\x01\xa7\x01\xd4\x02\x63\x00\x64\x00\xec\x02\x54\x03\x65\x00\x66\x00\x39\x00\x3a\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\x09\x00\x05\x02\x06\x02\x09\x00\xa5\x01\xc9\x00\xbc\x00\x0a\x00\x8a\x01\x3b\x00\x0c\x00\xd0\x00\x72\x01\x0c\x00\xa4\x01\x94\x01\x6e\x01\x95\x01\xbd\x00\x39\x00\x3a\x00\xa3\x01\x45\x00\x73\x01\x39\x00\x3c\x00\x0f\x00\x10\x00\x11\x00\xa2\x01\x12\x00\x3d\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\xd4\x01\x16\x00\x0a\x00\x61\x01\xb2\x00\x0c\x00\xdb\x00\x62\x01\xf6\x02\x63\x01\xf7\x02\xb3\x00\xbc\x00\x91\x02\x76\x01\x77\x01\xfc\x01\x39\x00\x78\x01\x9d\x00\x0e\x00\x0f\x00\xb4\x00\x11\x00\xbd\x00\x12\x00\x13\x00\x9d\x01\x14\x00\x15\x00\x16\x00\x17\x00\x18\x02\xfe\x01\xdf\x00\x05\x02\x06\x02\x2f\x00\xe5\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\xab\x02\x3e\x00\xb5\x00\xb6\x00\xac\x02\xe6\x00\x96\x01\x50\x00\x7a\x01\xe7\x00\x51\x00\xe8\x00\x52\x00\x53\x00\x54\x00\x55\x00\xdb\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\xdc\x00\xdd\x00\x7b\x01\xde\x00\xdf\x00\x39\x00\x3a\x00\x63\x00\x64\x00\x4c\x00\x08\x00\x65\x00\x66\x00\xe3\x00\x1b\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\x09\x00\x63\x00\xb7\x00\x6c\x01\xf3\x02\x72\x01\xf4\x02\x0a\x00\xbc\x00\x63\x01\xa8\x00\x59\x01\xc9\x00\x39\x00\xa9\x00\x64\x01\xfa\x01\x71\x01\x61\x01\x81\x02\x08\x02\x0a\x02\x91\x01\x7d\x02\x92\x01\x60\xff\xbc\x00\x84\x01\x11\x00\xbc\x00\x12\x00\x39\x00\x85\x01\x14\x00\x15\x00\x16\x00\x86\x01\x09\x00\xbc\x00\x39\x00\x3a\x00\xbd\x00\x3b\x00\xbc\x00\x0a\x00\x79\x02\x67\x01\xa8\x00\xac\x00\xad\x00\x08\x02\x09\x02\x68\x01\xb3\x00\x77\x02\xbd\x00\x87\x01\x88\x01\xd4\x02\x89\x01\x76\x02\xd5\x02\xbc\x00\xf7\x02\x69\x01\x11\x00\x39\x00\x12\x00\x09\x00\xbc\x00\x14\x00\x15\x00\x16\x00\x5d\x01\xbd\x00\x0a\x00\x96\x01\x5e\x01\x0c\x00\xd5\x01\xf5\x01\x08\x02\xcd\x02\x97\x01\xb3\x00\x70\x02\xd4\x02\xb5\x00\xb6\x00\xd5\x02\x96\x01\x5a\x03\x65\x02\x98\x01\xdf\x00\x5f\x01\x11\x00\x53\x02\x12\x00\xbc\x00\x6b\x02\x14\x00\x15\x00\x16\x00\x5d\x01\x09\x00\x44\x00\x98\x01\xdf\x00\xdb\x00\x69\x02\xbd\x00\x0a\x00\x66\x02\x0b\x00\x0c\x00\x45\x00\xfb\x01\xb5\x00\xb6\x00\xd4\x02\xd5\x01\xee\x01\xd5\x02\x6d\x01\x59\x03\xde\x00\xdf\x00\x68\x02\x49\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\xef\xfe\x12\x00\x13\x00\xbc\x01\x14\x00\x15\x00\x16\x00\x17\x00\x8a\x01\x1a\x02\x1b\x02\x1c\x02\xdb\x00\x1d\x02\xee\xfe\x18\x00\x19\x00\x1a\x00\x1b\x00\x1f\x02\x63\x00\xb7\x00\xf0\xfe\x20\x02\xf4\xfe\x21\x02\xf3\xfe\x6a\x01\x4a\x02\xde\x00\xdf\x00\xd4\x02\x22\x02\xbc\x00\xd5\x02\x3f\x02\xd6\x02\xbc\x00\xd7\x02\x16\x02\x82\x00\x83\x00\x44\x02\x80\x03\x84\x00\xbd\x00\x85\x00\x1f\x00\x86\x00\xbd\x00\x50\xfe\x63\x00\xb7\x00\x87\x00\x88\x00\x89\x00\x8a\x00\x4a\x00\x20\x00\x8b\x00\x8c\x00\x8d\x00\x25\x02\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x21\x00\x3e\x02\x22\x00\x23\x00\x24\x00\x25\x00\x93\x00\xd5\x01\xe3\x01\x28\x00\x94\x00\x29\x00\x96\x01\x2a\x00\x95\x00\x96\x00\xbe\x00\x29\x02\x2b\x00\x52\x02\x3c\x02\xbf\x00\xc0\x00\xc1\x00\xc2\x00\xd5\x01\xe2\x01\xd5\x01\xde\x01\x98\x01\xdf\x00\xd5\x01\xdb\x01\xc3\x00\xc4\x00\xa1\x02\x88\x02\x89\x02\x8a\x02\x8b\x02\x8c\x02\x2c\x00\x2d\x00\xd9\x02\xda\x02\x2e\x00\x3b\x02\x41\x00\xd8\x01\xd9\x01\x3a\x02\x31\x00\x32\x00\x24\x02\x33\x00\x34\x00\x29\x02\x42\x00\xdb\x02\x36\x00\xdc\x02\x43\x00\x35\x02\x44\x00\xd5\x01\xd6\x01\x17\x02\x39\x00\x97\x00\xfa\x01\x39\x00\x3a\x00\xbc\x00\x3b\x00\x16\x02\x82\x00\x83\x00\xcf\x01\xd1\x01\x84\x00\x2f\x02\x85\x00\x1f\x00\x86\x00\xbd\x00\x50\xfe\xcf\x01\xd0\x01\x87\x00\x88\x00\x89\x00\x8a\x00\x34\x02\x20\x00\x8b\x00\x8c\x00\x8d\x00\x33\x02\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x21\x00\x32\x02\x22\x00\x23\x00\x24\x00\x25\x00\x93\x00\xcf\x01\x25\x02\x28\x00\x94\x00\x29\x00\x31\x02\x2a\x00\x95\x00\x96\x00\xfc\x01\x2f\x02\x2b\x00\xd4\x02\xc7\x00\xc8\x00\xd5\x02\xd4\x02\x84\x03\xc9\x00\xd5\x02\xf1\xfe\x83\x03\xd5\x01\xe5\x02\x9a\x01\x0d\x02\xfe\x01\xdf\x00\x9b\x01\x29\x02\x9c\x01\xd5\x01\xe4\x02\x2c\x02\x2c\x00\x2d\x00\xd4\x02\x39\x00\x2e\x00\xd5\x02\x41\x00\x82\x03\xbd\x02\xbe\x02\x31\x00\x32\x00\xd4\x02\x33\x00\x34\x00\xd5\x02\x42\x00\x81\x03\x36\x00\x29\x02\x43\x00\x27\x02\x44\x00\xba\x02\xbb\x02\x17\x02\xbc\x00\x97\x00\x39\x00\x39\x00\x3a\x00\xbc\x00\x3b\x00\x82\x00\x83\x00\xd2\x02\xd3\x02\x84\x00\xbd\x00\x85\x00\x1f\x00\x86\x00\x39\x00\xbd\x00\xce\x02\xcf\x02\x87\x00\x88\x00\x89\x00\x8a\x00\xf9\x01\x20\x00\x8b\x00\x8c\x00\x8d\x00\xd8\x01\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x21\x00\xdd\x02\x22\x00\x23\x00\x24\x00\x25\x00\x93\x00\xc5\x02\xc6\x02\x28\x00\x94\x00\x29\x00\xfc\x01\x2a\x00\x95\x00\x96\x00\xec\x01\xfc\x01\x2b\x00\x87\x02\x88\x02\x89\x02\x8a\x02\x8b\x02\x8c\x02\x9e\x02\x9f\x02\xcd\x02\x0c\x02\xfe\x01\xdf\x00\xd5\x01\xfe\x02\xff\x01\xfe\x01\xdf\x00\x23\x03\x89\x02\x8a\x02\x8b\x02\x8c\x02\x2c\x00\x2d\x00\xcf\x01\x51\x03\x2e\x00\xc9\x02\x41\x00\xd5\x01\xfb\x02\xc8\x02\x31\x00\x32\x00\xc0\x02\x33\x00\x34\x00\xb8\x02\x42\x00\xb7\x02\x36\x00\x2c\x02\x43\x00\xb3\x02\x44\x00\xd5\x01\xea\x02\xf4\xfd\xb5\x02\x97\x00\x31\x02\x39\x00\x3a\x00\xb1\x02\x3b\x00\xf4\xfd\xf2\x00\xf3\x00\xf4\x00\xf5\x00\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x01\x01\x01\x02\x01\x03\x01\x04\x01\x05\x01\x06\x01\x07\x01\x08\x01\x09\x01\x0a\x01\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\x10\x01\x11\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x01\x22\x01\x23\x01\x24\x01\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\x2c\x01\x2d\x01\x2e\x01\x2f\x01\x30\x01\x31\x01\x32\x01\x33\x01\x34\x01\x35\x01\x36\x01\x37\x01\x38\x01\x39\x01\x3a\x01\x3b\x01\x3c\x01\x3d\x01\x3e\x01\x3f\x01\x40\x01\x41\x01\x42\x01\x43\x01\x44\x01\x45\x01\x46\x01\x47\x01\x48\x01\x49\x01\x4a\x01\x4b\x01\x4c\x01\x4d\x01\x4e\x01\x4f\x01\x50\x01\x51\x01\x52\x01\x53\x01\x54\x01\x55\x01\x56\x01\x57\x01\x82\x00\x83\x00\x43\x03\x44\x03\x84\x00\x45\x03\x85\x00\x1f\x00\x86\x00\xb0\x02\x50\xfe\xaf\x02\x46\x03\x87\x00\x88\x00\x89\x00\x47\x03\xae\x02\x20\x00\x8b\x00\x8c\x00\x8d\x00\x48\x03\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x21\x00\x29\x02\x22\x00\x23\x00\x24\x00\x25\x00\x93\x00\xd5\x01\xe8\x02\x28\x00\x94\x00\x29\x00\xa9\x02\x2a\x00\x95\x00\x96\x00\xd3\xfe\xd3\xfe\x2b\x00\x31\x02\xbc\x00\xd3\xfe\x29\x02\xd3\xfe\xcf\x01\x50\x03\x9a\x02\xd3\xfe\xcf\x01\x4f\x03\x95\x02\xd3\xfe\xbd\x00\xd3\xfe\xe6\x02\x88\x02\x89\x02\x8a\x02\x8b\x02\x8c\x02\xd3\xfe\x2c\x00\x2d\x00\xcf\x01\x4e\x03\x2e\x00\x79\x02\x41\x00\x38\x03\x35\x03\x94\x02\x31\x00\x32\x00\x93\x02\x33\x00\x34\x00\x86\x02\x42\x00\x84\x02\x36\x00\x23\x03\x43\x00\x39\x00\x44\x00\x34\x03\x35\x03\x22\x03\xfc\x01\x97\x00\x21\x03\x39\x00\x3a\x00\x0c\x03\x3b\x00\x82\x00\x83\x00\x43\x03\x44\x03\x84\x00\x45\x03\x85\x00\x1f\x00\x86\x00\xfd\x01\xfe\x01\xdf\x00\x46\x03\x87\x00\x88\x00\x89\x00\x47\x03\x1b\x03\x20\x00\x8b\x00\x8c\x00\x8d\x00\x48\x03\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x21\x00\x1a\x03\x22\x00\x23\x00\x24\x00\x25\x00\x93\x00\x30\x03\x9f\x02\x28\x00\x94\x00\x29\x00\x19\x03\x2a\x00\x95\x00\x96\x00\xc7\x00\xc8\x00\x2b\x00\xc7\x00\xc8\x00\xc9\x00\x65\x03\x66\x03\xc9\x00\x18\x03\x31\x02\xe1\x00\xd5\x01\xe3\x01\x9a\x01\xe2\x00\x11\x03\xe3\x00\x9b\x01\x10\x03\x9c\x01\xd5\x01\x58\x03\x0f\x03\x39\x00\x2c\x00\x2d\x00\x39\x00\x0b\x03\x2e\x00\x22\x02\x41\x00\xd5\x01\x57\x03\x06\x03\x31\x00\x32\x00\x39\x00\x33\x00\x34\x00\x00\x03\x42\x00\xd8\x01\x36\x00\xfa\x02\x43\x00\xd8\x01\x44\x00\x57\x03\x56\x03\x54\x03\xbc\x00\x97\x00\x39\x00\x39\x00\x3a\x00\x49\x03\x3b\x00\x89\xff\x89\xff\x3b\x03\x22\x02\x89\xff\xbd\x00\x89\xff\x89\xff\x89\xff\x3a\x03\x89\xff\x38\x03\x37\x03\x89\xff\x89\xff\x89\xff\x89\xff\x34\x03\x89\xff\x89\xff\x89\xff\x89\xff\x33\x03\x89\xff\x89\xff\x89\xff\x89\xff\x89\xff\x89\xff\x76\x03\x89\xff\x89\xff\x89\xff\x89\xff\x89\xff\x77\x03\x39\x00\x89\xff\x89\xff\x89\xff\xfc\x01\x89\xff\x89\xff\x89\xff\xc7\x00\xc8\x00\x89\xff\x73\x03\xbc\x00\xc9\x00\x72\x03\x71\x03\x6f\x03\x22\x02\x6d\x03\xe1\x00\xe2\x02\xfe\x01\xdf\x00\xe2\x00\xbd\x00\xe3\x00\x6a\x03\x22\x02\x63\x03\x39\x00\x06\x03\x5f\x03\x39\x00\x89\xff\x89\xff\x5d\x03\x7d\x03\x89\xff\xd8\x01\x89\xff\x7c\x03\x2e\x03\x39\x00\x89\xff\x89\xff\x39\x00\x89\xff\x89\xff\x47\x00\x89\xff\x88\x03\x89\xff\x08\x00\x89\xff\xf0\x00\x89\xff\xd9\x00\xd8\x00\xa4\x00\xfc\x01\x89\xff\xa0\x00\x89\xff\x89\xff\x4d\x00\x89\xff\x82\x00\x83\x00\xf2\x01\xed\x01\x84\x00\xef\x01\x85\x00\x1f\x00\x86\x00\xdf\x02\xfe\x01\xdf\x00\xec\x01\x87\x00\x88\x00\x89\x00\x8a\x00\xea\x01\x20\x00\x8b\x00\x8c\x00\x8d\x00\xe7\x01\x8e\x00\x8f\x00\x90\x00\x91\x00\x92\x00\x21\x00\xe8\x01\x22\x00\x23\x00\x24\x00\x25\x00\x93\x00\xe6\x01\xe4\x01\x28\x00\x94\x00\x29\x00\xdc\x01\x2a\x00\x95\x00\x96\x00\xc7\x00\xc8\x00\x2b\x00\xc7\x00\xc8\x00\xc9\x00\xd3\x01\xb8\x01\xc9\x00\xbc\x00\xb5\x01\x9a\x01\xb0\x01\xaf\x01\xe1\x00\x9b\x01\xa8\x01\x9c\x01\xe2\x00\xa7\x01\x1a\x02\xbd\x00\x7e\x02\xa0\x01\x39\x00\x2c\x00\x2d\x00\x39\x00\x6f\x01\x2e\x00\x7b\x02\x41\x00\x6d\x02\x6e\x02\x6b\x02\x31\x00\x32\x00\x1f\x00\x33\x00\x34\x00\x72\x01\x42\x00\x62\x02\x36\x00\x69\x02\x43\x00\x66\x02\x44\x00\xb9\x00\x5f\x02\x45\x00\x73\x01\x97\x00\xba\x00\x39\x00\x3a\x00\xfc\x01\x3b\x00\x21\x00\x6f\x01\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x42\x02\x2f\x02\x28\x00\x3c\x02\x29\x00\x38\x02\x2a\x00\xc9\x02\xfe\x01\xdf\x00\x37\x02\x2b\x00\x74\x01\x75\x01\x76\x01\x77\x01\x36\x02\x35\x02\x78\x01\x4a\x03\x88\x02\x89\x02\x8a\x02\x8b\x02\x8c\x02\x31\x03\x88\x02\x89\x02\x8a\x02\x8b\x02\x8c\x02\x2d\x02\x0e\x02\x2c\x02\x2c\x00\x2d\x00\x27\x02\xd1\x02\x2e\x00\x2f\x00\x30\x00\xb5\x02\xb1\x02\xb3\x02\x31\x00\x32\x00\x1f\x00\x33\x00\x34\x00\xac\x02\x35\x00\x9f\x00\x36\x00\xa9\x02\x37\x00\xa7\x02\x38\x00\x20\x00\xa6\x02\xa5\x02\x9c\x02\x9a\x02\x84\x02\x39\x00\x3a\x00\x09\x00\x3b\x00\x21\x00\x1b\x03\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x16\x03\x0c\x00\x28\x00\x15\x03\x29\x00\x14\x03\x2a\x00\xb3\x00\x11\x03\x0c\x03\x08\x03\x2b\x00\x60\x03\x88\x02\x89\x02\x8a\x02\x8b\x02\x8c\x02\x5f\x01\x11\x00\x04\x03\x12\x00\xf4\x02\xf1\x02\x14\x00\x15\x00\x16\x00\x5d\x01\xf4\x02\xf1\x02\x6f\x03\x3b\x03\x52\x03\x74\x03\x2c\x00\x2d\x00\x73\x03\x6d\x03\x2e\x00\x2f\x00\x30\x00\x83\x01\x6b\x03\x6a\x03\xaf\x00\x32\x00\x68\x03\x33\x00\x34\x00\x1f\x00\x35\x00\x67\x03\x36\x00\x64\x03\x37\x00\x9c\x00\x38\x00\x9d\x00\x63\x03\x09\x00\x20\x00\x61\x03\x5d\x03\x39\x00\x3a\x00\x5b\x03\x3b\x00\x80\x03\x7a\x03\x0c\x00\x21\x00\x79\x03\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x86\x03\x85\x03\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\xd5\x00\x0f\x00\x10\x00\x11\x00\x2b\x00\x12\x00\x3d\x00\x00\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x00\x00\x33\x00\x34\x00\x1f\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x9c\x00\x38\x00\x9d\x00\x00\x00\x09\x00\x20\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x0c\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\xb2\x01\x10\x00\x11\x00\x2b\x00\x12\x00\x3d\x00\x00\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x32\x00\x00\x00\x33\x00\x34\x00\x1f\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x9c\x00\x38\x00\x9d\x00\x00\x00\x09\x00\x20\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x0c\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x70\x02\x10\x00\x11\x00\x2b\x00\x12\x00\x3d\x00\x00\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\xa1\x02\x2f\x00\x30\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x00\x00\x33\x00\x34\x00\x1f\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x9c\x00\x38\x00\x9d\x00\x00\x00\x09\x00\x20\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x0c\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\xea\x00\x11\x00\x2b\x00\x12\x00\xeb\x00\x00\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x60\x03\x2f\x00\x30\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x00\x00\x33\x00\x34\x00\x1f\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x9c\x00\x38\x00\x9d\x00\x00\x00\x09\x00\x20\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x0c\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x27\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\xea\x00\x11\x00\x2b\x00\x12\x00\x00\x00\x63\x02\x14\x00\x15\x00\x16\x00\x86\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\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x1f\x00\x33\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x09\x00\x3b\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x0c\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5d\x02\x11\x00\x00\x00\x12\x00\x00\x00\x5e\x02\x14\x00\x15\x00\x16\x00\x86\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x32\x00\x00\x00\x33\x00\x34\x00\x1f\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x99\x00\x00\x00\x09\x00\x20\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x0c\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\xea\x00\x11\x00\x2b\x00\x12\x00\x00\x00\x00\x00\x14\x00\x15\x00\x16\x00\x5d\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\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x1f\x00\x33\x00\x34\x00\x00\x00\x35\x00\x9f\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\xc7\x00\xc8\x00\x00\x00\x00\x00\x2b\x00\xc9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9a\x01\x00\x00\x00\x00\x00\x00\x9b\x01\x00\x00\x9c\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x00\x00\x33\x00\x34\x00\x1f\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x99\x00\x00\x00\x00\x00\xb9\x00\x00\x00\x00\x00\x39\x00\x3a\x00\xba\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\xc7\x00\xc8\x00\x00\x00\x00\x00\x2b\x00\xc9\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe1\x00\x00\x00\x00\x00\x00\x00\xe2\x00\x00\x00\xe3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x32\x00\x1f\x00\x33\x00\x34\x00\x00\x00\x42\x00\x8f\x01\x36\x00\x00\x00\x43\x00\x00\x00\x44\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\xbb\x01\xbc\x01\xbd\x01\xbe\x01\xbf\x01\xc0\x01\xc1\x01\xc2\x01\xc3\x01\xc4\x01\xc5\x01\xc6\x01\xc7\x01\xc8\x01\xc9\x01\xca\x01\xcb\x01\xcc\x01\xcd\x01\xce\x01\xcf\x01\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x32\x00\x00\x00\x33\x00\x34\x00\x1f\x00\x42\x00\x00\x00\x36\x00\x00\x00\x43\x00\x9c\x00\x44\x00\x9d\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x32\x00\x00\x00\x33\x00\x34\x00\x1f\x00\x42\x00\x00\x00\x36\x00\x00\x00\x43\x00\x00\x00\x44\x00\x8c\x01\x00\x00\x00\x00\x20\x00\x8d\x01\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x1f\x00\x33\x00\x34\x00\x00\x00\x35\x00\x9f\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x32\x00\x00\x00\x33\x00\x34\x00\x1f\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x99\x00\x00\x00\x00\x00\xb9\x00\x00\x00\x00\x00\x39\x00\x3a\x00\xba\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x32\x00\x1f\x00\x33\x00\x34\x00\x00\x00\x42\x00\x52\x02\x36\x00\x00\x00\x43\x00\x00\x00\x44\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x32\x00\x00\x00\x33\x00\x34\x00\x1f\x00\x42\x00\x00\x00\x36\x00\x00\x00\x43\x00\x9c\x00\x44\x00\x9d\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x1f\x00\x33\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x37\xff\x33\x00\x1f\x00\x37\xff\x42\x00\x00\x00\x36\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x1f\x00\x33\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\xb9\x00\x00\x00\x00\x00\x00\x00\x00\x00\xba\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x32\x00\x1f\x00\x33\x00\x34\x00\x00\x00\x42\x00\x00\x00\x36\x00\x00\x00\x43\x00\x00\x00\x44\x00\xb9\x00\x00\x00\x00\x00\x00\x00\x00\x00\xba\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x1f\x00\x33\x00\x34\x00\x00\x00\x42\x00\x00\x00\x36\x00\x00\x00\x43\x00\x00\x00\x44\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x1f\x00\x33\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x32\x00\x00\x00\x33\x00\x34\x00\x1f\x00\x42\x00\x00\x00\x36\x00\x00\x00\x43\x00\x00\x00\x44\x00\x50\x02\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x89\xff\x33\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x89\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x89\xff\x00\x00\x89\xff\x89\xff\x89\xff\x89\xff\x89\xff\x00\x00\x00\x00\x89\xff\x00\x00\x89\xff\x00\x00\x89\xff\x00\x00\x00\x00\x00\x00\x00\x00\x89\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x89\xff\x89\xff\x00\x00\x00\x00\x89\xff\x89\xff\x89\xff\x00\x00\x00\x00\x00\x00\x89\xff\x89\xff\x1f\x00\x89\xff\x89\xff\x00\x00\x89\xff\x00\x00\x89\xff\x00\x00\x89\xff\x00\x00\x89\xff\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x89\xff\x89\xff\x00\x00\x89\xff\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x2f\x00\x30\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x1f\x00\x33\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x00\x00\x37\x00\x00\x00\x38\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x1f\x00\x33\x00\x34\x00\x00\x00\x42\x00\x00\x00\x36\x00\x00\x00\x43\x00\x00\x00\x44\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x32\x00\x1f\x00\x33\x00\x34\x00\x00\x00\x42\x00\x00\x00\x36\x00\x00\x00\x43\x00\x00\x00\x44\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x1f\x00\x33\x00\x34\x00\x00\x00\x42\x00\x00\x00\x36\x00\x00\x00\x43\x00\x00\x00\x44\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x32\x00\x1f\x00\x33\x00\x34\x00\x00\x00\x42\x00\x00\x00\x36\x00\x00\x00\x43\x00\x00\x00\x44\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x1f\x00\x33\x00\x34\x00\x00\x00\x42\x00\x00\x00\x36\x00\x00\x00\x43\x00\x00\x00\x44\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x32\x00\x1f\x00\x33\x00\x34\x00\x00\x00\x42\x00\x00\x00\x36\x00\x00\x00\x43\x00\x00\x00\x44\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x35\xff\x33\x00\x1f\x00\x00\x00\x42\x00\x00\x00\x36\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x1f\x00\x33\x00\x00\x00\x00\x00\x42\x00\x00\x00\x36\x00\x00\x00\x43\x00\x00\x00\x44\x00\x20\x00\x00\x00\x00\x00\x00\x00\x8d\x01\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x32\x00\x1f\x00\x33\x00\x34\x00\x00\x00\x42\x00\x00\x00\x36\x00\x00\x00\x43\x00\x00\x00\x44\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x1f\x00\x33\x00\x00\x00\x00\x00\x42\x00\x00\x00\x36\x00\x00\x00\x43\x00\x00\x00\x44\x00\x20\x00\x00\x00\x00\x00\x00\x00\x8d\x01\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x1f\x00\x33\x00\x00\x00\x00\x00\x42\x00\x00\x00\x36\x00\x00\x00\x43\x00\x00\x00\x44\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x32\x00\x1f\x00\x33\x00\x00\x00\x00\x00\x42\x00\x00\x00\x36\x00\x00\x00\x43\x00\x00\x00\x44\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x1f\x00\x33\x00\x00\x00\x00\x00\x42\x00\x00\x00\x36\x00\x00\x00\x43\x00\x00\x00\x44\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x32\x00\x1f\x00\x33\x00\x00\x00\x00\x00\x42\x00\x00\x00\x36\x00\x00\x00\x43\x00\x00\x00\x44\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x1f\x00\x33\x00\x00\x00\x00\x00\x42\x00\x00\x00\x36\x00\x00\x00\x43\x00\x00\x00\x44\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x29\x00\x00\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\xaf\x00\x32\x00\x00\x00\x33\x00\x09\x00\x00\x00\x42\x00\x00\x00\x36\x00\x00\x00\x43\x00\x0a\x00\x44\x00\x3b\x00\x0c\x00\x00\x00\x00\x00\x09\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x3c\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x3d\x00\x00\x00\x14\x00\x15\x00\x16\x00\x17\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x00\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x09\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\xa5\x00\x3e\x00\x2a\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x00\x1d\x00\x3c\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x3d\x00\x00\x00\x14\x00\x15\x00\x16\x00\x17\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x00\x00\x00\x00\x34\x00\x00\x00\x42\x00\x00\x00\x36\x00\x00\x00\x43\x00\x09\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x39\x00\x3a\x00\x0c\x00\x3b\x00\x21\x00\x00\x00\x22\x00\x23\x00\xa5\x01\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\xa6\x00\x00\x00\x2a\x00\x00\x00\x5f\x01\x11\x00\x00\x00\x12\x00\xee\x00\x00\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x00\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2a\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x36\x00\x00\x00\x43\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x39\x00\x3a\x00\x2e\x00\x3b\x00\x41\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x36\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x21\x00\x3b\x00\x22\x00\x23\x00\x00\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\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\x21\x00\x00\x00\x22\x00\x23\x00\x00\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2a\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\xcd\x00\x00\x00\x36\x00\x00\x00\xce\x00\x00\x00\xcf\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x39\x00\x3a\x00\x2e\x00\x3b\x00\x41\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x36\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x21\x00\x3b\x00\x22\x00\x23\x00\x00\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\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\x21\x00\x00\x00\x22\x00\x23\x00\x00\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2a\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x36\x00\x00\x00\x43\x00\x00\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x39\x00\x3a\x00\x2e\x00\x3b\x00\x41\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x36\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x21\x00\x3b\x00\x22\x00\x23\x00\x00\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\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\x21\x00\x00\x00\x22\x00\x23\x00\x00\x00\x25\x00\x26\x00\x00\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x2a\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x36\x00\x00\x00\x4f\x02\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x39\x00\x3a\x00\x2e\x00\x3b\x00\x41\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x00\x00\x00\x36\x00\x00\x00\x43\x00\x00\x00\x44\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x09\x00\x39\x00\x3a\x00\x21\x00\x3b\x00\x22\x00\x23\x00\xa5\x00\x25\x00\x26\x00\xa8\x00\x00\x00\x28\x00\x00\x00\xae\x01\xaa\x00\x2a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x01\x11\x00\x00\x00\x12\x00\xee\x00\x00\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2c\x00\x2d\x00\x00\x00\x00\x00\x2e\x00\x00\x00\x41\x00\x00\x00\x00\x00\x00\x00\x31\x00\x32\x00\x00\x00\x00\x00\x09\x00\x00\x00\x42\x00\x00\x00\x36\x00\x00\x00\x4d\x03\x0a\x00\x44\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x01\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x00\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7c\x01\x7d\x01\x00\x00\x00\x00\x00\x00\x00\x00\x7b\x01\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x00\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x00\x00\x00\x95\x02\x7d\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x00\x0e\x00\x0f\x00\xb4\x00\x11\x00\x00\x00\x12\x00\x13\x00\x00\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x09\x00\x83\x01\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x00\x00\xa7\x00\xa8\x00\x00\x00\x00\x00\x00\x00\xa9\x00\xaa\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9a\x00\x0e\x00\x0f\x00\xab\x00\x11\x00\x00\x00\x12\x00\x13\x00\x00\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x09\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\xaf\x00\xb0\x00\x0a\x00\x00\x00\xa7\x00\xa8\x00\x00\x00\x00\x00\x00\x00\xa9\x00\xaa\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x97\x00\x0e\x00\x0f\x00\xab\x00\x11\x00\x00\x00\x12\x00\x13\x00\x00\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc2\x02\x18\x00\x19\x00\x1a\x00\x1b\x00\xac\x00\xad\x00\x0a\x00\x00\x00\x63\x01\xa8\x00\x00\x00\x00\x00\x00\x00\xa9\x00\x64\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x01\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x14\x00\x15\x00\x16\x00\x5d\x01\x09\x00\x00\x00\x8d\x01\x00\x00\x72\x02\x73\x02\x74\x02\x0a\x00\x00\x00\x65\x01\xa8\x00\xac\x00\xad\x00\x00\x00\x66\x01\xaa\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x01\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x14\x00\x15\x00\x16\x00\x5d\x01\x09\x00\x00\x00\x50\x02\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x65\x01\xa8\x00\xaf\x00\xb0\x00\x00\x00\x66\x01\xaa\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x01\x11\x00\x00\x00\x12\x00\x09\x00\x00\x00\x14\x00\x15\x00\x16\x00\x5d\x01\x00\x00\x0a\x00\x00\x00\x65\x01\xa8\x00\x00\x00\x00\x00\x00\x00\x66\x01\xaa\x00\x00\x00\xaf\x00\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x01\x11\x00\x00\x00\x12\x00\x09\x00\x00\x00\x14\x00\x15\x00\x16\x00\x5d\x01\x00\x00\x0a\x00\x00\x00\x63\x01\xa8\x00\x00\x00\x00\x00\x00\x00\xa9\x00\x64\x01\x00\x00\xaf\x00\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x01\x11\x00\x00\x00\x12\x00\x09\x00\x00\x00\x14\x00\x15\x00\x16\x00\x5d\x01\x00\x00\x0a\x00\x00\x00\x5b\x01\xa8\x00\x00\x00\x00\x00\x00\x00\xa9\x00\xaa\x00\x00\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x01\x11\x00\x00\x00\x12\x00\x09\x00\x00\x00\x14\x00\x15\x00\x16\x00\x5d\x01\x00\x00\x0a\x00\x00\x00\x5b\x01\xa8\x00\x00\x00\x00\x00\x00\x00\xa9\x00\xaa\x00\x00\x00\xaf\x00\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x01\x11\x00\x00\x00\x12\x00\x09\x00\x00\x00\x14\x00\x15\x00\x16\x00\x5d\x01\x00\x00\x0a\x00\x00\x00\x63\x01\xa8\x00\x00\x00\x00\x00\x00\x00\xa9\x00\x64\x01\x00\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5c\x01\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x14\x00\x15\x00\x16\x00\x5d\x01\x09\x00\x00\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\xa8\x00\xac\x00\xad\x00\x00\x00\xa9\x00\xaa\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9a\x00\x0e\x00\x0f\x00\xab\x00\x11\x00\x00\x00\x12\x00\x13\x00\x00\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x09\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x82\x01\x0a\x00\x00\x00\x0b\x00\xa8\x00\x00\x00\x00\x00\x00\x00\xa9\x00\xaa\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x97\x00\x0e\x00\x0f\x00\xab\x00\x11\x00\x00\x00\x12\x00\x13\x00\x00\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x81\x01\xa8\x00\x09\x00\x00\x00\x00\x00\xa9\x00\xaa\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa8\x00\x00\x00\x00\x00\x00\x00\xa9\x00\xaa\x00\x5c\x01\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x14\x00\x15\x00\x16\x00\x5d\x01\x00\x00\x5c\x01\x11\x00\x09\x00\x12\x00\x00\x00\x00\x00\x14\x00\x15\x00\x16\x00\x5d\x01\x7f\x01\x00\x00\xa8\x00\x09\x00\x00\x00\x00\x00\xa9\x00\xaa\x00\x00\x00\x00\x00\x00\x00\x7e\x01\x00\x00\xa8\x00\x00\x00\x00\x00\x00\x00\xa9\x00\xaa\x00\x5c\x01\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x14\x00\x15\x00\x16\x00\x5d\x01\x00\x00\x5c\x01\x11\x00\x09\x00\x12\x00\x00\x00\x00\x00\x14\x00\x15\x00\x16\x00\x5d\x01\x82\x01\x00\x00\xa8\x00\x09\x00\x00\x00\x00\x00\x5c\x02\xaa\x00\x00\x00\x00\x00\x00\x00\x81\x01\x00\x00\xa8\x00\x00\x00\x00\x00\x00\x00\x5b\x02\xaa\x00\x5c\x01\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x14\x00\x15\x00\x16\x00\x5d\x01\x00\x00\x5c\x01\x11\x00\x09\x00\x12\x00\x00\x00\x00\x00\x14\x00\x15\x00\x16\x00\x5d\x01\x82\x01\x00\x00\xa8\x00\x09\x00\x00\x00\x00\x00\x5a\x02\xaa\x00\x00\x00\x00\x00\x00\x00\x81\x01\x00\x00\xa8\x00\x00\x00\x00\x00\x00\x00\x59\x02\xaa\x00\x5c\x01\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x14\x00\x15\x00\x16\x00\x5d\x01\x00\x00\x5c\x01\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x14\x00\x15\x00\x16\x00\x5d\x01\x7f\x01\x00\x00\x00\x00\x09\x00\x00\x00\x99\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x7e\x01\x0b\x00\x0c\x00\x00\x00\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\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe9\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x97\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb4\x01\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb3\x01\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x01\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6c\x01\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\x01\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x59\x01\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x7a\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x79\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x46\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x41\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x22\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb9\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x96\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1d\x03\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x03\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x03\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x03\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xeb\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe9\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe7\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4d\x03\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x00\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x09\x00\x00\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\xa5\x00\x00\x00\x00\x00\xa8\x00\x09\x00\x00\x00\x00\x00\xae\x01\xaa\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x00\x00\xa8\x00\x00\x00\x00\x00\x00\x00\xae\x01\x81\x02\x5c\x01\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x14\x00\x15\x00\x16\x00\x5d\x01\x00\x00\x5c\x01\x11\x00\x00\x00\x12\x00\x09\x00\x00\x00\x14\x00\x15\x00\x16\x00\x5d\x01\x00\x00\xa5\x00\x00\x00\x00\x00\xa8\x00\x00\x00\x00\x00\x00\x00\x7f\x02\xaa\x00\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa5\x00\x00\x00\x00\x00\xa8\x00\x5c\x01\x11\x00\x00\x00\x12\x00\x7d\x02\xa5\x01\x14\x00\x15\x00\x16\x00\x5d\x01\x00\x00\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x69\x01\x11\x00\xa5\x00\x12\x00\x00\x00\x0c\x00\x14\x00\x15\x00\x16\x00\x5d\x01\x00\x00\xa5\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x01\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x14\x00\x15\x00\x16\x00\x5d\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"# - -happyReduceArr = Happy_Data_Array.array (7, 524) [ - (7 , happyReduce_7), - (8 , happyReduce_8), - (9 , happyReduce_9), - (10 , happyReduce_10), - (11 , happyReduce_11), - (12 , happyReduce_12), - (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) - ] - -happy_n_terms = 104 :: Int -happy_n_nonterms = 175 :: Int - -happyReduce_7 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_7 = happySpecReduce_1 0# happyReduction_7 -happyReduction_7 happy_x_1 - = case happyOut11 happy_x_1 of { happy_var_1 -> - happyIn10 - (reverse happy_var_1 - )} - -happyReduce_8 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_8 = happySpecReduce_2 1# happyReduction_8 -happyReduction_8 happy_x_2 - happy_x_1 - = case happyOut11 happy_x_1 of { happy_var_1 -> - case happyOut12 happy_x_2 of { happy_var_2 -> - happyIn11 - (happy_var_2 : happy_var_1 - )}} - -happyReduce_9 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_9 = happySpecReduce_0 1# happyReduction_9 -happyReduction_9 = happyIn11 - ([] - ) - -happyReduce_10 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_10 = happySpecReduce_1 2# happyReduction_10 -happyReduction_10 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwAbstract happy_var_1) -> - happyIn12 - (TokKeyword KwAbstract happy_var_1 - )} - -happyReduce_11 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_11 = happySpecReduce_1 2# happyReduction_11 -happyReduction_11 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwCoData happy_var_1) -> - happyIn12 - (TokKeyword KwCoData happy_var_1 - )} - -happyReduce_12 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_12 = happySpecReduce_1 2# happyReduction_12 -happyReduction_12 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwCoInductive happy_var_1) -> - happyIn12 - (TokKeyword KwCoInductive happy_var_1 - )} - -happyReduce_13 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_13 = happySpecReduce_1 2# happyReduction_13 -happyReduction_13 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwConstructor happy_var_1) -> - happyIn12 - (TokKeyword KwConstructor happy_var_1 - )} - -happyReduce_14 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_14 = happySpecReduce_1 2# happyReduction_14 -happyReduction_14 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwData happy_var_1) -> - happyIn12 - (TokKeyword KwData happy_var_1 - )} - -happyReduce_15 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_15 = happySpecReduce_1 2# happyReduction_15 -happyReduction_15 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwEta happy_var_1) -> - happyIn12 - (TokKeyword KwEta happy_var_1 - )} - -happyReduce_16 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_16 = happySpecReduce_1 2# happyReduction_16 -happyReduction_16 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwField happy_var_1) -> - happyIn12 - (TokKeyword KwField happy_var_1 - )} - -happyReduce_17 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_17 = happySpecReduce_1 2# happyReduction_17 -happyReduction_17 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwForall happy_var_1) -> - happyIn12 - (TokKeyword KwForall happy_var_1 - )} - -happyReduce_18 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_18 = happySpecReduce_1 2# happyReduction_18 -happyReduction_18 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwVariable happy_var_1) -> - happyIn12 - (TokKeyword KwVariable happy_var_1 - )} - -happyReduce_19 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_19 = happySpecReduce_1 2# happyReduction_19 -happyReduction_19 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwHiding happy_var_1) -> - happyIn12 - (TokKeyword KwHiding happy_var_1 - )} - -happyReduce_20 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_20 = happySpecReduce_1 2# happyReduction_20 -happyReduction_20 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwImport happy_var_1) -> - happyIn12 - (TokKeyword KwImport happy_var_1 - )} - -happyReduce_21 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_21 = happySpecReduce_1 2# happyReduction_21 -happyReduction_21 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwIn happy_var_1) -> - happyIn12 - (TokKeyword KwIn happy_var_1 - )} - -happyReduce_22 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_22 = happySpecReduce_1 2# happyReduction_22 -happyReduction_22 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwInductive happy_var_1) -> - happyIn12 - (TokKeyword KwInductive happy_var_1 - )} - -happyReduce_23 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_23 = happySpecReduce_1 2# happyReduction_23 -happyReduction_23 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwInfix happy_var_1) -> - happyIn12 - (TokKeyword KwInfix happy_var_1 - )} - -happyReduce_24 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_24 = happySpecReduce_1 2# happyReduction_24 -happyReduction_24 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwInfixL happy_var_1) -> - happyIn12 - (TokKeyword KwInfixL happy_var_1 - )} - -happyReduce_25 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_25 = happySpecReduce_1 2# happyReduction_25 -happyReduction_25 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwInfixR happy_var_1) -> - happyIn12 - (TokKeyword KwInfixR happy_var_1 - )} - -happyReduce_26 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_26 = happySpecReduce_1 2# happyReduction_26 -happyReduction_26 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwInstance happy_var_1) -> - happyIn12 - (TokKeyword KwInstance happy_var_1 - )} - -happyReduce_27 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_27 = happySpecReduce_1 2# happyReduction_27 -happyReduction_27 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwOverlap happy_var_1) -> - happyIn12 - (TokKeyword KwOverlap happy_var_1 - )} - -happyReduce_28 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_28 = happySpecReduce_1 2# happyReduction_28 -happyReduction_28 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwLet happy_var_1) -> - happyIn12 - (TokKeyword KwLet happy_var_1 - )} - -happyReduce_29 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_29 = happySpecReduce_1 2# happyReduction_29 -happyReduction_29 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwMacro happy_var_1) -> - happyIn12 - (TokKeyword KwMacro happy_var_1 - )} - -happyReduce_30 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_30 = happySpecReduce_1 2# happyReduction_30 -happyReduction_30 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwModule happy_var_1) -> - happyIn12 - (TokKeyword KwModule happy_var_1 - )} - -happyReduce_31 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_31 = happySpecReduce_1 2# happyReduction_31 -happyReduction_31 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwMutual happy_var_1) -> - happyIn12 - (TokKeyword KwMutual happy_var_1 - )} - -happyReduce_32 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_32 = happySpecReduce_1 2# happyReduction_32 -happyReduction_32 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwNoEta happy_var_1) -> - happyIn12 - (TokKeyword KwNoEta happy_var_1 - )} - -happyReduce_33 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_33 = happySpecReduce_1 2# happyReduction_33 -happyReduction_33 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwOpen happy_var_1) -> - happyIn12 - (TokKeyword KwOpen happy_var_1 - )} - -happyReduce_34 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_34 = happySpecReduce_1 2# happyReduction_34 -happyReduction_34 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwPatternSyn happy_var_1) -> - happyIn12 - (TokKeyword KwPatternSyn happy_var_1 - )} - -happyReduce_35 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_35 = happySpecReduce_1 2# happyReduction_35 -happyReduction_35 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwPostulate happy_var_1) -> - happyIn12 - (TokKeyword KwPostulate happy_var_1 - )} - -happyReduce_36 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_36 = happySpecReduce_1 2# happyReduction_36 -happyReduction_36 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwPrimitive happy_var_1) -> - happyIn12 - (TokKeyword KwPrimitive happy_var_1 - )} - -happyReduce_37 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_37 = happySpecReduce_1 2# happyReduction_37 -happyReduction_37 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwPrivate happy_var_1) -> - happyIn12 - (TokKeyword KwPrivate happy_var_1 - )} - -happyReduce_38 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_38 = happySpecReduce_1 2# happyReduction_38 -happyReduction_38 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwProp happy_var_1) -> - happyIn12 - (TokKeyword KwProp happy_var_1 - )} - -happyReduce_39 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_39 = happySpecReduce_1 2# happyReduction_39 -happyReduction_39 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwPublic happy_var_1) -> - happyIn12 - (TokKeyword KwPublic happy_var_1 - )} - -happyReduce_40 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_40 = happySpecReduce_1 2# happyReduction_40 -happyReduction_40 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwQuote happy_var_1) -> - happyIn12 - (TokKeyword KwQuote happy_var_1 - )} - -happyReduce_41 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_41 = happySpecReduce_1 2# happyReduction_41 -happyReduction_41 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwQuoteContext happy_var_1) -> - happyIn12 - (TokKeyword KwQuoteContext happy_var_1 - )} - -happyReduce_42 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_42 = happySpecReduce_1 2# happyReduction_42 -happyReduction_42 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwQuoteGoal happy_var_1) -> - happyIn12 - (TokKeyword KwQuoteGoal happy_var_1 - )} - -happyReduce_43 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_43 = happySpecReduce_1 2# happyReduction_43 -happyReduction_43 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwQuoteTerm happy_var_1) -> - happyIn12 - (TokKeyword KwQuoteTerm happy_var_1 - )} - -happyReduce_44 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_44 = happySpecReduce_1 2# happyReduction_44 -happyReduction_44 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwRecord happy_var_1) -> - happyIn12 - (TokKeyword KwRecord happy_var_1 - )} - -happyReduce_45 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_45 = happySpecReduce_1 2# happyReduction_45 -happyReduction_45 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwRenaming happy_var_1) -> - happyIn12 - (TokKeyword KwRenaming happy_var_1 - )} - -happyReduce_46 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_46 = happySpecReduce_1 2# happyReduction_46 -happyReduction_46 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwRewrite happy_var_1) -> - happyIn12 - (TokKeyword KwRewrite happy_var_1 - )} - -happyReduce_47 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_47 = happySpecReduce_1 2# happyReduction_47 -happyReduction_47 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwSet happy_var_1) -> - happyIn12 - (TokKeyword KwSet happy_var_1 - )} - -happyReduce_48 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_48 = happySpecReduce_1 2# happyReduction_48 -happyReduction_48 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwSyntax happy_var_1) -> - happyIn12 - (TokKeyword KwSyntax happy_var_1 - )} - -happyReduce_49 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_49 = happySpecReduce_1 2# happyReduction_49 -happyReduction_49 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwTactic happy_var_1) -> - happyIn12 - (TokKeyword KwTactic happy_var_1 - )} - -happyReduce_50 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_50 = happySpecReduce_1 2# happyReduction_50 -happyReduction_50 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwTo happy_var_1) -> - happyIn12 - (TokKeyword KwTo happy_var_1 - )} - -happyReduce_51 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_51 = happySpecReduce_1 2# happyReduction_51 -happyReduction_51 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwUnquote happy_var_1) -> - happyIn12 - (TokKeyword KwUnquote happy_var_1 - )} - -happyReduce_52 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_52 = happySpecReduce_1 2# happyReduction_52 -happyReduction_52 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwUnquoteDecl happy_var_1) -> - happyIn12 - (TokKeyword KwUnquoteDecl happy_var_1 - )} - -happyReduce_53 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_53 = happySpecReduce_1 2# happyReduction_53 -happyReduction_53 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwUnquoteDef happy_var_1) -> - happyIn12 - (TokKeyword KwUnquoteDef happy_var_1 - )} - -happyReduce_54 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_54 = happySpecReduce_1 2# happyReduction_54 -happyReduction_54 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwUsing happy_var_1) -> - happyIn12 - (TokKeyword KwUsing happy_var_1 - )} - -happyReduce_55 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_55 = happySpecReduce_1 2# happyReduction_55 -happyReduction_55 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwWhere happy_var_1) -> - happyIn12 - (TokKeyword KwWhere happy_var_1 - )} - -happyReduce_56 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_56 = happySpecReduce_1 2# happyReduction_56 -happyReduction_56 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwDo happy_var_1) -> - happyIn12 - (TokKeyword KwDo happy_var_1 - )} - -happyReduce_57 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_57 = happySpecReduce_1 2# happyReduction_57 -happyReduction_57 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwWith happy_var_1) -> - happyIn12 - (TokKeyword KwWith happy_var_1 - )} - -happyReduce_58 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_58 = happySpecReduce_1 2# happyReduction_58 -happyReduction_58 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwBUILTIN happy_var_1) -> - happyIn12 - (TokKeyword KwBUILTIN happy_var_1 - )} - -happyReduce_59 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_59 = happySpecReduce_1 2# happyReduction_59 -happyReduction_59 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwCATCHALL happy_var_1) -> - happyIn12 - (TokKeyword KwCATCHALL happy_var_1 - )} - -happyReduce_60 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_60 = happySpecReduce_1 2# happyReduction_60 -happyReduction_60 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwDISPLAY happy_var_1) -> - happyIn12 - (TokKeyword KwDISPLAY happy_var_1 - )} - -happyReduce_61 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_61 = happySpecReduce_1 2# happyReduction_61 -happyReduction_61 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwETA happy_var_1) -> - happyIn12 - (TokKeyword KwETA happy_var_1 - )} - -happyReduce_62 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_62 = happySpecReduce_1 2# happyReduction_62 -happyReduction_62 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwFOREIGN happy_var_1) -> - happyIn12 - (TokKeyword KwFOREIGN happy_var_1 - )} - -happyReduce_63 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_63 = happySpecReduce_1 2# happyReduction_63 -happyReduction_63 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwCOMPILE happy_var_1) -> - happyIn12 - (TokKeyword KwCOMPILE happy_var_1 - )} - -happyReduce_64 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_64 = happySpecReduce_1 2# happyReduction_64 -happyReduction_64 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwIMPOSSIBLE happy_var_1) -> - happyIn12 - (TokKeyword KwIMPOSSIBLE happy_var_1 - )} - -happyReduce_65 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_65 = happySpecReduce_1 2# happyReduction_65 -happyReduction_65 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwINJECTIVE happy_var_1) -> - happyIn12 - (TokKeyword KwINJECTIVE happy_var_1 - )} - -happyReduce_66 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_66 = happySpecReduce_1 2# happyReduction_66 -happyReduction_66 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwINLINE happy_var_1) -> - happyIn12 - (TokKeyword KwINLINE happy_var_1 - )} - -happyReduce_67 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_67 = happySpecReduce_1 2# happyReduction_67 -happyReduction_67 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwNOINLINE happy_var_1) -> - happyIn12 - (TokKeyword KwNOINLINE happy_var_1 - )} - -happyReduce_68 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_68 = happySpecReduce_1 2# happyReduction_68 -happyReduction_68 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwMEASURE happy_var_1) -> - happyIn12 - (TokKeyword KwMEASURE happy_var_1 - )} - -happyReduce_69 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_69 = happySpecReduce_1 2# happyReduction_69 -happyReduction_69 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwNO_TERMINATION_CHECK happy_var_1) -> - happyIn12 - (TokKeyword KwNO_TERMINATION_CHECK happy_var_1 - )} - -happyReduce_70 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_70 = happySpecReduce_1 2# happyReduction_70 -happyReduction_70 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwNO_POSITIVITY_CHECK happy_var_1) -> - happyIn12 - (TokKeyword KwNO_POSITIVITY_CHECK happy_var_1 - )} - -happyReduce_71 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_71 = happySpecReduce_1 2# happyReduction_71 -happyReduction_71 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwNO_UNIVERSE_CHECK happy_var_1) -> - happyIn12 - (TokKeyword KwNO_UNIVERSE_CHECK happy_var_1 - )} - -happyReduce_72 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_72 = happySpecReduce_1 2# happyReduction_72 -happyReduction_72 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwNON_TERMINATING happy_var_1) -> - happyIn12 - (TokKeyword KwNON_TERMINATING happy_var_1 - )} - -happyReduce_73 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_73 = happySpecReduce_1 2# happyReduction_73 -happyReduction_73 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwOPTIONS happy_var_1) -> - happyIn12 - (TokKeyword KwOPTIONS happy_var_1 - )} - -happyReduce_74 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_74 = happySpecReduce_1 2# happyReduction_74 -happyReduction_74 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwPOLARITY happy_var_1) -> - happyIn12 - (TokKeyword KwPOLARITY happy_var_1 - )} - -happyReduce_75 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_75 = happySpecReduce_1 2# happyReduction_75 -happyReduction_75 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwREWRITE happy_var_1) -> - happyIn12 - (TokKeyword KwREWRITE happy_var_1 - )} - -happyReduce_76 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_76 = happySpecReduce_1 2# happyReduction_76 -happyReduction_76 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwSTATIC happy_var_1) -> - happyIn12 - (TokKeyword KwSTATIC happy_var_1 - )} - -happyReduce_77 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_77 = happySpecReduce_1 2# happyReduction_77 -happyReduction_77 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwTERMINATING happy_var_1) -> - happyIn12 - (TokKeyword KwTERMINATING happy_var_1 - )} - -happyReduce_78 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_78 = happySpecReduce_1 2# happyReduction_78 -happyReduction_78 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwWARNING_ON_USAGE happy_var_1) -> - happyIn12 - (TokKeyword KwWARNING_ON_USAGE happy_var_1 - )} - -happyReduce_79 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_79 = happySpecReduce_1 2# happyReduction_79 -happyReduction_79 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSetN happy_var_1) -> - happyIn12 - (TokSetN happy_var_1 - )} - -happyReduce_80 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_80 = happySpecReduce_1 2# happyReduction_80 -happyReduction_80 happy_x_1 - = case happyOutTok happy_x_1 of { (TokPropN happy_var_1) -> - happyIn12 - (TokPropN happy_var_1 - )} - -happyReduce_81 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_81 = happySpecReduce_1 2# happyReduction_81 -happyReduction_81 happy_x_1 - = case happyOutTok happy_x_1 of { (TokTeX happy_var_1) -> - happyIn12 - (TokTeX happy_var_1 - )} - -happyReduce_82 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_82 = happySpecReduce_1 2# happyReduction_82 -happyReduction_82 happy_x_1 - = case happyOutTok happy_x_1 of { (TokComment happy_var_1) -> - happyIn12 - (TokComment happy_var_1 - )} - -happyReduce_83 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_83 = happySpecReduce_1 2# happyReduction_83 -happyReduction_83 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymEllipsis happy_var_1) -> - happyIn12 - (TokSymbol SymEllipsis happy_var_1 - )} - -happyReduce_84 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_84 = happySpecReduce_1 2# happyReduction_84 -happyReduction_84 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymDotDot happy_var_1) -> - happyIn12 - (TokSymbol SymDotDot happy_var_1 - )} - -happyReduce_85 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_85 = happySpecReduce_1 2# happyReduction_85 -happyReduction_85 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymDot happy_var_1) -> - happyIn12 - (TokSymbol SymDot happy_var_1 - )} - -happyReduce_86 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_86 = happySpecReduce_1 2# happyReduction_86 -happyReduction_86 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymSemi happy_var_1) -> - happyIn12 - (TokSymbol SymSemi happy_var_1 - )} - -happyReduce_87 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_87 = happySpecReduce_1 2# happyReduction_87 -happyReduction_87 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymColon happy_var_1) -> - happyIn12 - (TokSymbol SymColon happy_var_1 - )} - -happyReduce_88 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_88 = happySpecReduce_1 2# happyReduction_88 -happyReduction_88 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymEqual happy_var_1) -> - happyIn12 - (TokSymbol SymEqual happy_var_1 - )} - -happyReduce_89 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_89 = happySpecReduce_1 2# happyReduction_89 -happyReduction_89 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymUnderscore happy_var_1) -> - happyIn12 - (TokSymbol SymUnderscore happy_var_1 - )} - -happyReduce_90 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_90 = happySpecReduce_1 2# happyReduction_90 -happyReduction_90 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymQuestionMark happy_var_1) -> - happyIn12 - (TokSymbol SymQuestionMark happy_var_1 - )} - -happyReduce_91 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_91 = happySpecReduce_1 2# happyReduction_91 -happyReduction_91 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymArrow happy_var_1) -> - happyIn12 - (TokSymbol SymArrow happy_var_1 - )} - -happyReduce_92 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_92 = happySpecReduce_1 2# happyReduction_92 -happyReduction_92 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymLambda happy_var_1) -> - happyIn12 - (TokSymbol SymLambda happy_var_1 - )} - -happyReduce_93 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_93 = happySpecReduce_1 2# happyReduction_93 -happyReduction_93 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymAs happy_var_1) -> - happyIn12 - (TokSymbol SymAs happy_var_1 - )} - -happyReduce_94 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_94 = happySpecReduce_1 2# happyReduction_94 -happyReduction_94 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymBar happy_var_1) -> - happyIn12 - (TokSymbol SymBar happy_var_1 - )} - -happyReduce_95 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_95 = happySpecReduce_1 2# happyReduction_95 -happyReduction_95 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymOpenParen happy_var_1) -> - happyIn12 - (TokSymbol SymOpenParen happy_var_1 - )} - -happyReduce_96 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_96 = happySpecReduce_1 2# happyReduction_96 -happyReduction_96 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymCloseParen happy_var_1) -> - happyIn12 - (TokSymbol SymCloseParen happy_var_1 - )} - -happyReduce_97 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_97 = happySpecReduce_1 2# happyReduction_97 -happyReduction_97 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymOpenIdiomBracket happy_var_1) -> - happyIn12 - (TokSymbol SymOpenIdiomBracket happy_var_1 - )} - -happyReduce_98 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_98 = happySpecReduce_1 2# happyReduction_98 -happyReduction_98 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymCloseIdiomBracket happy_var_1) -> - happyIn12 - (TokSymbol SymCloseIdiomBracket happy_var_1 - )} - -happyReduce_99 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_99 = happySpecReduce_1 2# happyReduction_99 -happyReduction_99 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymDoubleOpenBrace happy_var_1) -> - happyIn12 - (TokSymbol SymDoubleOpenBrace happy_var_1 - )} - -happyReduce_100 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_100 = happySpecReduce_1 2# happyReduction_100 -happyReduction_100 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymDoubleCloseBrace happy_var_1) -> - happyIn12 - (TokSymbol SymDoubleCloseBrace happy_var_1 - )} - -happyReduce_101 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_101 = happySpecReduce_1 2# happyReduction_101 -happyReduction_101 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymOpenBrace happy_var_1) -> - happyIn12 - (TokSymbol SymOpenBrace happy_var_1 - )} - -happyReduce_102 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_102 = happySpecReduce_1 2# happyReduction_102 -happyReduction_102 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymCloseBrace happy_var_1) -> - happyIn12 - (TokSymbol SymCloseBrace happy_var_1 - )} - -happyReduce_103 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_103 = happySpecReduce_1 2# happyReduction_103 -happyReduction_103 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymOpenVirtualBrace happy_var_1) -> - happyIn12 - (TokSymbol SymOpenVirtualBrace happy_var_1 - )} - -happyReduce_104 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_104 = happySpecReduce_1 2# happyReduction_104 -happyReduction_104 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymCloseVirtualBrace happy_var_1) -> - happyIn12 - (TokSymbol SymCloseVirtualBrace happy_var_1 - )} - -happyReduce_105 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_105 = happySpecReduce_1 2# happyReduction_105 -happyReduction_105 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymVirtualSemi happy_var_1) -> - happyIn12 - (TokSymbol SymVirtualSemi happy_var_1 - )} - -happyReduce_106 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_106 = happySpecReduce_1 2# happyReduction_106 -happyReduction_106 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> - happyIn12 - (TokSymbol SymOpenPragma happy_var_1 - )} - -happyReduce_107 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_107 = happySpecReduce_1 2# happyReduction_107 -happyReduction_107 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymClosePragma happy_var_1) -> - happyIn12 - (TokSymbol SymClosePragma happy_var_1 - )} - -happyReduce_108 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_108 = happySpecReduce_1 2# happyReduction_108 -happyReduction_108 happy_x_1 - = case happyOutTok happy_x_1 of { (TokId happy_var_1) -> - happyIn12 - (TokId happy_var_1 - )} - -happyReduce_109 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_109 = happySpecReduce_1 2# happyReduction_109 -happyReduction_109 happy_x_1 - = case happyOutTok happy_x_1 of { (TokQId happy_var_1) -> - happyIn12 - (TokQId happy_var_1 - )} - -happyReduce_110 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_110 = happySpecReduce_1 2# happyReduction_110 -happyReduction_110 happy_x_1 - = case happyOutTok happy_x_1 of { (TokString happy_var_1) -> - happyIn12 - (TokString happy_var_1 - )} - -happyReduce_111 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_111 = happySpecReduce_1 2# happyReduction_111 -happyReduction_111 happy_x_1 - = case happyOutTok happy_x_1 of { (TokLiteral happy_var_1) -> - happyIn12 - (TokLiteral happy_var_1 - )} - -happyReduce_112 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_112 = happySpecReduce_3 3# happyReduction_112 -happyReduction_112 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut143 happy_x_2 of { happy_var_2 -> - happyIn13 - (takeOptionsPragmas happy_var_2 - )} - -happyReduce_113 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_113 = happySpecReduce_0 4# happyReduction_113 -happyReduction_113 = happyIn14 - (() - ) - -happyReduce_114 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_114 = happySpecReduce_1 4# happyReduction_114 -happyReduction_114 happy_x_1 - = happyIn14 - (() - ) - -happyReduce_115 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_115 = happySpecReduce_1 5# happyReduction_115 -happyReduction_115 happy_x_1 - = happyIn15 - (() - ) - -happyReduce_116 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_116 = happyMonadReduce 1# 5# happyReduction_116 -happyReduction_116 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((( popContext)) - ) (\r -> happyReturn (happyIn15 r)) - -happyReduce_117 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_117 = happySpecReduce_1 6# happyReduction_117 -happyReduction_117 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymSemi happy_var_1) -> - happyIn16 - (happy_var_1 - )} - -happyReduce_118 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_118 = happySpecReduce_1 6# happyReduction_118 -happyReduction_118 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymVirtualSemi happy_var_1) -> - happyIn16 - (happy_var_1 - )} - -happyReduce_119 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_119 = happyMonadReduce 0# 7# happyReduction_119 -happyReduction_119 (happyRest) tk - = happyThen ((( pushLexState imp_dir)) - ) (\r -> happyReturn (happyIn17 r)) - -happyReduce_120 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_120 = happyMonadReduce 1# 8# happyReduction_120 -happyReduction_120 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOutTok happy_x_1 of { (TokLiteral happy_var_1) -> - ( case happy_var_1 of { - LitNat _ i -> return i; - _ -> parseError $ "Expected integer" - })}) - ) (\r -> happyReturn (happyIn18 r)) - -happyReduce_121 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_121 = happyMonadReduce 1# 9# happyReduction_121 -happyReduction_121 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOutTok happy_x_1 of { (TokId happy_var_1) -> - ( mkName happy_var_1)}) - ) (\r -> happyReturn (happyIn19 r)) - -happyReduce_122 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_122 = happySpecReduce_2 10# happyReduction_122 -happyReduction_122 happy_x_2 - happy_x_1 - = case happyOut19 happy_x_1 of { happy_var_1 -> - case happyOut20 happy_x_2 of { happy_var_2 -> - happyIn20 - (happy_var_1 : happy_var_2 - )}} - -happyReduce_123 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_123 = happySpecReduce_1 10# happyReduction_123 -happyReduction_123 happy_x_1 - = case happyOut19 happy_x_1 of { happy_var_1 -> - happyIn20 - ([happy_var_1] - )} - -happyReduce_124 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_124 = happySpecReduce_1 11# happyReduction_124 -happyReduction_124 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymDoubleCloseBrace happy_var_1) -> - happyIn21 - (getRange happy_var_1 - )} - -happyReduce_125 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_125 = happyMonadReduce 2# 11# happyReduction_125 -happyReduction_125 (happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOutTok happy_x_1 of { (TokSymbol SymCloseBrace happy_var_1) -> - case happyOutTok happy_x_2 of { (TokSymbol SymCloseBrace happy_var_2) -> - ( - if posPos (fromJust (rEnd' (getRange happy_var_2))) - - posPos (fromJust (rStart' (getRange happy_var_1))) > 2 - then parseErrorRange happy_var_2 "Expecting '}}', found separated '}'s." - else return $ getRange (happy_var_1, happy_var_2))}}) - ) (\r -> happyReturn (happyIn21 r)) - -happyReduce_126 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_126 = happySpecReduce_2 12# happyReduction_126 -happyReduction_126 happy_x_2 - happy_x_1 - = case happyOut19 happy_x_2 of { happy_var_2 -> - happyIn22 - (setRelevance NonStrict $ defaultArg happy_var_2 - )} - -happyReduce_127 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_127 = happySpecReduce_2 12# happyReduction_127 -happyReduction_127 happy_x_2 - happy_x_1 - = case happyOut19 happy_x_2 of { happy_var_2 -> - happyIn22 - (setRelevance Irrelevant $ defaultArg happy_var_2 - )} - -happyReduce_128 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_128 = happySpecReduce_1 12# happyReduction_128 -happyReduction_128 happy_x_1 - = case happyOut19 happy_x_1 of { happy_var_1 -> - happyIn22 - (defaultArg happy_var_1 - )} - -happyReduce_129 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_129 = happySpecReduce_2 13# happyReduction_129 -happyReduction_129 happy_x_2 - happy_x_1 - = case happyOut22 happy_x_1 of { happy_var_1 -> - case happyOut23 happy_x_2 of { happy_var_2 -> - happyIn23 - (happy_var_1 : happy_var_2 - )}} - -happyReduce_130 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_130 = happySpecReduce_1 13# happyReduction_130 -happyReduction_130 happy_x_1 - = case happyOut22 happy_x_1 of { happy_var_1 -> - happyIn23 - ([happy_var_1] - )} - -happyReduce_131 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_131 = happySpecReduce_2 14# happyReduction_131 -happyReduction_131 happy_x_2 - happy_x_1 - = case happyOut22 happy_x_1 of { happy_var_1 -> - case happyOut24 happy_x_2 of { happy_var_2 -> - happyIn24 - (happy_var_1 : happy_var_2 - )}} - -happyReduce_132 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_132 = happySpecReduce_1 14# happyReduction_132 -happyReduction_132 happy_x_1 - = case happyOut22 happy_x_1 of { happy_var_1 -> - happyIn24 - ([happy_var_1] - )} - -happyReduce_133 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_133 = happyReduce 4# 14# happyReduction_133 -happyReduction_133 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut23 happy_x_2 of { happy_var_2 -> - case happyOut24 happy_x_4 of { happy_var_4 -> - happyIn24 - (map makeInstance happy_var_2 ++ happy_var_4 - ) `HappyStk` happyRest}} - -happyReduce_134 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_134 = happySpecReduce_3 14# happyReduction_134 -happyReduction_134 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut23 happy_x_2 of { happy_var_2 -> - happyIn24 - (map makeInstance happy_var_2 - )} - -happyReduce_135 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_135 = happyReduce 4# 14# happyReduction_135 -happyReduction_135 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut23 happy_x_2 of { happy_var_2 -> - case happyOut24 happy_x_4 of { happy_var_4 -> - happyIn24 - (map hide happy_var_2 ++ happy_var_4 - ) `HappyStk` happyRest}} - -happyReduce_136 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_136 = happySpecReduce_3 14# happyReduction_136 -happyReduction_136 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut23 happy_x_2 of { happy_var_2 -> - happyIn24 - (map hide happy_var_2 - )} - -happyReduce_137 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_137 = happyReduce 5# 14# happyReduction_137 -happyReduction_137 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut20 happy_x_3 of { happy_var_3 -> - case happyOut24 happy_x_5 of { happy_var_5 -> - happyIn24 - (map (hide . setRelevance Irrelevant . defaultArg) happy_var_3 ++ happy_var_5 - ) `HappyStk` happyRest}} - -happyReduce_138 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_138 = happyReduce 4# 14# happyReduction_138 -happyReduction_138 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut20 happy_x_3 of { happy_var_3 -> - happyIn24 - (map (hide . setRelevance Irrelevant . defaultArg) happy_var_3 - ) `HappyStk` happyRest} - -happyReduce_139 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_139 = happyReduce 5# 14# happyReduction_139 -happyReduction_139 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut20 happy_x_3 of { happy_var_3 -> - case happyOut24 happy_x_5 of { happy_var_5 -> - happyIn24 - (map (makeInstance . setRelevance Irrelevant . defaultArg) happy_var_3 ++ happy_var_5 - ) `HappyStk` happyRest}} - -happyReduce_140 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_140 = happyReduce 4# 14# happyReduction_140 -happyReduction_140 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut20 happy_x_3 of { happy_var_3 -> - happyIn24 - (map (makeInstance . setRelevance Irrelevant . defaultArg) happy_var_3 - ) `HappyStk` happyRest} - -happyReduce_141 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_141 = happyReduce 5# 14# happyReduction_141 -happyReduction_141 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut20 happy_x_3 of { happy_var_3 -> - case happyOut24 happy_x_5 of { happy_var_5 -> - happyIn24 - (map (hide . setRelevance NonStrict . defaultArg) happy_var_3 ++ happy_var_5 - ) `HappyStk` happyRest}} - -happyReduce_142 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_142 = happyReduce 4# 14# happyReduction_142 -happyReduction_142 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut20 happy_x_3 of { happy_var_3 -> - happyIn24 - (map (hide . setRelevance NonStrict . defaultArg) happy_var_3 - ) `HappyStk` happyRest} - -happyReduce_143 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_143 = happyReduce 5# 14# happyReduction_143 -happyReduction_143 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut20 happy_x_3 of { happy_var_3 -> - case happyOut24 happy_x_5 of { happy_var_5 -> - happyIn24 - (map (makeInstance . setRelevance NonStrict . defaultArg) happy_var_3 ++ happy_var_5 - ) `HappyStk` happyRest}} - -happyReduce_144 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_144 = happyReduce 4# 14# happyReduction_144 -happyReduction_144 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut20 happy_x_3 of { happy_var_3 -> - happyIn24 - (map (makeInstance . setRelevance NonStrict . defaultArg) happy_var_3 - ) `HappyStk` happyRest} - -happyReduce_145 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_145 = happyMonadReduce 2# 15# happyReduction_145 -happyReduction_145 (happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOut27 happy_x_1 of { happy_var_1 -> - case happyOut24 happy_x_2 of { happy_var_2 -> - ( mapM (applyAttrs happy_var_1) happy_var_2)}}) - ) (\r -> happyReturn (happyIn25 r)) - -happyReduce_146 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_146 = happyMonadReduce 2# 16# happyReduction_146 -happyReduction_146 (happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOutTok happy_x_1 of { (TokSymbol SymAs happy_var_1) -> - case happyOut54 happy_x_2 of { happy_var_2 -> - ( setRange (getRange (happy_var_1,happy_var_2)) `fmap` toAttribute happy_var_2)}}) - ) (\r -> happyReturn (happyIn26 r)) - -happyReduce_147 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_147 = happySpecReduce_0 17# happyReduction_147 -happyReduction_147 = happyIn27 - ([] - ) - -happyReduce_148 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_148 = happySpecReduce_2 17# happyReduction_148 -happyReduction_148 happy_x_2 - happy_x_1 - = case happyOut27 happy_x_1 of { happy_var_1 -> - case happyOut26 happy_x_2 of { happy_var_2 -> - happyIn27 - (happy_var_2 : happy_var_1 - )}} - -happyReduce_149 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_149 = happySpecReduce_1 18# happyReduction_149 -happyReduction_149 happy_x_1 - = case happyOut26 happy_x_1 of { happy_var_1 -> - happyIn28 - ([happy_var_1] - )} - -happyReduce_150 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_150 = happySpecReduce_2 18# happyReduction_150 -happyReduction_150 happy_x_2 - happy_x_1 - = case happyOut28 happy_x_1 of { happy_var_1 -> - case happyOut26 happy_x_2 of { happy_var_2 -> - happyIn28 - (happy_var_2 : happy_var_1 - )}} - -happyReduce_151 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_151 = happyMonadReduce 1# 19# happyReduction_151 -happyReduction_151 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOutTok happy_x_1 of { (TokQId happy_var_1) -> - ( mkQName happy_var_1)}) - ) (\r -> happyReturn (happyIn29 r)) - -happyReduce_152 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_152 = happySpecReduce_1 19# happyReduction_152 -happyReduction_152 happy_x_1 - = case happyOut19 happy_x_1 of { happy_var_1 -> - happyIn29 - (QName happy_var_1 - )} - -happyReduce_153 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_153 = happySpecReduce_1 20# happyReduction_153 -happyReduction_153 happy_x_1 - = case happyOut29 happy_x_1 of { happy_var_1 -> - happyIn30 - (happy_var_1 - )} - -happyReduce_154 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_154 = happySpecReduce_1 21# happyReduction_154 -happyReduction_154 happy_x_1 - = case happyOut19 happy_x_1 of { happy_var_1 -> - happyIn31 - (happy_var_1 - )} - -happyReduce_155 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_155 = happySpecReduce_1 21# happyReduction_155 -happyReduction_155 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymUnderscore happy_var_1) -> - happyIn31 - (Name (getRange happy_var_1) InScope [Hole] - )} - -happyReduce_156 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_156 = happySpecReduce_2 22# happyReduction_156 -happyReduction_156 happy_x_2 - happy_x_1 - = case happyOut31 happy_x_1 of { happy_var_1 -> - case happyOut32 happy_x_2 of { happy_var_2 -> - happyIn32 - (happy_var_1 : happy_var_2 - )}} - -happyReduce_157 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_157 = happySpecReduce_1 22# happyReduction_157 -happyReduction_157 happy_x_1 - = case happyOut31 happy_x_1 of { happy_var_1 -> - happyIn32 - ([happy_var_1] - )} - -happyReduce_158 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_158 = happyMonadReduce 1# 23# happyReduction_158 -happyReduction_158 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOut34 happy_x_1 of { happy_var_1 -> - ( - case happy_var_1 of - Left ns -> return ns - Right _ -> parseError $ "expected sequence of bound identifiers, not absurd pattern")}) - ) (\r -> happyReturn (happyIn33 r)) - -happyReduce_159 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_159 = happyMonadReduce 1# 24# happyReduction_159 -happyReduction_159 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOut46 happy_x_1 of { happy_var_1 -> - ( boundNamesOrAbsurd happy_var_1)}) - ) (\r -> happyReturn (happyIn34 r)) - -happyReduce_160 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_160 = happyMonadReduce 3# 24# happyReduction_160 -happyReduction_160 (happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOut29 happy_x_1 of { happy_var_1 -> - case happyOut29 happy_x_3 of { happy_var_3 -> - ( fmap (Left . (:[])) $ mkNamedArg (Just happy_var_1) (Left happy_var_3))}}) - ) (\r -> happyReturn (happyIn34 r)) - -happyReduce_161 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_161 = happyMonadReduce 3# 24# happyReduction_161 -happyReduction_161 (happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOut29 happy_x_3 of { happy_var_3 -> - ( fmap (Left . (:[])) $ mkNamedArg Nothing (Left happy_var_3))}) - ) (\r -> happyReturn (happyIn34 r)) - -happyReduce_162 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_162 = happyMonadReduce 3# 24# happyReduction_162 -happyReduction_162 (happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOut29 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_3 of { (TokSymbol SymUnderscore happy_var_3) -> - ( fmap (Left . (:[])) $ mkNamedArg (Just happy_var_1) (Right $ getRange happy_var_3))}}) - ) (\r -> happyReturn (happyIn34 r)) - -happyReduce_163 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_163 = happyMonadReduce 3# 24# happyReduction_163 -happyReduction_163 (happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOutTok happy_x_3 of { (TokSymbol SymUnderscore happy_var_3) -> - ( fmap (Left . (:[])) $ mkNamedArg Nothing (Right $ getRange happy_var_3))}) - ) (\r -> happyReturn (happyIn34 r)) - -happyReduce_164 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_164 = happyMonadReduce 1# 25# happyReduction_164 -happyReduction_164 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOut46 happy_x_1 of { happy_var_1 -> - ( - let -- interpret an expression as name - getName :: Expr -> Maybe Name - getName (Ident (QName x)) = Just x - getName (Underscore r _) = Just (Name r InScope [Hole]) - getName _ = Nothing - - getNames :: Expr -> Maybe [Name] - getNames (RawApp _ es) = mapM getName es - getNames e = singleton `fmap` getName e - - -- interpret an expression as name or list of hidden names - getName1 :: Expr -> Maybe [Arg Name] - getName1 (Ident (QName x)) = Just [defaultArg x] - getName1 (Underscore r _) = Just [defaultArg $ Name r InScope [Hole]] - getName1 (HiddenArg _ (Named Nothing e)) - = map (setHiding Hidden . defaultArg) `fmap` getNames e - getName1 _ = Nothing - - in - case mapM getName1 happy_var_1 of - Just good -> return $ (map . fmap) (unnamed . mkBoundName_) $ concat good - Nothing -> parseError $ "expected sequence of possibly hidden bound identifiers")}) - ) (\r -> happyReturn (happyIn35 r)) - -happyReduce_165 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_165 = happySpecReduce_0 26# happyReduction_165 -happyReduction_165 = happyIn36 - ([] - ) - -happyReduce_166 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_166 = happySpecReduce_2 26# happyReduction_166 -happyReduction_166 happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokString happy_var_1) -> - case happyOut36 happy_x_2 of { happy_var_2 -> - happyIn36 - (snd happy_var_1 : happy_var_2 - )}} - -happyReduce_167 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_167 = happySpecReduce_1 27# happyReduction_167 -happyReduction_167 happy_x_1 - = case happyOutTok happy_x_1 of { (TokString happy_var_1) -> - happyIn37 - (snd happy_var_1 - )} - -happyReduce_168 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_168 = happySpecReduce_0 28# happyReduction_168 -happyReduction_168 = happyIn38 - ([] - ) - -happyReduce_169 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_169 = happySpecReduce_2 28# happyReduction_169 -happyReduction_169 happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokString happy_var_1) -> - case happyOut38 happy_x_2 of { happy_var_2 -> - happyIn38 - (happy_var_1 : happy_var_2 - )}} - -happyReduce_170 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_170 = happySpecReduce_0 29# happyReduction_170 -happyReduction_170 = happyIn39 - ([] - ) - -happyReduce_171 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_171 = happySpecReduce_2 29# happyReduction_171 -happyReduction_171 happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokString happy_var_1) -> - case happyOut39 happy_x_2 of { happy_var_2 -> - happyIn39 - (happy_var_1 : happy_var_2 - )}} - -happyReduce_172 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_172 = happyReduce 4# 29# happyReduction_172 -happyReduction_172 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOut39 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { (TokSymbol SymClosePragma happy_var_3) -> - case happyOut39 happy_x_4 of { happy_var_4 -> - happyIn39 - ([(happy_var_1, "{-#")] ++ happy_var_2 ++ [(happy_var_3, "#-}")] ++ happy_var_4 - ) `HappyStk` happyRest}}}} - -happyReduce_173 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_173 = happyMonadReduce 1# 30# happyReduction_173 -happyReduction_173 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOutTok happy_x_1 of { (TokString happy_var_1) -> - ( mkName happy_var_1)}) - ) (\r -> happyReturn (happyIn40 r)) - -happyReduce_174 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_174 = happyMonadReduce 1# 31# happyReduction_174 -happyReduction_174 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOutTok happy_x_1 of { (TokString happy_var_1) -> - ( pragmaQName happy_var_1)}) - ) (\r -> happyReturn (happyIn41 r)) - -happyReduce_175 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_175 = happyMonadReduce 1# 32# happyReduction_175 -happyReduction_175 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOut38 happy_x_1 of { happy_var_1 -> - ( mapM pragmaQName happy_var_1)}) - ) (\r -> happyReturn (happyIn42 r)) - -happyReduce_176 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_176 = happySpecReduce_2 33# happyReduction_176 -happyReduction_176 happy_x_2 - happy_x_1 - = case happyOut63 happy_x_1 of { happy_var_1 -> - case happyOut43 happy_x_2 of { happy_var_2 -> - happyIn43 - (Pi happy_var_1 happy_var_2 - )}} - -happyReduce_177 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_177 = happySpecReduce_3 33# happyReduction_177 -happyReduction_177 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut50 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { (TokSymbol SymArrow happy_var_2) -> - case happyOut43 happy_x_3 of { happy_var_3 -> - happyIn43 - (Fun (getRange (happy_var_1,happy_var_2,happy_var_3)) - (defaultArg $ RawApp (getRange happy_var_1) happy_var_1) - happy_var_3 - )}}} - -happyReduce_178 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_178 = happyMonadReduce 4# 33# happyReduction_178 -happyReduction_178 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOut28 happy_x_1 of { happy_var_1 -> - case happyOut50 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { (TokSymbol SymArrow happy_var_3) -> - case happyOut43 happy_x_4 of { happy_var_4 -> - ( applyAttrs happy_var_1 (defaultArg $ RawApp (getRange (happy_var_1,happy_var_2)) happy_var_2) <&> \ dom -> - Fun (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4)) dom happy_var_4)}}}}) - ) (\r -> happyReturn (happyIn43 r)) - -happyReduce_179 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_179 = happySpecReduce_3 33# happyReduction_179 -happyReduction_179 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut44 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { (TokSymbol SymEqual happy_var_2) -> - case happyOut43 happy_x_3 of { happy_var_3 -> - happyIn43 - (Equal (getRange (happy_var_1, happy_var_2, happy_var_3)) happy_var_1 happy_var_3 - )}}} - -happyReduce_180 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_180 = happySpecReduce_1 33# happyReduction_180 -happyReduction_180 happy_x_1 - = case happyOut44 happy_x_1 of { happy_var_1 -> - happyIn43 - (happy_var_1 - )} - -happyReduce_181 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_181 = happyMonadReduce 1# 34# happyReduction_181 -happyReduction_181 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOut45 happy_x_1 of { happy_var_1 -> - ( case happy_var_1 of - { [e] -> return e - ; e : es -> return $ WithApp (fuseRange e es) e es - ; [] -> parseError "impossible: empty with expressions" - })}) - ) (\r -> happyReturn (happyIn44 r)) - -happyReduce_182 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_182 = happySpecReduce_3 35# happyReduction_182 -happyReduction_182 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut50 happy_x_1 of { happy_var_1 -> - case happyOut45 happy_x_3 of { happy_var_3 -> - happyIn45 - (RawApp (getRange happy_var_1) happy_var_1 : happy_var_3 - )}} - -happyReduce_183 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_183 = happySpecReduce_1 35# happyReduction_183 -happyReduction_183 happy_x_1 - = case happyOut46 happy_x_1 of { happy_var_1 -> - happyIn45 - ([RawApp (getRange happy_var_1) happy_var_1] - )} - -happyReduce_184 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_184 = happySpecReduce_1 36# happyReduction_184 -happyReduction_184 happy_x_1 - = case happyOut47 happy_x_1 of { happy_var_1 -> - happyIn46 - ([happy_var_1] - )} - -happyReduce_185 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_185 = happySpecReduce_2 36# happyReduction_185 -happyReduction_185 happy_x_2 - happy_x_1 - = case happyOut55 happy_x_1 of { happy_var_1 -> - case happyOut46 happy_x_2 of { happy_var_2 -> - happyIn46 - (happy_var_1 : happy_var_2 - )}} - -happyReduce_186 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_186 = happySpecReduce_3 37# happyReduction_186 -happyReduction_186 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymLambda happy_var_1) -> - case happyOut71 happy_x_2 of { happy_var_2 -> - case happyOut43 happy_x_3 of { happy_var_3 -> - happyIn47 - (Lam (getRange (happy_var_1,happy_var_2,happy_var_3)) happy_var_2 happy_var_3 - )}}} - -happyReduce_187 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_187 = happySpecReduce_1 37# happyReduction_187 -happyReduction_187 happy_x_1 - = case happyOut49 happy_x_1 of { happy_var_1 -> - happyIn47 - (happy_var_1 - )} - -happyReduce_188 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_188 = happySpecReduce_3 37# happyReduction_188 -happyReduction_188 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut80 happy_x_2 of { happy_var_2 -> - case happyOut43 happy_x_3 of { happy_var_3 -> - happyIn47 - (forallPi happy_var_2 happy_var_3 - )}} - -happyReduce_189 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_189 = happySpecReduce_3 37# happyReduction_189 -happyReduction_189 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwLet happy_var_1) -> - case happyOut181 happy_x_2 of { happy_var_2 -> - case happyOut48 happy_x_3 of { happy_var_3 -> - happyIn47 - (Let (getRange (happy_var_1,happy_var_2,happy_var_3)) happy_var_2 happy_var_3 - )}}} - -happyReduce_190 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_190 = happyReduce 4# 37# happyReduction_190 -happyReduction_190 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_1 of { (TokKeyword KwDo happy_var_1) -> - case happyOut85 happy_x_3 of { happy_var_3 -> - happyIn47 - (DoBlock (getRange (happy_var_1, happy_var_3)) happy_var_3 - ) `HappyStk` happyRest}} - -happyReduce_191 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_191 = happySpecReduce_1 37# happyReduction_191 -happyReduction_191 happy_x_1 - = case happyOut55 happy_x_1 of { happy_var_1 -> - happyIn47 - (happy_var_1 - )} - -happyReduce_192 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_192 = happyReduce 4# 37# happyReduction_192 -happyReduction_192 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_1 of { (TokKeyword KwQuoteGoal happy_var_1) -> - case happyOut19 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { (TokKeyword KwIn happy_var_3) -> - case happyOut43 happy_x_4 of { happy_var_4 -> - happyIn47 - (QuoteGoal (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4)) happy_var_2 happy_var_4 - ) `HappyStk` happyRest}}}} - -happyReduce_193 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_193 = happySpecReduce_2 37# happyReduction_193 -happyReduction_193 happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwTactic happy_var_1) -> - case happyOut50 happy_x_2 of { happy_var_2 -> - happyIn47 - (Tactic (getRange (happy_var_1, happy_var_2)) (RawApp (getRange happy_var_2) happy_var_2) [] - )}} - -happyReduce_194 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_194 = happyReduce 4# 37# happyReduction_194 -happyReduction_194 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_1 of { (TokKeyword KwTactic happy_var_1) -> - case happyOut50 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { (TokSymbol SymBar happy_var_3) -> - case happyOut45 happy_x_4 of { happy_var_4 -> - happyIn47 - (Tactic (getRange (happy_var_1, happy_var_2, happy_var_3, happy_var_4)) (RawApp (getRange happy_var_2) happy_var_2) happy_var_4 - ) `HappyStk` happyRest}}}} - -happyReduce_195 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_195 = happySpecReduce_2 38# happyReduction_195 -happyReduction_195 happy_x_2 - happy_x_1 - = case happyOut43 happy_x_2 of { happy_var_2 -> - happyIn48 - (Just happy_var_2 - )} - -happyReduce_196 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_196 = happySpecReduce_0 38# happyReduction_196 -happyReduction_196 = happyIn48 - (Nothing - ) - -happyReduce_197 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_197 = happyReduce 4# 39# happyReduction_197 -happyReduction_197 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_1 of { (TokSymbol SymLambda happy_var_1) -> - case happyOutTok happy_x_2 of { (TokSymbol SymOpenBrace happy_var_2) -> - case happyOut78 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymCloseBrace happy_var_4) -> - happyIn49 - (ExtendedLam (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4)) (reverse happy_var_3) - ) `HappyStk` happyRest}}}} - -happyReduce_198 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_198 = happyReduce 5# 39# happyReduction_198 -happyReduction_198 (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 { (TokSymbol SymLambda happy_var_1) -> - case happyOutTok happy_x_2 of { (TokKeyword KwWhere happy_var_2) -> - case happyOut79 happy_x_4 of { happy_var_4 -> - happyIn49 - (ExtendedLam (getRange (happy_var_1, happy_var_2, happy_var_4)) (reverse happy_var_4) - ) `HappyStk` happyRest}}} - -happyReduce_199 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_199 = happyMonadReduce 2# 39# happyReduction_199 -happyReduction_199 (happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOutTok happy_x_1 of { (TokSymbol SymLambda happy_var_1) -> - case happyOut72 happy_x_2 of { happy_var_2 -> - ( case happy_var_2 of - Left (bs, h) -> if null bs then return $ AbsurdLam r h else - return $ Lam r bs (AbsurdLam r h) - where r = fuseRange happy_var_1 bs - Right es -> do -- it is of the form @\ { p1 ... () }@ - p <- exprToLHS (RawApp (getRange es) es); - return $ ExtendedLam (fuseRange happy_var_1 es) - [LamClause (p [] []) AbsurdRHS NoWhere False])}}) - ) (\r -> happyReturn (happyIn49 r)) - -happyReduce_200 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_200 = happySpecReduce_1 40# happyReduction_200 -happyReduction_200 happy_x_1 - = case happyOut55 happy_x_1 of { happy_var_1 -> - happyIn50 - ([happy_var_1] - )} - -happyReduce_201 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_201 = happySpecReduce_2 40# happyReduction_201 -happyReduction_201 happy_x_2 - happy_x_1 - = case happyOut55 happy_x_1 of { happy_var_1 -> - case happyOut50 happy_x_2 of { happy_var_2 -> - happyIn50 - (happy_var_1 : happy_var_2 - )}} - -happyReduce_202 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_202 = happySpecReduce_0 41# happyReduction_202 -happyReduction_202 = happyIn51 - ([] - ) - -happyReduce_203 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_203 = happySpecReduce_2 41# happyReduction_203 -happyReduction_203 happy_x_2 - happy_x_1 - = case happyOut55 happy_x_1 of { happy_var_1 -> - case happyOut51 happy_x_2 of { happy_var_2 -> - happyIn51 - (happy_var_1 : happy_var_2 - )}} - -happyReduce_204 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_204 = happySpecReduce_3 42# happyReduction_204 -happyReduction_204 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymOpenBrace happy_var_1) -> - case happyOut43 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { (TokSymbol SymCloseBrace happy_var_3) -> - happyIn52 - (HiddenArg (getRange (happy_var_1,happy_var_2,happy_var_3)) (maybeNamed happy_var_2) - )}}} - -happyReduce_205 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_205 = happySpecReduce_2 42# happyReduction_205 -happyReduction_205 happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymOpenBrace happy_var_1) -> - case happyOutTok happy_x_2 of { (TokSymbol SymCloseBrace happy_var_2) -> - happyIn52 - (let r = fuseRange happy_var_1 happy_var_2 in HiddenArg r $ unnamed $ Absurd r - )}} - -happyReduce_206 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_206 = happySpecReduce_1 43# happyReduction_206 -happyReduction_206 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymQuestionMark happy_var_1) -> - happyIn53 - (QuestionMark (getRange happy_var_1) Nothing - )} - -happyReduce_207 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_207 = happySpecReduce_1 43# happyReduction_207 -happyReduction_207 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymUnderscore happy_var_1) -> - happyIn53 - (Underscore (getRange happy_var_1) Nothing - )} - -happyReduce_208 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_208 = happySpecReduce_1 43# happyReduction_208 -happyReduction_208 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwProp happy_var_1) -> - happyIn53 - (Prop (getRange happy_var_1) - )} - -happyReduce_209 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_209 = happySpecReduce_1 43# happyReduction_209 -happyReduction_209 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwSet happy_var_1) -> - happyIn53 - (Set (getRange happy_var_1) - )} - -happyReduce_210 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_210 = happySpecReduce_1 43# happyReduction_210 -happyReduction_210 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwQuote happy_var_1) -> - happyIn53 - (Quote (getRange happy_var_1) - )} - -happyReduce_211 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_211 = happySpecReduce_1 43# happyReduction_211 -happyReduction_211 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwQuoteTerm happy_var_1) -> - happyIn53 - (QuoteTerm (getRange happy_var_1) - )} - -happyReduce_212 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_212 = happySpecReduce_1 43# happyReduction_212 -happyReduction_212 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwQuoteContext happy_var_1) -> - happyIn53 - (QuoteContext (getRange happy_var_1) - )} - -happyReduce_213 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_213 = happySpecReduce_1 43# happyReduction_213 -happyReduction_213 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwUnquote happy_var_1) -> - happyIn53 - (Unquote (getRange happy_var_1) - )} - -happyReduce_214 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_214 = happySpecReduce_1 43# happyReduction_214 -happyReduction_214 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSetN happy_var_1) -> - happyIn53 - (SetN (getRange (fst happy_var_1)) (snd happy_var_1) - )} - -happyReduce_215 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_215 = happySpecReduce_1 43# happyReduction_215 -happyReduction_215 happy_x_1 - = case happyOutTok happy_x_1 of { (TokPropN happy_var_1) -> - happyIn53 - (PropN (getRange (fst happy_var_1)) (snd happy_var_1) - )} - -happyReduce_216 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_216 = happySpecReduce_3 43# happyReduction_216 -happyReduction_216 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymDoubleOpenBrace happy_var_1) -> - case happyOut43 happy_x_2 of { happy_var_2 -> - case happyOut21 happy_x_3 of { happy_var_3 -> - happyIn53 - (InstanceArg (getRange (happy_var_1,happy_var_2,happy_var_3)) (maybeNamed happy_var_2) - )}}} - -happyReduce_217 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_217 = happySpecReduce_3 43# happyReduction_217 -happyReduction_217 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymOpenIdiomBracket happy_var_1) -> - case happyOut43 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { (TokSymbol SymCloseIdiomBracket happy_var_3) -> - happyIn53 - (IdiomBrackets (getRange (happy_var_1,happy_var_2,happy_var_3)) happy_var_2 - )}}} - -happyReduce_218 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_218 = happySpecReduce_2 43# happyReduction_218 -happyReduction_218 happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymOpenParen happy_var_1) -> - case happyOutTok happy_x_2 of { (TokSymbol SymCloseParen happy_var_2) -> - happyIn53 - (Absurd (fuseRange happy_var_1 happy_var_2) - )}} - -happyReduce_219 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_219 = happySpecReduce_2 43# happyReduction_219 -happyReduction_219 happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymDoubleOpenBrace happy_var_1) -> - case happyOut21 happy_x_2 of { happy_var_2 -> - happyIn53 - (let r = fuseRange happy_var_1 happy_var_2 in InstanceArg r $ unnamed $ Absurd r - )}} - -happyReduce_220 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_220 = happySpecReduce_3 43# happyReduction_220 -happyReduction_220 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut19 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { (TokSymbol SymAs happy_var_2) -> - case happyOut55 happy_x_3 of { happy_var_3 -> - happyIn53 - (As (getRange (happy_var_1,happy_var_2,happy_var_3)) happy_var_1 happy_var_3 - )}}} - -happyReduce_221 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_221 = happySpecReduce_2 43# happyReduction_221 -happyReduction_221 happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymDot happy_var_1) -> - case happyOut55 happy_x_2 of { happy_var_2 -> - happyIn53 - (Dot (fuseRange happy_var_1 happy_var_2) happy_var_2 - )}} - -happyReduce_222 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_222 = happyReduce 4# 43# happyReduction_222 -happyReduction_222 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_1 of { (TokKeyword KwRecord happy_var_1) -> - case happyOutTok happy_x_2 of { (TokSymbol SymOpenBrace happy_var_2) -> - case happyOut56 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymCloseBrace happy_var_4) -> - happyIn53 - (Rec (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4)) happy_var_3 - ) `HappyStk` happyRest}}}} - -happyReduce_223 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_223 = happyReduce 5# 43# happyReduction_223 -happyReduction_223 (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 { (TokKeyword KwRecord happy_var_1) -> - case happyOut53 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { (TokSymbol SymOpenBrace happy_var_3) -> - case happyOut60 happy_x_4 of { happy_var_4 -> - case happyOutTok happy_x_5 of { (TokSymbol SymCloseBrace happy_var_5) -> - happyIn53 - (RecUpdate (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4,happy_var_5)) happy_var_2 happy_var_4 - ) `HappyStk` happyRest}}}}} - -happyReduce_224 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_224 = happySpecReduce_1 43# happyReduction_224 -happyReduction_224 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymEllipsis happy_var_1) -> - happyIn53 - (Ellipsis (getRange happy_var_1) - )} - -happyReduce_225 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_225 = happySpecReduce_1 43# happyReduction_225 -happyReduction_225 happy_x_1 - = case happyOut54 happy_x_1 of { happy_var_1 -> - happyIn53 - (happy_var_1 - )} - -happyReduce_226 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_226 = happySpecReduce_1 44# happyReduction_226 -happyReduction_226 happy_x_1 - = case happyOut29 happy_x_1 of { happy_var_1 -> - happyIn54 - (Ident happy_var_1 - )} - -happyReduce_227 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_227 = happySpecReduce_1 44# happyReduction_227 -happyReduction_227 happy_x_1 - = case happyOutTok happy_x_1 of { (TokLiteral happy_var_1) -> - happyIn54 - (Lit happy_var_1 - )} - -happyReduce_228 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_228 = happySpecReduce_3 44# happyReduction_228 -happyReduction_228 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymOpenParen happy_var_1) -> - case happyOut43 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { (TokSymbol SymCloseParen happy_var_3) -> - happyIn54 - (Paren (getRange (happy_var_1,happy_var_2,happy_var_3)) happy_var_2 - )}}} - -happyReduce_229 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_229 = happySpecReduce_1 45# happyReduction_229 -happyReduction_229 happy_x_1 - = case happyOut52 happy_x_1 of { happy_var_1 -> - happyIn55 - (happy_var_1 - )} - -happyReduce_230 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_230 = happySpecReduce_1 45# happyReduction_230 -happyReduction_230 happy_x_1 - = case happyOut53 happy_x_1 of { happy_var_1 -> - happyIn55 - (happy_var_1 - )} - -happyReduce_231 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_231 = happySpecReduce_0 46# happyReduction_231 -happyReduction_231 = happyIn56 - ([] - ) - -happyReduce_232 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_232 = happySpecReduce_1 46# happyReduction_232 -happyReduction_232 happy_x_1 - = case happyOut57 happy_x_1 of { happy_var_1 -> - happyIn56 - (happy_var_1 - )} - -happyReduce_233 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_233 = happySpecReduce_1 47# happyReduction_233 -happyReduction_233 happy_x_1 - = case happyOut58 happy_x_1 of { happy_var_1 -> - happyIn57 - ([happy_var_1] - )} - -happyReduce_234 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_234 = happySpecReduce_3 47# happyReduction_234 -happyReduction_234 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut58 happy_x_1 of { happy_var_1 -> - case happyOut57 happy_x_3 of { happy_var_3 -> - happyIn57 - (happy_var_1 : happy_var_3 - )}} - -happyReduce_235 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_235 = happySpecReduce_1 48# happyReduction_235 -happyReduction_235 happy_x_1 - = case happyOut62 happy_x_1 of { happy_var_1 -> - happyIn58 - (Left happy_var_1 - )} - -happyReduce_236 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_236 = happySpecReduce_1 48# happyReduction_236 -happyReduction_236 happy_x_1 - = case happyOut59 happy_x_1 of { happy_var_1 -> - happyIn58 - (Right happy_var_1 - )} - -happyReduce_237 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_237 = happySpecReduce_3 49# happyReduction_237 -happyReduction_237 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut30 happy_x_1 of { happy_var_1 -> - case happyOut138 happy_x_2 of { happy_var_2 -> - case happyOut88 happy_x_3 of { happy_var_3 -> - happyIn59 - (ModuleAssignment happy_var_1 happy_var_2 happy_var_3 - )}}} - -happyReduce_238 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_238 = happySpecReduce_0 50# happyReduction_238 -happyReduction_238 = happyIn60 - ([] - ) - -happyReduce_239 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_239 = happySpecReduce_1 50# happyReduction_239 -happyReduction_239 happy_x_1 - = case happyOut61 happy_x_1 of { happy_var_1 -> - happyIn60 - (happy_var_1 - )} - -happyReduce_240 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_240 = happySpecReduce_1 51# happyReduction_240 -happyReduction_240 happy_x_1 - = case happyOut62 happy_x_1 of { happy_var_1 -> - happyIn61 - ([happy_var_1] - )} - -happyReduce_241 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_241 = happySpecReduce_3 51# happyReduction_241 -happyReduction_241 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut62 happy_x_1 of { happy_var_1 -> - case happyOut61 happy_x_3 of { happy_var_3 -> - happyIn61 - (happy_var_1 : happy_var_3 - )}} - -happyReduce_242 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_242 = happySpecReduce_3 52# happyReduction_242 -happyReduction_242 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut19 happy_x_1 of { happy_var_1 -> - case happyOut43 happy_x_3 of { happy_var_3 -> - happyIn62 - (FieldAssignment happy_var_1 happy_var_3 - )}} - -happyReduce_243 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_243 = happySpecReduce_2 53# happyReduction_243 -happyReduction_243 happy_x_2 - happy_x_1 - = case happyOut64 happy_x_1 of { happy_var_1 -> - happyIn63 - (happy_var_1 - )} - -happyReduce_244 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_244 = happySpecReduce_1 54# happyReduction_244 -happyReduction_244 happy_x_1 - = case happyOut65 happy_x_1 of { happy_var_1 -> - happyIn64 - (happy_var_1 - )} - -happyReduce_245 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_245 = happySpecReduce_2 55# happyReduction_245 -happyReduction_245 happy_x_2 - happy_x_1 - = case happyOut66 happy_x_1 of { happy_var_1 -> - case happyOut65 happy_x_2 of { happy_var_2 -> - happyIn65 - (happy_var_1 : happy_var_2 - )}} - -happyReduce_246 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_246 = happySpecReduce_1 55# happyReduction_246 -happyReduction_246 happy_x_1 - = case happyOut66 happy_x_1 of { happy_var_1 -> - happyIn65 - ([happy_var_1] - )} - -happyReduce_247 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_247 = happyReduce 4# 56# happyReduction_247 -happyReduction_247 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_2 of { (TokSymbol SymOpenParen happy_var_2) -> - case happyOut69 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymCloseParen happy_var_4) -> - happyIn66 - (setRange (getRange (happy_var_2,happy_var_3,happy_var_4)) $ - setRelevance Irrelevant happy_var_3 - ) `HappyStk` happyRest}}} - -happyReduce_248 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_248 = happyReduce 4# 56# happyReduction_248 -happyReduction_248 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_2 of { (TokSymbol SymOpenBrace happy_var_2) -> - case happyOut67 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymCloseBrace happy_var_4) -> - happyIn66 - (setRange (getRange (happy_var_2,happy_var_3,happy_var_4)) $ - setHiding Hidden $ - setRelevance Irrelevant happy_var_3 - ) `HappyStk` happyRest}}} - -happyReduce_249 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_249 = happyReduce 4# 56# happyReduction_249 -happyReduction_249 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_2 of { (TokSymbol SymDoubleOpenBrace happy_var_2) -> - case happyOut67 happy_x_3 of { happy_var_3 -> - case happyOut21 happy_x_4 of { happy_var_4 -> - happyIn66 - (setRange (getRange (happy_var_2,happy_var_3,happy_var_4)) $ - makeInstance $ - setRelevance Irrelevant happy_var_3 - ) `HappyStk` happyRest}}} - -happyReduce_250 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_250 = happyReduce 4# 56# happyReduction_250 -happyReduction_250 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_2 of { (TokSymbol SymOpenParen happy_var_2) -> - case happyOut69 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymCloseParen happy_var_4) -> - happyIn66 - (setRange (getRange (happy_var_2,happy_var_3,happy_var_4)) $ - setRelevance NonStrict happy_var_3 - ) `HappyStk` happyRest}}} - -happyReduce_251 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_251 = happyReduce 4# 56# happyReduction_251 -happyReduction_251 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_2 of { (TokSymbol SymOpenBrace happy_var_2) -> - case happyOut67 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymCloseBrace happy_var_4) -> - happyIn66 - (setRange (getRange (happy_var_2,happy_var_3,happy_var_4)) $ - setHiding Hidden $ - setRelevance NonStrict happy_var_3 - ) `HappyStk` happyRest}}} - -happyReduce_252 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_252 = happyReduce 4# 56# happyReduction_252 -happyReduction_252 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_2 of { (TokSymbol SymDoubleOpenBrace happy_var_2) -> - case happyOut67 happy_x_3 of { happy_var_3 -> - case happyOut21 happy_x_4 of { happy_var_4 -> - happyIn66 - (setRange (getRange (happy_var_2,happy_var_3,happy_var_4)) $ - makeInstance $ - setRelevance NonStrict happy_var_3 - ) `HappyStk` happyRest}}} - -happyReduce_253 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_253 = happySpecReduce_3 56# happyReduction_253 -happyReduction_253 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymOpenParen happy_var_1) -> - case happyOut69 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { (TokSymbol SymCloseParen happy_var_3) -> - happyIn66 - (setRange (getRange (happy_var_1,happy_var_2,happy_var_3)) happy_var_2 - )}}} - -happyReduce_254 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_254 = happySpecReduce_3 56# happyReduction_254 -happyReduction_254 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymOpenParen happy_var_1) -> - case happyOut70 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { (TokSymbol SymCloseParen happy_var_3) -> - happyIn66 - (setRange (getRange (happy_var_1,happy_var_2,happy_var_3)) happy_var_2 - )}}} - -happyReduce_255 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_255 = happySpecReduce_3 56# happyReduction_255 -happyReduction_255 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymDoubleOpenBrace happy_var_1) -> - case happyOut67 happy_x_2 of { happy_var_2 -> - case happyOut21 happy_x_3 of { happy_var_3 -> - happyIn66 - (setRange (getRange (happy_var_1,happy_var_2,happy_var_3)) $ - makeInstance happy_var_2 - )}}} - -happyReduce_256 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_256 = happySpecReduce_3 56# happyReduction_256 -happyReduction_256 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymDoubleOpenBrace happy_var_1) -> - case happyOut68 happy_x_2 of { happy_var_2 -> - case happyOut21 happy_x_3 of { happy_var_3 -> - happyIn66 - (setRange (getRange (happy_var_1,happy_var_2,happy_var_3)) $ - makeInstance happy_var_2 - )}}} - -happyReduce_257 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_257 = happySpecReduce_3 56# happyReduction_257 -happyReduction_257 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymOpenBrace happy_var_1) -> - case happyOut67 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { (TokSymbol SymCloseBrace happy_var_3) -> - happyIn66 - (setRange (getRange (happy_var_1,happy_var_2,happy_var_3)) $ - setHiding Hidden happy_var_2 - )}}} - -happyReduce_258 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_258 = happySpecReduce_3 56# happyReduction_258 -happyReduction_258 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymOpenBrace happy_var_1) -> - case happyOut68 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { (TokSymbol SymCloseBrace happy_var_3) -> - happyIn66 - (setRange (getRange (happy_var_1,happy_var_2,happy_var_3)) $ - setHiding Hidden happy_var_2 - )}}} - -happyReduce_259 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_259 = happySpecReduce_3 56# happyReduction_259 -happyReduction_259 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymOpenParen happy_var_1) -> - case happyOut137 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { (TokSymbol SymCloseParen happy_var_3) -> - happyIn66 - (TLet (getRange (happy_var_1,happy_var_3)) happy_var_2 - )}}} - -happyReduce_260 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_260 = happyReduce 4# 56# happyReduction_260 -happyReduction_260 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_1 of { (TokSymbol SymOpenParen happy_var_1) -> - case happyOut181 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymCloseParen happy_var_4) -> - happyIn66 - (TLet (getRange (happy_var_1,happy_var_4)) happy_var_3 - ) `HappyStk` happyRest}}} - -happyReduce_261 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_261 = happySpecReduce_3 57# happyReduction_261 -happyReduction_261 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut33 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { (TokSymbol SymColon happy_var_2) -> - case happyOut43 happy_x_3 of { happy_var_3 -> - happyIn67 - (let r = getRange (happy_var_1,happy_var_2,happy_var_3) -- the range is approximate only for TypedBindings - in TBind r happy_var_1 happy_var_3 - )}}} - -happyReduce_262 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_262 = happyMonadReduce 4# 58# happyReduction_262 -happyReduction_262 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOut28 happy_x_1 of { happy_var_1 -> - case happyOut33 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { (TokSymbol SymColon happy_var_3) -> - case happyOut43 happy_x_4 of { happy_var_4 -> - ( do - let r = getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4) -- the range is approximate only for TypedBindings - xs <- mapM (applyAttrs happy_var_1) happy_var_2 - return $ TBind r xs happy_var_4)}}}}) - ) (\r -> happyReturn (happyIn68 r)) - -happyReduce_263 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_263 = happySpecReduce_3 59# happyReduction_263 -happyReduction_263 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut35 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { (TokSymbol SymColon happy_var_2) -> - case happyOut43 happy_x_3 of { happy_var_3 -> - happyIn69 - (let r = getRange (happy_var_1,happy_var_2,happy_var_3) -- the range is approximate only for TypedBindings - in TBind r happy_var_1 happy_var_3 - )}}} - -happyReduce_264 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_264 = happyMonadReduce 4# 60# happyReduction_264 -happyReduction_264 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOut28 happy_x_1 of { happy_var_1 -> - case happyOut35 happy_x_2 of { happy_var_2 -> - case happyOutTok happy_x_3 of { (TokSymbol SymColon happy_var_3) -> - case happyOut43 happy_x_4 of { happy_var_4 -> - ( do - let r = getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4) -- the range is approximate only for TypedBindings - xs <- mapM (applyAttrs happy_var_1) happy_var_2 - return $ TBind r xs happy_var_4)}}}}) - ) (\r -> happyReturn (happyIn70 r)) - -happyReduce_265 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_265 = happyMonadReduce 2# 61# happyReduction_265 -happyReduction_265 (happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOut73 happy_x_1 of { happy_var_1 -> - ( - case reverse happy_var_1 of - Left _ : _ -> parseError "Absurd lambda cannot have a body." - _ : _ -> return [ b | Right b <- happy_var_1 ] - [] -> parsePanic "Empty LamBinds")}) - ) (\r -> happyReturn (happyIn71 r)) - -happyReduce_266 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_266 = happyMonadReduce 1# 62# happyReduction_266 -happyReduction_266 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOut74 happy_x_1 of { happy_var_1 -> - ( - case happy_var_1 of - Left lb -> case reverse lb of - Right _ : _ -> parseError "Missing body for lambda" - Left h : _ -> return $ Left ([ b | Right b <- init lb], h) - _ -> parseError "Unsupported variant of lambda" - Right es -> return $ Right es)}) - ) (\r -> happyReturn (happyIn72 r)) - -happyReduce_267 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_267 = happySpecReduce_2 63# happyReduction_267 -happyReduction_267 happy_x_2 - happy_x_1 - = case happyOut83 happy_x_1 of { happy_var_1 -> - case happyOut73 happy_x_2 of { happy_var_2 -> - happyIn73 - (map Right happy_var_1 ++ happy_var_2 - )}} - -happyReduce_268 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_268 = happySpecReduce_2 63# happyReduction_268 -happyReduction_268 happy_x_2 - happy_x_1 - = case happyOut66 happy_x_1 of { happy_var_1 -> - case happyOut73 happy_x_2 of { happy_var_2 -> - happyIn73 - (Right (DomainFull happy_var_1) : happy_var_2 - )}} - -happyReduce_269 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_269 = happySpecReduce_1 63# happyReduction_269 -happyReduction_269 happy_x_1 - = case happyOut83 happy_x_1 of { happy_var_1 -> - happyIn73 - (map Right happy_var_1 - )} - -happyReduce_270 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_270 = happySpecReduce_1 63# happyReduction_270 -happyReduction_270 happy_x_1 - = case happyOut66 happy_x_1 of { happy_var_1 -> - happyIn73 - ([Right $ DomainFull happy_var_1] - )} - -happyReduce_271 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_271 = happySpecReduce_2 63# happyReduction_271 -happyReduction_271 happy_x_2 - happy_x_1 - = happyIn73 - ([Left NotHidden] - ) - -happyReduce_272 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_272 = happySpecReduce_2 63# happyReduction_272 -happyReduction_272 happy_x_2 - happy_x_1 - = happyIn73 - ([Left Hidden] - ) - -happyReduce_273 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_273 = happySpecReduce_2 63# happyReduction_273 -happyReduction_273 happy_x_2 - happy_x_1 - = happyIn73 - ([Left (Instance NoOverlap)] - ) - -happyReduce_274 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_274 = happySpecReduce_2 64# happyReduction_274 -happyReduction_274 happy_x_2 - happy_x_1 - = case happyOut83 happy_x_1 of { happy_var_1 -> - case happyOut73 happy_x_2 of { happy_var_2 -> - happyIn74 - (Left $ map Right happy_var_1 ++ happy_var_2 - )}} - -happyReduce_275 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_275 = happySpecReduce_2 64# happyReduction_275 -happyReduction_275 happy_x_2 - happy_x_1 - = case happyOut66 happy_x_1 of { happy_var_1 -> - case happyOut73 happy_x_2 of { happy_var_2 -> - happyIn74 - (Left $ Right (DomainFull happy_var_1) : happy_var_2 - )}} - -happyReduce_276 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_276 = happySpecReduce_1 64# happyReduction_276 -happyReduction_276 happy_x_1 - = case happyOut84 happy_x_1 of { happy_var_1 -> - happyIn74 - (case happy_var_1 of - Left lb -> Left $ map Right lb - Right es -> Right es - )} - -happyReduce_277 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_277 = happySpecReduce_1 64# happyReduction_277 -happyReduction_277 happy_x_1 - = case happyOut66 happy_x_1 of { happy_var_1 -> - happyIn74 - (Left [Right $ DomainFull happy_var_1] - )} - -happyReduce_278 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_278 = happySpecReduce_2 64# happyReduction_278 -happyReduction_278 happy_x_2 - happy_x_1 - = happyIn74 - (Left [Left NotHidden] - ) - -happyReduce_279 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_279 = happySpecReduce_2 64# happyReduction_279 -happyReduction_279 happy_x_2 - happy_x_1 - = happyIn74 - (Left [Left Hidden] - ) - -happyReduce_280 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_280 = happySpecReduce_2 64# happyReduction_280 -happyReduction_280 happy_x_2 - happy_x_1 - = happyIn74 - (Left [Left (Instance NoOverlap)] - ) - -happyReduce_281 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_281 = happyMonadReduce 3# 65# happyReduction_281 -happyReduction_281 (happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOut51 happy_x_1 of { happy_var_1 -> - case happyOut43 happy_x_3 of { happy_var_3 -> - ( do - p <- exprToLHS (RawApp (getRange happy_var_1) happy_var_1) ; - return LamClause{ lamLHS = p [] [] - , lamRHS = RHS happy_var_3 - , lamWhere = NoWhere - , lamCatchAll = False })}}) - ) (\r -> happyReturn (happyIn75 r)) - -happyReduce_282 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_282 = happyMonadReduce 4# 65# happyReduction_282 -happyReduction_282 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOut51 happy_x_2 of { happy_var_2 -> - case happyOut43 happy_x_4 of { happy_var_4 -> - ( do - p <- exprToLHS (RawApp (getRange happy_var_2) happy_var_2) ; - return LamClause{ lamLHS = p [] [] - , lamRHS = RHS happy_var_4 - , lamWhere = NoWhere - , lamCatchAll = True })}}) - ) (\r -> happyReturn (happyIn75 r)) - -happyReduce_283 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_283 = happyMonadReduce 1# 66# happyReduction_283 -happyReduction_283 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOut46 happy_x_1 of { happy_var_1 -> - ( do - p <- exprToLHS (RawApp (getRange happy_var_1) happy_var_1); - return LamClause{ lamLHS = p [] [] - , lamRHS = AbsurdRHS - , lamWhere = NoWhere - , lamCatchAll = False })}) - ) (\r -> happyReturn (happyIn76 r)) - -happyReduce_284 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_284 = happyMonadReduce 2# 66# happyReduction_284 -happyReduction_284 (happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOut46 happy_x_2 of { happy_var_2 -> - ( do - p <- exprToLHS (RawApp (getRange happy_var_2) happy_var_2); - return LamClause{ lamLHS = p [] [] - , lamRHS = AbsurdRHS - , lamWhere = NoWhere - , lamCatchAll = True })}) - ) (\r -> happyReturn (happyIn76 r)) - -happyReduce_285 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_285 = happySpecReduce_1 67# happyReduction_285 -happyReduction_285 happy_x_1 - = case happyOut75 happy_x_1 of { happy_var_1 -> - happyIn77 - (happy_var_1 - )} - -happyReduce_286 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_286 = happySpecReduce_1 67# happyReduction_286 -happyReduction_286 happy_x_1 - = case happyOut76 happy_x_1 of { happy_var_1 -> - happyIn77 - (happy_var_1 - )} - -happyReduce_287 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_287 = happySpecReduce_3 68# happyReduction_287 -happyReduction_287 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut78 happy_x_1 of { happy_var_1 -> - case happyOut77 happy_x_3 of { happy_var_3 -> - happyIn78 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_288 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_288 = happySpecReduce_3 68# happyReduction_288 -happyReduction_288 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut76 happy_x_1 of { happy_var_1 -> - case happyOut77 happy_x_3 of { happy_var_3 -> - happyIn78 - ([happy_var_3, happy_var_1] - )}} - -happyReduce_289 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_289 = happySpecReduce_1 68# happyReduction_289 -happyReduction_289 happy_x_1 - = case happyOut75 happy_x_1 of { happy_var_1 -> - happyIn78 - ([happy_var_1] - )} - -happyReduce_290 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_290 = happySpecReduce_3 69# happyReduction_290 -happyReduction_290 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut79 happy_x_1 of { happy_var_1 -> - case happyOut77 happy_x_3 of { happy_var_3 -> - happyIn79 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_291 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_291 = happySpecReduce_1 69# happyReduction_291 -happyReduction_291 happy_x_1 - = case happyOut77 happy_x_1 of { happy_var_1 -> - happyIn79 - ([happy_var_1] - )} - -happyReduce_292 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_292 = happySpecReduce_2 70# happyReduction_292 -happyReduction_292 happy_x_2 - happy_x_1 - = case happyOut81 happy_x_1 of { happy_var_1 -> - happyIn80 - (happy_var_1 - )} - -happyReduce_293 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_293 = happySpecReduce_2 71# happyReduction_293 -happyReduction_293 happy_x_2 - happy_x_1 - = case happyOut83 happy_x_1 of { happy_var_1 -> - case happyOut81 happy_x_2 of { happy_var_2 -> - happyIn81 - (happy_var_1 ++ happy_var_2 - )}} - -happyReduce_294 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_294 = happySpecReduce_2 71# happyReduction_294 -happyReduction_294 happy_x_2 - happy_x_1 - = case happyOut66 happy_x_1 of { happy_var_1 -> - case happyOut81 happy_x_2 of { happy_var_2 -> - happyIn81 - (DomainFull happy_var_1 : happy_var_2 - )}} - -happyReduce_295 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_295 = happySpecReduce_1 71# happyReduction_295 -happyReduction_295 happy_x_1 - = case happyOut83 happy_x_1 of { happy_var_1 -> - happyIn81 - (happy_var_1 - )} - -happyReduce_296 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_296 = happySpecReduce_1 71# happyReduction_296 -happyReduction_296 happy_x_1 - = case happyOut66 happy_x_1 of { happy_var_1 -> - happyIn81 - ([DomainFull happy_var_1] - )} - -happyReduce_297 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_297 = happySpecReduce_2 72# happyReduction_297 -happyReduction_297 happy_x_2 - happy_x_1 - = case happyOut83 happy_x_1 of { happy_var_1 -> - case happyOut82 happy_x_2 of { happy_var_2 -> - happyIn82 - (happy_var_1 ++ happy_var_2 - )}} - -happyReduce_298 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_298 = happySpecReduce_2 72# happyReduction_298 -happyReduction_298 happy_x_2 - happy_x_1 - = case happyOut66 happy_x_1 of { happy_var_1 -> - case happyOut82 happy_x_2 of { happy_var_2 -> - happyIn82 - (DomainFull happy_var_1 : happy_var_2 - )}} - -happyReduce_299 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_299 = happySpecReduce_0 72# happyReduction_299 -happyReduction_299 = happyIn82 - ([] - ) - -happyReduce_300 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_300 = happyMonadReduce 1# 73# happyReduction_300 -happyReduction_300 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOut84 happy_x_1 of { happy_var_1 -> - ( case happy_var_1 of - Left lbs -> return lbs - Right _ -> parseError "expected sequence of bound identifiers, not absurd pattern")}) - ) (\r -> happyReturn (happyIn83 r)) - -happyReduce_301 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_301 = happySpecReduce_1 74# happyReduction_301 -happyReduction_301 happy_x_1 - = case happyOut31 happy_x_1 of { happy_var_1 -> - happyIn84 - (Left [DomainFree $ defaultNamedArg $ mkBoundName_ happy_var_1] - )} - -happyReduce_302 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_302 = happySpecReduce_2 74# happyReduction_302 -happyReduction_302 happy_x_2 - happy_x_1 - = case happyOut31 happy_x_2 of { happy_var_2 -> - happyIn84 - (Left [DomainFree $ setRelevance Irrelevant $ defaultNamedArg $ mkBoundName_ happy_var_2] - )} - -happyReduce_303 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_303 = happySpecReduce_2 74# happyReduction_303 -happyReduction_303 happy_x_2 - happy_x_1 - = case happyOut31 happy_x_2 of { happy_var_2 -> - happyIn84 - (Left [DomainFree $ setRelevance NonStrict $ defaultNamedArg $ mkBoundName_ happy_var_2] - )} - -happyReduce_304 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_304 = happySpecReduce_3 74# happyReduction_304 -happyReduction_304 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut34 happy_x_2 of { happy_var_2 -> - happyIn84 - (mapLeft (map DomainFree) happy_var_2 - )} - -happyReduce_305 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_305 = happyMonadReduce 4# 74# happyReduction_305 -happyReduction_305 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOut28 happy_x_2 of { happy_var_2 -> - case happyOut34 happy_x_3 of { happy_var_3 -> - ( applyAttrs happy_var_2 defaultArgInfo <&> \ ai -> - mapLeft (map (DomainFree . setArgInfo ai)) happy_var_3)}}) - ) (\r -> happyReturn (happyIn84 r)) - -happyReduce_306 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_306 = happySpecReduce_3 74# happyReduction_306 -happyReduction_306 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut34 happy_x_2 of { happy_var_2 -> - happyIn84 - (mapLeft (map (DomainFree . setHiding Hidden)) happy_var_2 - )} - -happyReduce_307 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_307 = happyMonadReduce 4# 74# happyReduction_307 -happyReduction_307 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOut28 happy_x_2 of { happy_var_2 -> - case happyOut34 happy_x_3 of { happy_var_3 -> - ( applyAttrs happy_var_2 defaultArgInfo <&> \ ai -> - mapLeft (map (DomainFree . setHiding Hidden . setArgInfo ai)) happy_var_3)}}) - ) (\r -> happyReturn (happyIn84 r)) - -happyReduce_308 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_308 = happySpecReduce_3 74# happyReduction_308 -happyReduction_308 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut33 happy_x_2 of { happy_var_2 -> - happyIn84 - (Left $ map (DomainFree . makeInstance) happy_var_2 - )} - -happyReduce_309 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_309 = happyMonadReduce 4# 74# happyReduction_309 -happyReduction_309 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOut28 happy_x_2 of { happy_var_2 -> - case happyOut33 happy_x_3 of { happy_var_3 -> - ( applyAttrs happy_var_2 defaultArgInfo <&> \ ai -> - Left $ map (DomainFree . makeInstance . setArgInfo ai) happy_var_3)}}) - ) (\r -> happyReturn (happyIn84 r)) - -happyReduce_310 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_310 = happyReduce 4# 74# happyReduction_310 -happyReduction_310 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut33 happy_x_3 of { happy_var_3 -> - happyIn84 - (Left $ map (DomainFree . setHiding Hidden . setRelevance Irrelevant) happy_var_3 - ) `HappyStk` happyRest} - -happyReduce_311 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_311 = happyReduce 4# 74# happyReduction_311 -happyReduction_311 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut33 happy_x_3 of { happy_var_3 -> - happyIn84 - (Left $ map (DomainFree . makeInstance . setRelevance Irrelevant) happy_var_3 - ) `HappyStk` happyRest} - -happyReduce_312 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_312 = happyReduce 4# 74# happyReduction_312 -happyReduction_312 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut33 happy_x_3 of { happy_var_3 -> - happyIn84 - (Left $ map (DomainFree . setHiding Hidden . setRelevance NonStrict) happy_var_3 - ) `HappyStk` happyRest} - -happyReduce_313 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_313 = happyReduce 4# 74# happyReduction_313 -happyReduction_313 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut33 happy_x_3 of { happy_var_3 -> - happyIn84 - (Left $ map (DomainFree . makeInstance . setRelevance NonStrict) happy_var_3 - ) `HappyStk` happyRest} - -happyReduce_314 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_314 = happySpecReduce_1 75# happyReduction_314 -happyReduction_314 happy_x_1 - = case happyOut86 happy_x_1 of { happy_var_1 -> - happyIn85 - ([happy_var_1] - )} - -happyReduce_315 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_315 = happySpecReduce_2 75# happyReduction_315 -happyReduction_315 happy_x_2 - happy_x_1 - = case happyOut86 happy_x_1 of { happy_var_1 -> - happyIn85 - ([happy_var_1] - )} - -happyReduce_316 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_316 = happySpecReduce_3 75# happyReduction_316 -happyReduction_316 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut86 happy_x_1 of { happy_var_1 -> - case happyOut85 happy_x_3 of { happy_var_3 -> - happyIn85 - (happy_var_1 : happy_var_3 - )}} - -happyReduce_317 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_317 = happyMonadReduce 2# 76# happyReduction_317 -happyReduction_317 (happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOut43 happy_x_1 of { happy_var_1 -> - case happyOut87 happy_x_2 of { happy_var_2 -> - ( buildDoStmt happy_var_1 happy_var_2)}}) - ) (\r -> happyReturn (happyIn86 r)) - -happyReduce_318 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_318 = happySpecReduce_0 77# happyReduction_318 -happyReduction_318 = happyIn87 - ([] - ) - -happyReduce_319 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_319 = happyReduce 4# 77# happyReduction_319 -happyReduction_319 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut79 happy_x_3 of { happy_var_3 -> - happyIn87 - (reverse happy_var_3 - ) `HappyStk` happyRest} - -happyReduce_320 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_320 = happyMonadReduce 1# 78# happyReduction_320 -happyReduction_320 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOut89 happy_x_1 of { happy_var_1 -> - ( mergeImportDirectives happy_var_1)}) - ) (\r -> happyReturn (happyIn88 r)) - -happyReduce_321 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_321 = happySpecReduce_2 79# happyReduction_321 -happyReduction_321 happy_x_2 - happy_x_1 - = case happyOut90 happy_x_1 of { happy_var_1 -> - case happyOut89 happy_x_2 of { happy_var_2 -> - happyIn89 - (happy_var_1 : happy_var_2 - )}} - -happyReduce_322 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_322 = happySpecReduce_0 79# happyReduction_322 -happyReduction_322 = happyIn89 - ([] - ) - -happyReduce_323 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_323 = happySpecReduce_1 80# happyReduction_323 -happyReduction_323 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwPublic happy_var_1) -> - happyIn90 - (defaultImportDir { importDirRange = getRange happy_var_1, publicOpen = True } - )} - -happyReduce_324 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_324 = happySpecReduce_1 80# happyReduction_324 -happyReduction_324 happy_x_1 - = case happyOut91 happy_x_1 of { happy_var_1 -> - happyIn90 - (defaultImportDir { importDirRange = snd happy_var_1, using = fst happy_var_1 } - )} - -happyReduce_325 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_325 = happySpecReduce_1 80# happyReduction_325 -happyReduction_325 happy_x_1 - = case happyOut92 happy_x_1 of { happy_var_1 -> - happyIn90 - (defaultImportDir { importDirRange = snd happy_var_1, hiding = fst happy_var_1 } - )} - -happyReduce_326 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_326 = happySpecReduce_1 80# happyReduction_326 -happyReduction_326 happy_x_1 - = case happyOut93 happy_x_1 of { happy_var_1 -> - happyIn90 - (defaultImportDir { importDirRange = snd happy_var_1, impRenaming = fst happy_var_1 } - )} - -happyReduce_327 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_327 = happyReduce 4# 81# happyReduction_327 -happyReduction_327 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_1 of { (TokKeyword KwUsing happy_var_1) -> - case happyOutTok happy_x_2 of { (TokSymbol SymOpenParen happy_var_2) -> - case happyOut98 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymCloseParen happy_var_4) -> - happyIn91 - ((Using happy_var_3 , getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4)) - ) `HappyStk` happyRest}}}} - -happyReduce_328 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_328 = happyReduce 4# 82# happyReduction_328 -happyReduction_328 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_1 of { (TokKeyword KwHiding happy_var_1) -> - case happyOutTok happy_x_2 of { (TokSymbol SymOpenParen happy_var_2) -> - case happyOut98 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymCloseParen happy_var_4) -> - happyIn92 - ((happy_var_3 , getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4)) - ) `HappyStk` happyRest}}}} - -happyReduce_329 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_329 = happyReduce 4# 83# happyReduction_329 -happyReduction_329 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_1 of { (TokKeyword KwRenaming happy_var_1) -> - case happyOutTok happy_x_2 of { (TokSymbol SymOpenParen happy_var_2) -> - case happyOut94 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymCloseParen happy_var_4) -> - happyIn93 - ((happy_var_3 , getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4)) - ) `HappyStk` happyRest}}}} - -happyReduce_330 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_330 = happySpecReduce_3 83# happyReduction_330 -happyReduction_330 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwRenaming happy_var_1) -> - case happyOutTok happy_x_2 of { (TokSymbol SymOpenParen happy_var_2) -> - case happyOutTok happy_x_3 of { (TokSymbol SymCloseParen happy_var_3) -> - happyIn93 - (([] , getRange (happy_var_1,happy_var_2,happy_var_3)) - )}}} - -happyReduce_331 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_331 = happySpecReduce_3 84# happyReduction_331 -happyReduction_331 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut95 happy_x_1 of { happy_var_1 -> - case happyOut94 happy_x_3 of { happy_var_3 -> - happyIn94 - (happy_var_1 : happy_var_3 - )}} - -happyReduce_332 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_332 = happySpecReduce_1 84# happyReduction_332 -happyReduction_332 happy_x_1 - = case happyOut95 happy_x_1 of { happy_var_1 -> - happyIn94 - ([happy_var_1] - )} - -happyReduce_333 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_333 = happySpecReduce_3 85# happyReduction_333 -happyReduction_333 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut96 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { (TokKeyword KwTo happy_var_2) -> - case happyOut19 happy_x_3 of { happy_var_3 -> - happyIn95 - (Renaming happy_var_1 (setImportedName happy_var_1 happy_var_3) (getRange happy_var_2) - )}}} - -happyReduce_334 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_334 = happySpecReduce_2 86# happyReduction_334 -happyReduction_334 happy_x_2 - happy_x_1 - = case happyOut19 happy_x_2 of { happy_var_2 -> - happyIn96 - (ImportedName happy_var_2 - )} - -happyReduce_335 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_335 = happySpecReduce_3 86# happyReduction_335 -happyReduction_335 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut19 happy_x_3 of { happy_var_3 -> - happyIn96 - (ImportedModule happy_var_3 - )} - -happyReduce_336 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_336 = happySpecReduce_1 87# happyReduction_336 -happyReduction_336 happy_x_1 - = case happyOut19 happy_x_1 of { happy_var_1 -> - happyIn97 - (ImportedName happy_var_1 - )} - -happyReduce_337 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_337 = happySpecReduce_2 87# happyReduction_337 -happyReduction_337 happy_x_2 - happy_x_1 - = case happyOut19 happy_x_2 of { happy_var_2 -> - happyIn97 - (ImportedModule happy_var_2 - )} - -happyReduce_338 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_338 = happySpecReduce_0 88# happyReduction_338 -happyReduction_338 = happyIn98 - ([] - ) - -happyReduce_339 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_339 = happySpecReduce_1 88# happyReduction_339 -happyReduction_339 happy_x_1 - = case happyOut99 happy_x_1 of { happy_var_1 -> - happyIn98 - (happy_var_1 - )} - -happyReduce_340 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_340 = happySpecReduce_1 89# happyReduction_340 -happyReduction_340 happy_x_1 - = case happyOut97 happy_x_1 of { happy_var_1 -> - happyIn99 - ([happy_var_1] - )} - -happyReduce_341 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_341 = happySpecReduce_3 89# happyReduction_341 -happyReduction_341 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut97 happy_x_1 of { happy_var_1 -> - case happyOut99 happy_x_3 of { happy_var_3 -> - happyIn99 - (happy_var_1 : happy_var_3 - )}} - -happyReduce_342 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_342 = happyMonadReduce 3# 90# happyReduction_342 -happyReduction_342 (happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOut44 happy_x_1 of { happy_var_1 -> - case happyOut102 happy_x_2 of { happy_var_2 -> - case happyOut101 happy_x_3 of { happy_var_3 -> - ( exprToLHS happy_var_1 >>= \p -> return (p happy_var_2 happy_var_3))}}}) - ) (\r -> happyReturn (happyIn100 r)) - -happyReduce_343 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_343 = happySpecReduce_0 91# happyReduction_343 -happyReduction_343 = happyIn101 - ([] - ) - -happyReduce_344 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_344 = happySpecReduce_2 91# happyReduction_344 -happyReduction_344 happy_x_2 - happy_x_1 - = case happyOut43 happy_x_2 of { happy_var_2 -> - happyIn101 - (case happy_var_2 of { WithApp _ e es -> e : es; e -> [e] } - )} - -happyReduce_345 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_345 = happySpecReduce_0 92# happyReduction_345 -happyReduction_345 = happyIn102 - ([] - ) - -happyReduce_346 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_346 = happySpecReduce_2 92# happyReduction_346 -happyReduction_346 happy_x_2 - happy_x_1 - = case happyOut44 happy_x_2 of { happy_var_2 -> - happyIn102 - (case happy_var_2 of { WithApp _ e es -> e : es; e -> [e] } - )} - -happyReduce_347 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_347 = happySpecReduce_1 93# happyReduction_347 -happyReduction_347 happy_x_1 - = case happyOut43 happy_x_1 of { happy_var_1 -> - happyIn103 - (HoleContentExpr happy_var_1 - )} - -happyReduce_348 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_348 = happySpecReduce_1 93# happyReduction_348 -happyReduction_348 happy_x_1 - = case happyOut102 happy_x_1 of { happy_var_1 -> - happyIn103 - (HoleContentRewrite happy_var_1 - )} - -happyReduce_349 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_349 = happySpecReduce_0 94# happyReduction_349 -happyReduction_349 = happyIn104 - (NoWhere - ) - -happyReduce_350 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_350 = happySpecReduce_2 94# happyReduction_350 -happyReduction_350 happy_x_2 - happy_x_1 - = case happyOut182 happy_x_2 of { happy_var_2 -> - happyIn104 - (AnyWhere happy_var_2 - )} - -happyReduce_351 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_351 = happyReduce 4# 94# happyReduction_351 -happyReduction_351 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut19 happy_x_2 of { happy_var_2 -> - case happyOut182 happy_x_4 of { happy_var_4 -> - happyIn104 - (SomeWhere happy_var_2 PublicAccess happy_var_4 - ) `HappyStk` happyRest}} - -happyReduce_352 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_352 = happyReduce 4# 94# happyReduction_352 -happyReduction_352 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut142 happy_x_2 of { happy_var_2 -> - case happyOut182 happy_x_4 of { happy_var_4 -> - happyIn104 - (SomeWhere happy_var_2 PublicAccess happy_var_4 - ) `HappyStk` happyRest}} - -happyReduce_353 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_353 = happySpecReduce_2 95# happyReduction_353 -happyReduction_353 happy_x_2 - happy_x_1 - = case happyOut43 happy_x_1 of { happy_var_1 -> - case happyOut104 happy_x_2 of { happy_var_2 -> - happyIn105 - (ExprWhere happy_var_1 happy_var_2 - )}} - -happyReduce_354 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_354 = happySpecReduce_1 96# happyReduction_354 -happyReduction_354 happy_x_1 - = case happyOut117 happy_x_1 of { happy_var_1 -> - happyIn106 - (happy_var_1 - )} - -happyReduce_355 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_355 = happySpecReduce_1 96# happyReduction_355 -happyReduction_355 happy_x_1 - = case happyOut109 happy_x_1 of { happy_var_1 -> - happyIn106 - (happy_var_1 - )} - -happyReduce_356 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_356 = happySpecReduce_1 96# happyReduction_356 -happyReduction_356 happy_x_1 - = case happyOut111 happy_x_1 of { happy_var_1 -> - happyIn106 - ([happy_var_1] - )} - -happyReduce_357 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_357 = happySpecReduce_1 96# happyReduction_357 -happyReduction_357 happy_x_1 - = case happyOut112 happy_x_1 of { happy_var_1 -> - happyIn106 - ([happy_var_1] - )} - -happyReduce_358 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_358 = happySpecReduce_1 96# happyReduction_358 -happyReduction_358 happy_x_1 - = case happyOut113 happy_x_1 of { happy_var_1 -> - happyIn106 - ([happy_var_1] - )} - -happyReduce_359 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_359 = happySpecReduce_1 96# happyReduction_359 -happyReduction_359 happy_x_1 - = case happyOut114 happy_x_1 of { happy_var_1 -> - happyIn106 - ([happy_var_1] - )} - -happyReduce_360 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_360 = happySpecReduce_1 96# happyReduction_360 -happyReduction_360 happy_x_1 - = case happyOut116 happy_x_1 of { happy_var_1 -> - happyIn106 - ([happy_var_1] - )} - -happyReduce_361 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_361 = happySpecReduce_1 96# happyReduction_361 -happyReduction_361 happy_x_1 - = case happyOut118 happy_x_1 of { happy_var_1 -> - happyIn106 - (happy_var_1 - )} - -happyReduce_362 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_362 = happySpecReduce_1 96# happyReduction_362 -happyReduction_362 happy_x_1 - = case happyOut119 happy_x_1 of { happy_var_1 -> - happyIn106 - ([happy_var_1] - )} - -happyReduce_363 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_363 = happySpecReduce_1 96# happyReduction_363 -happyReduction_363 happy_x_1 - = case happyOut120 happy_x_1 of { happy_var_1 -> - happyIn106 - ([happy_var_1] - )} - -happyReduce_364 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_364 = happySpecReduce_1 96# happyReduction_364 -happyReduction_364 happy_x_1 - = case happyOut121 happy_x_1 of { happy_var_1 -> - happyIn106 - ([happy_var_1] - )} - -happyReduce_365 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_365 = happySpecReduce_1 96# happyReduction_365 -happyReduction_365 happy_x_1 - = case happyOut122 happy_x_1 of { happy_var_1 -> - happyIn106 - ([happy_var_1] - )} - -happyReduce_366 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_366 = happySpecReduce_1 96# happyReduction_366 -happyReduction_366 happy_x_1 - = case happyOut123 happy_x_1 of { happy_var_1 -> - happyIn106 - ([happy_var_1] - )} - -happyReduce_367 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_367 = happySpecReduce_1 96# happyReduction_367 -happyReduction_367 happy_x_1 - = case happyOut124 happy_x_1 of { happy_var_1 -> - happyIn106 - ([happy_var_1] - )} - -happyReduce_368 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_368 = happySpecReduce_1 96# happyReduction_368 -happyReduction_368 happy_x_1 - = case happyOut125 happy_x_1 of { happy_var_1 -> - happyIn106 - ([happy_var_1] - )} - -happyReduce_369 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_369 = happySpecReduce_1 96# happyReduction_369 -happyReduction_369 happy_x_1 - = case happyOut137 happy_x_1 of { happy_var_1 -> - happyIn106 - (happy_var_1 - )} - -happyReduce_370 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_370 = happySpecReduce_1 96# happyReduction_370 -happyReduction_370 happy_x_1 - = case happyOut140 happy_x_1 of { happy_var_1 -> - happyIn106 - ([happy_var_1] - )} - -happyReduce_371 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_371 = happySpecReduce_1 96# happyReduction_371 -happyReduction_371 happy_x_1 - = case happyOut141 happy_x_1 of { happy_var_1 -> - happyIn106 - ([happy_var_1] - )} - -happyReduce_372 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_372 = happySpecReduce_1 96# happyReduction_372 -happyReduction_372 happy_x_1 - = case happyOut144 happy_x_1 of { happy_var_1 -> - happyIn106 - ([happy_var_1] - )} - -happyReduce_373 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_373 = happySpecReduce_1 96# happyReduction_373 -happyReduction_373 happy_x_1 - = case happyOut127 happy_x_1 of { happy_var_1 -> - happyIn106 - ([happy_var_1] - )} - -happyReduce_374 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_374 = happySpecReduce_1 96# happyReduction_374 -happyReduction_374 happy_x_1 - = case happyOut128 happy_x_1 of { happy_var_1 -> - happyIn106 - ([happy_var_1] - )} - -happyReduce_375 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_375 = happySpecReduce_1 96# happyReduction_375 -happyReduction_375 happy_x_1 - = case happyOut126 happy_x_1 of { happy_var_1 -> - happyIn106 - ([happy_var_1] - )} - -happyReduce_376 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_376 = happySpecReduce_3 97# happyReduction_376 -happyReduction_376 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut20 happy_x_1 of { happy_var_1 -> - case happyOut43 happy_x_3 of { happy_var_3 -> - happyIn107 - (map (\ x -> typeSig defaultArgInfo x happy_var_3) happy_var_1 - )}} - -happyReduce_377 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_377 = happySpecReduce_3 98# happyReduction_377 -happyReduction_377 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut25 happy_x_1 of { happy_var_1 -> - case happyOut43 happy_x_3 of { happy_var_3 -> - happyIn108 - (map (fmap (\ x -> typeSig defaultArgInfo x happy_var_3)) happy_var_1 - )}} - -happyReduce_378 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_378 = happyMonadReduce 4# 98# happyReduction_378 -happyReduction_378 (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 { (TokKeyword KwOverlap happy_var_1) -> - case happyOut25 happy_x_2 of { happy_var_2 -> - case happyOut43 happy_x_4 of { happy_var_4 -> - ( - let setOverlap x = - case getHiding x of - Instance _ -> return $ makeInstance' YesOverlap x - _ -> parseErrorRange happy_var_1 - "The 'overlap' keyword only applies to instance fields (fields marked with {{ }})" - in T.traverse (setOverlap . fmap (\ x -> typeSig defaultArgInfo x happy_var_4)) happy_var_2)}}}) - ) (\r -> happyReturn (happyIn108 r)) - -happyReduce_379 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_379 = happySpecReduce_2 98# happyReduction_379 -happyReduction_379 happy_x_2 - happy_x_1 - = case happyOut172 happy_x_2 of { happy_var_2 -> - happyIn108 - (let - setInstance (TypeSig info x t) = TypeSig (makeInstance info) x t - setInstance _ = __IMPOSSIBLE__ in - map (fmap setInstance) happy_var_2 - )} - -happyReduce_380 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_380 = happyMonadReduce 3# 99# happyReduction_380 -happyReduction_380 (happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOut100 happy_x_1 of { happy_var_1 -> - case happyOut110 happy_x_2 of { happy_var_2 -> - case happyOut104 happy_x_3 of { happy_var_3 -> - ( funClauseOrTypeSigs [] happy_var_1 happy_var_2 happy_var_3)}}}) - ) (\r -> happyReturn (happyIn109 r)) - -happyReduce_381 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_381 = happyMonadReduce 4# 99# happyReduction_381 -happyReduction_381 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOut28 happy_x_1 of { happy_var_1 -> - case happyOut100 happy_x_2 of { happy_var_2 -> - case happyOut110 happy_x_3 of { happy_var_3 -> - case happyOut104 happy_x_4 of { happy_var_4 -> - ( funClauseOrTypeSigs happy_var_1 happy_var_2 happy_var_3 happy_var_4)}}}}) - ) (\r -> happyReturn (happyIn109 r)) - -happyReduce_382 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_382 = happySpecReduce_2 100# happyReduction_382 -happyReduction_382 happy_x_2 - happy_x_1 - = case happyOut43 happy_x_2 of { happy_var_2 -> - happyIn110 - (JustRHS (RHS happy_var_2) - )} - -happyReduce_383 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_383 = happySpecReduce_2 100# happyReduction_383 -happyReduction_383 happy_x_2 - happy_x_1 - = case happyOut43 happy_x_2 of { happy_var_2 -> - happyIn110 - (TypeSigsRHS happy_var_2 - )} - -happyReduce_384 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_384 = happySpecReduce_0 100# happyReduction_384 -happyReduction_384 = happyIn110 - (JustRHS AbsurdRHS - ) - -happyReduce_385 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_385 = happyReduce 7# 101# happyReduction_385 -happyReduction_385 (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 { (TokKeyword KwData happy_var_1) -> - case happyOut19 happy_x_2 of { happy_var_2 -> - case happyOut82 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymColon happy_var_4) -> - case happyOut43 happy_x_5 of { happy_var_5 -> - case happyOutTok happy_x_6 of { (TokKeyword KwWhere happy_var_6) -> - case happyOut182 happy_x_7 of { happy_var_7 -> - happyIn111 - (Data (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4,happy_var_5,happy_var_6,happy_var_7)) Inductive happy_var_2 happy_var_3 happy_var_5 happy_var_7 - ) `HappyStk` happyRest}}}}}}} - -happyReduce_386 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_386 = happyReduce 7# 101# happyReduction_386 -happyReduction_386 (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 { (TokKeyword KwCoData happy_var_1) -> - case happyOut19 happy_x_2 of { happy_var_2 -> - case happyOut82 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymColon happy_var_4) -> - case happyOut43 happy_x_5 of { happy_var_5 -> - case happyOutTok happy_x_6 of { (TokKeyword KwWhere happy_var_6) -> - case happyOut182 happy_x_7 of { happy_var_7 -> - happyIn111 - (Data (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4,happy_var_5,happy_var_6,happy_var_7)) CoInductive happy_var_2 happy_var_3 happy_var_5 happy_var_7 - ) `HappyStk` happyRest}}}}}}} - -happyReduce_387 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_387 = happyReduce 5# 101# happyReduction_387 -happyReduction_387 (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 { (TokKeyword KwData happy_var_1) -> - case happyOut19 happy_x_2 of { happy_var_2 -> - case happyOut82 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokKeyword KwWhere happy_var_4) -> - case happyOut182 happy_x_5 of { happy_var_5 -> - happyIn111 - (DataDef (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4,happy_var_5)) Inductive happy_var_2 happy_var_3 happy_var_5 - ) `HappyStk` happyRest}}}}} - -happyReduce_388 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_388 = happyReduce 5# 101# happyReduction_388 -happyReduction_388 (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 { (TokKeyword KwCoData happy_var_1) -> - case happyOut19 happy_x_2 of { happy_var_2 -> - case happyOut82 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokKeyword KwWhere happy_var_4) -> - case happyOut182 happy_x_5 of { happy_var_5 -> - happyIn111 - (DataDef (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4,happy_var_5)) CoInductive happy_var_2 happy_var_3 happy_var_5 - ) `HappyStk` happyRest}}}}} - -happyReduce_389 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_389 = happyReduce 5# 102# happyReduction_389 -happyReduction_389 (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 { (TokKeyword KwData happy_var_1) -> - case happyOut19 happy_x_2 of { happy_var_2 -> - case happyOut82 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymColon happy_var_4) -> - case happyOut43 happy_x_5 of { happy_var_5 -> - happyIn112 - (DataSig (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4,happy_var_5)) Inductive happy_var_2 happy_var_3 happy_var_5 - ) `HappyStk` happyRest}}}}} - -happyReduce_390 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_390 = happyMonadReduce 7# 103# happyReduction_390 -happyReduction_390 (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 { (TokKeyword KwRecord happy_var_1) -> - case happyOut53 happy_x_2 of { happy_var_2 -> - case happyOut82 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymColon happy_var_4) -> - case happyOut43 happy_x_5 of { happy_var_5 -> - case happyOutTok happy_x_6 of { (TokKeyword KwWhere happy_var_6) -> - case happyOut176 happy_x_7 of { happy_var_7 -> - ( exprToName happy_var_2 >>= \ n -> let ((x,y,z),ds) = happy_var_7 in return $ Record (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4,happy_var_5,happy_var_6,happy_var_7)) n x y z happy_var_3 happy_var_5 ds)}}}}}}}) - ) (\r -> happyReturn (happyIn113 r)) - -happyReduce_391 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_391 = happyMonadReduce 5# 103# 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 { (TokKeyword KwRecord happy_var_1) -> - case happyOut53 happy_x_2 of { happy_var_2 -> - case happyOut82 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokKeyword KwWhere happy_var_4) -> - case happyOut176 happy_x_5 of { happy_var_5 -> - ( exprToName happy_var_2 >>= \ n -> let ((x,y,z),ds) = happy_var_5 in return $ RecordDef (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4,happy_var_5)) n x y z happy_var_3 ds)}}}}}) - ) (\r -> happyReturn (happyIn113 r)) - -happyReduce_392 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_392 = happyMonadReduce 5# 104# happyReduction_392 -happyReduction_392 (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 { (TokKeyword KwRecord happy_var_1) -> - case happyOut53 happy_x_2 of { happy_var_2 -> - case happyOut82 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymColon happy_var_4) -> - case happyOut43 happy_x_5 of { happy_var_5 -> - ( exprToName happy_var_2 >>= \ n -> return $ RecordSig (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4,happy_var_5)) n happy_var_3 happy_var_5)}}}}}) - ) (\r -> happyReturn (happyIn114 r)) - -happyReduce_393 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_393 = happySpecReduce_2 105# happyReduction_393 -happyReduction_393 happy_x_2 - happy_x_1 - = case happyOut19 happy_x_2 of { happy_var_2 -> - happyIn115 - ((happy_var_2, NotInstanceDef) - )} - -happyReduce_394 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_394 = happyReduce 5# 105# happyReduction_394 -happyReduction_394 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut19 happy_x_4 of { happy_var_4 -> - happyIn115 - ((happy_var_4, InstanceDef) - ) `HappyStk` happyRest} - -happyReduce_395 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_395 = happySpecReduce_3 106# happyReduction_395 -happyReduction_395 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwInfix happy_var_1) -> - case happyOut18 happy_x_2 of { happy_var_2 -> - case happyOut32 happy_x_3 of { happy_var_3 -> - happyIn116 - (Infix (Fixity (getRange (happy_var_1,happy_var_3)) (Related happy_var_2) NonAssoc) happy_var_3 - )}}} - -happyReduce_396 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_396 = happySpecReduce_3 106# happyReduction_396 -happyReduction_396 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwInfixL happy_var_1) -> - case happyOut18 happy_x_2 of { happy_var_2 -> - case happyOut32 happy_x_3 of { happy_var_3 -> - happyIn116 - (Infix (Fixity (getRange (happy_var_1,happy_var_3)) (Related happy_var_2) LeftAssoc) happy_var_3 - )}}} - -happyReduce_397 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_397 = happySpecReduce_3 106# happyReduction_397 -happyReduction_397 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwInfixR happy_var_1) -> - case happyOut18 happy_x_2 of { happy_var_2 -> - case happyOut32 happy_x_3 of { happy_var_3 -> - happyIn116 - (Infix (Fixity (getRange (happy_var_1,happy_var_3)) (Related happy_var_2) RightAssoc) happy_var_3 - )}}} - -happyReduce_398 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_398 = happySpecReduce_2 107# happyReduction_398 -happyReduction_398 happy_x_2 - happy_x_1 - = case happyOut172 happy_x_2 of { happy_var_2 -> - happyIn117 - (let - inst i = case getHiding i of - Instance _ -> InstanceDef - _ -> NotInstanceDef - toField (Arg info (TypeSig info' x t)) = Field (inst info') x (Arg info t) - in map toField happy_var_2 - )} - -happyReduce_399 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_399 = happySpecReduce_2 108# happyReduction_399 -happyReduction_399 happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwVariable happy_var_1) -> - case happyOut174 happy_x_2 of { happy_var_2 -> - happyIn118 - (let - toGeneralize (Arg info (TypeSig _ x t)) = TypeSig info x t - in [ Generalize (fuseRange happy_var_1 happy_var_2) (map toGeneralize happy_var_2) ] - )}} - -happyReduce_400 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_400 = happySpecReduce_2 109# happyReduction_400 -happyReduction_400 happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwMutual happy_var_1) -> - case happyOut182 happy_x_2 of { happy_var_2 -> - happyIn119 - (Mutual (fuseRange happy_var_1 happy_var_2) happy_var_2 - )}} - -happyReduce_401 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_401 = happySpecReduce_2 110# happyReduction_401 -happyReduction_401 happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwAbstract happy_var_1) -> - case happyOut182 happy_x_2 of { happy_var_2 -> - happyIn120 - (Abstract (fuseRange happy_var_1 happy_var_2) happy_var_2 - )}} - -happyReduce_402 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_402 = happySpecReduce_2 111# happyReduction_402 -happyReduction_402 happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwPrivate happy_var_1) -> - case happyOut182 happy_x_2 of { happy_var_2 -> - happyIn121 - (Private (fuseRange happy_var_1 happy_var_2) UserWritten happy_var_2 - )}} - -happyReduce_403 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_403 = happySpecReduce_2 112# happyReduction_403 -happyReduction_403 happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwInstance happy_var_1) -> - case happyOut182 happy_x_2 of { happy_var_2 -> - happyIn122 - (InstanceB (fuseRange happy_var_1 happy_var_2) happy_var_2 - )}} - -happyReduce_404 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_404 = happySpecReduce_2 113# happyReduction_404 -happyReduction_404 happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwMacro happy_var_1) -> - case happyOut182 happy_x_2 of { happy_var_2 -> - happyIn123 - (Macro (fuseRange happy_var_1 happy_var_2) happy_var_2 - )}} - -happyReduce_405 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_405 = happySpecReduce_2 114# happyReduction_405 -happyReduction_405 happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwPostulate happy_var_1) -> - case happyOut182 happy_x_2 of { happy_var_2 -> - happyIn124 - (Postulate (fuseRange happy_var_1 happy_var_2) happy_var_2 - )}} - -happyReduce_406 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_406 = happySpecReduce_2 115# happyReduction_406 -happyReduction_406 happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwPrimitive happy_var_1) -> - case happyOut169 happy_x_2 of { happy_var_2 -> - happyIn125 - (Primitive (fuseRange happy_var_1 happy_var_2) happy_var_2 - )}} - -happyReduce_407 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_407 = happySpecReduce_3 116# happyReduction_407 -happyReduction_407 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwUnquoteDecl happy_var_1) -> - case happyOut43 happy_x_3 of { happy_var_3 -> - happyIn126 - (UnquoteDecl (fuseRange happy_var_1 happy_var_3) [] happy_var_3 - )}} - -happyReduce_408 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_408 = happyReduce 4# 116# happyReduction_408 -happyReduction_408 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_1 of { (TokKeyword KwUnquoteDecl happy_var_1) -> - case happyOut20 happy_x_2 of { happy_var_2 -> - case happyOut43 happy_x_4 of { happy_var_4 -> - happyIn126 - (UnquoteDecl (fuseRange happy_var_1 happy_var_4) happy_var_2 happy_var_4 - ) `HappyStk` happyRest}}} - -happyReduce_409 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_409 = happyReduce 4# 116# happyReduction_409 -happyReduction_409 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_1 of { (TokKeyword KwUnquoteDef happy_var_1) -> - case happyOut20 happy_x_2 of { happy_var_2 -> - case happyOut43 happy_x_4 of { happy_var_4 -> - happyIn126 - (UnquoteDef (fuseRange happy_var_1 happy_var_4) happy_var_2 happy_var_4 - ) `HappyStk` happyRest}}} - -happyReduce_410 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_410 = happyMonadReduce 5# 117# happyReduction_410 -happyReduction_410 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOut19 happy_x_2 of { happy_var_2 -> - case happyOut131 happy_x_3 of { happy_var_3 -> - case happyOut130 happy_x_5 of { happy_var_5 -> - ( - case happy_var_2 of - Name _ _ [_] -> case mkNotation happy_var_3 happy_var_5 of - Left err -> parseError $ "Malformed syntax declaration: " ++ err - Right n -> return $ Syntax happy_var_2 n - _ -> parseError "Syntax declarations are allowed only for simple names (without holes)")}}}) - ) (\r -> happyReturn (happyIn127 r)) - -happyReduce_411 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_411 = happyMonadReduce 5# 118# happyReduction_411 -happyReduction_411 (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 { (TokKeyword KwPatternSyn happy_var_1) -> - case happyOut19 happy_x_2 of { happy_var_2 -> - case happyOut129 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymEqual happy_var_4) -> - case happyOut43 happy_x_5 of { happy_var_5 -> - ( do - p <- exprToPattern happy_var_5 - return (PatternSyn (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4,happy_var_5)) happy_var_2 happy_var_3 p))}}}}}) - ) (\r -> happyReturn (happyIn128 r)) - -happyReduce_412 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_412 = happySpecReduce_0 119# happyReduction_412 -happyReduction_412 = happyIn129 - ([] - ) - -happyReduce_413 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_413 = happyMonadReduce 1# 119# happyReduction_413 -happyReduction_413 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOut73 happy_x_1 of { happy_var_1 -> - ( patternSynArgs happy_var_1)}) - ) (\r -> happyReturn (happyIn129 r)) - -happyReduce_414 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_414 = happySpecReduce_1 120# happyReduction_414 -happyReduction_414 happy_x_1 - = case happyOut135 happy_x_1 of { happy_var_1 -> - happyIn130 - ([happy_var_1] - )} - -happyReduce_415 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_415 = happySpecReduce_2 120# happyReduction_415 -happyReduction_415 happy_x_2 - happy_x_1 - = case happyOut130 happy_x_1 of { happy_var_1 -> - case happyOut135 happy_x_2 of { happy_var_2 -> - happyIn130 - (happy_var_1 ++ [happy_var_2] - )}} - -happyReduce_416 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_416 = happySpecReduce_1 121# happyReduction_416 -happyReduction_416 happy_x_1 - = case happyOut132 happy_x_1 of { happy_var_1 -> - happyIn131 - ([happy_var_1] - )} - -happyReduce_417 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_417 = happySpecReduce_2 121# happyReduction_417 -happyReduction_417 happy_x_2 - happy_x_1 - = case happyOut131 happy_x_1 of { happy_var_1 -> - case happyOut132 happy_x_2 of { happy_var_2 -> - happyIn131 - (happy_var_1 ++ [happy_var_2] - )}} - -happyReduce_418 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_418 = happySpecReduce_1 122# happyReduction_418 -happyReduction_418 happy_x_1 - = case happyOut133 happy_x_1 of { happy_var_1 -> - happyIn132 - (defaultNamedArg happy_var_1 - )} - -happyReduce_419 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_419 = happySpecReduce_3 122# happyReduction_419 -happyReduction_419 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut134 happy_x_2 of { happy_var_2 -> - happyIn132 - (hide $ defaultNamedArg happy_var_2 - )} - -happyReduce_420 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_420 = happySpecReduce_3 122# happyReduction_420 -happyReduction_420 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut134 happy_x_2 of { happy_var_2 -> - happyIn132 - (makeInstance $ defaultNamedArg happy_var_2 - )} - -happyReduce_421 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_421 = happyReduce 5# 122# 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) - = case happyOut135 happy_x_2 of { happy_var_2 -> - case happyOut134 happy_x_4 of { happy_var_4 -> - happyIn132 - (hide $ defaultArg $ named happy_var_2 happy_var_4 - ) `HappyStk` happyRest}} - -happyReduce_422 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_422 = happyReduce 5# 122# happyReduction_422 -happyReduction_422 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut135 happy_x_2 of { happy_var_2 -> - case happyOut134 happy_x_4 of { happy_var_4 -> - happyIn132 - (makeInstance $ defaultArg $ named happy_var_2 happy_var_4 - ) `HappyStk` happyRest}} - -happyReduce_423 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_423 = happySpecReduce_1 123# happyReduction_423 -happyReduction_423 happy_x_1 - = case happyOut135 happy_x_1 of { happy_var_1 -> - happyIn133 - (ExprHole happy_var_1 - )} - -happyReduce_424 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_424 = happyReduce 6# 123# happyReduction_424 -happyReduction_424 (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 happyOut135 happy_x_3 of { happy_var_3 -> - case happyOut135 happy_x_5 of { happy_var_5 -> - happyIn133 - (LambdaHole happy_var_3 happy_var_5 - ) `HappyStk` happyRest}} - -happyReduce_425 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_425 = happyReduce 6# 123# happyReduction_425 -happyReduction_425 (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_3 of { (TokSymbol SymUnderscore happy_var_3) -> - case happyOut135 happy_x_5 of { happy_var_5 -> - happyIn133 - (LambdaHole (Ranged (getRange happy_var_3) "_") happy_var_5 - ) `HappyStk` happyRest}} - -happyReduce_426 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_426 = happySpecReduce_1 124# happyReduction_426 -happyReduction_426 happy_x_1 - = case happyOut135 happy_x_1 of { happy_var_1 -> - happyIn134 - (ExprHole happy_var_1 - )} - -happyReduce_427 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_427 = happyReduce 4# 124# happyReduction_427 -happyReduction_427 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut135 happy_x_2 of { happy_var_2 -> - case happyOut135 happy_x_4 of { happy_var_4 -> - happyIn134 - (LambdaHole happy_var_2 happy_var_4 - ) `HappyStk` happyRest}} - -happyReduce_428 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_428 = happyReduce 4# 124# happyReduction_428 -happyReduction_428 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_3 of { (TokSymbol SymArrow happy_var_3) -> - case happyOut135 happy_x_4 of { happy_var_4 -> - happyIn134 - (LambdaHole (Ranged (getRange happy_var_3) "_") happy_var_4 - ) `HappyStk` happyRest}} - -happyReduce_429 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_429 = happySpecReduce_1 125# happyReduction_429 -happyReduction_429 happy_x_1 - = case happyOutTok happy_x_1 of { (TokId happy_var_1) -> - happyIn135 - (Ranged (getRange $ fst happy_var_1) (stringToRawName $ snd happy_var_1) - )} - -happyReduce_430 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_430 = happySpecReduce_1 126# happyReduction_430 -happyReduction_430 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwOpen happy_var_1) -> - happyIn136 - (Just (getRange happy_var_1) - )} - -happyReduce_431 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_431 = happySpecReduce_0 126# happyReduction_431 -happyReduction_431 = happyIn136 - (Nothing - ) - -happyReduce_432 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_432 = happyMonadReduce 5# 127# happyReduction_432 -happyReduction_432 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOut136 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { (TokKeyword KwImport happy_var_2) -> - case happyOut30 happy_x_3 of { happy_var_3 -> - case happyOut138 happy_x_4 of { happy_var_4 -> - case happyOut88 happy_x_5 of { happy_var_5 -> - ( - let - { doOpen = maybe DontOpen (const DoOpen) happy_var_1 - ; m = happy_var_3 - ; es = happy_var_4 - ; dir = happy_var_5 - ; r = getRange (happy_var_1, happy_var_2, m, es, dir) - ; mr = getRange m - ; unique = hashString $ prettyShow $ (Strict.Nothing :: Strict.Maybe ()) <$ r - -- turn range into unique id, but delete file path - -- which is absolute and messes up suite of failing tests - -- (different hashs on different installations) - -- TODO: Don't use (insecure) hashes in this way. - ; fresh = Name mr NotInScope [ Id $ stringToRawName $ ".#" ++ prettyShow m ++ "-" ++ show unique ] - ; fresh' = Name mr NotInScope [ Id $ stringToRawName $ ".#" ++ prettyShow m ++ "-" ++ show (unique + 1) ] - ; impStm asR = Import r m (Just (AsName (Right fresh) asR)) DontOpen defaultImportDir - ; appStm m' es = - Private r Inserted - [ ModuleMacro r m' - (SectionApp (getRange es) [] - (RawApp (getRange es) (Ident (QName fresh) : es))) - doOpen dir - ] - ; (initArgs, last2Args) = splitAt (length es - 2) es - ; parseAsClause = case last2Args of - { [ Ident (QName (Name asR InScope [Id x])) - , e - -- Andreas, 2018-11-03, issue #3364, accept anything after 'as' - -- but require it to be a 'Name' in the scope checker. - ] | rawNameToString x == "as" -> Just . (asR,) $ - if | Ident (QName m') <- e -> Right m' - | otherwise -> Left e - ; _ -> Nothing - } - } in - case es of - { [] -> return [Import r m Nothing doOpen dir] - ; _ | Just (asR, m') <- parseAsClause -> - if null initArgs then return - [ Import (getRange (m, asR, m', dir)) m - (Just (AsName m' asR)) doOpen dir - ] - else return [ impStm asR, appStm (fromRight (const fresh') m') initArgs ] - -- Andreas, 2017-05-13, issue #2579 - -- Nisse reports that importing with instantation but without open - -- could be usefule for bringing instances into scope. - -- Ulf, 2018-12-6: Not since fixes of #1913 and #2489 which require - -- instances to be in scope. - | DontOpen <- doOpen -> parseErrorRange happy_var_2 "An import statement with module instantiation is useless without either an `open' keyword or an `as` binding giving a name to the instantiated module." - | otherwise -> return - [ impStm noRange - , appStm (noName $ beginningOf $ getRange m) es - ] - })}}}}}) - ) (\r -> happyReturn (happyIn137 r)) - -happyReduce_433 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_433 = happyReduce 4# 127# happyReduction_433 -happyReduction_433 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_1 of { (TokKeyword KwOpen happy_var_1) -> - case happyOut30 happy_x_2 of { happy_var_2 -> - case happyOut138 happy_x_3 of { happy_var_3 -> - case happyOut88 happy_x_4 of { happy_var_4 -> - happyIn137 - (let - { m = happy_var_2 - ; es = happy_var_3 - ; dir = happy_var_4 - ; r = getRange (happy_var_1, m, es, dir) - } in - [ case es of - { [] -> Open r m dir - ; _ -> Private r Inserted - [ ModuleMacro r (noName $ beginningOf $ getRange m) - (SectionApp (getRange (m , es)) [] (RawApp (fuseRange m es) (Ident m : es))) - DoOpen dir - ] - } - ] - ) `HappyStk` happyRest}}}} - -happyReduce_434 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_434 = happyReduce 6# 127# happyReduction_434 -happyReduction_434 (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 happyOut30 happy_x_2 of { happy_var_2 -> - case happyOut88 happy_x_6 of { happy_var_6 -> - happyIn137 - (let r = getRange happy_var_2 in - [ Private r Inserted - [ ModuleMacro r (noName $ beginningOf $ getRange happy_var_2) (RecordModuleInstance r happy_var_2) DoOpen happy_var_6 - ] - ] - ) `HappyStk` happyRest}} - -happyReduce_435 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_435 = happySpecReduce_0 128# happyReduction_435 -happyReduction_435 = happyIn138 - ([] - ) - -happyReduce_436 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_436 = happySpecReduce_2 128# happyReduction_436 -happyReduction_436 happy_x_2 - happy_x_1 - = case happyOut55 happy_x_1 of { happy_var_1 -> - case happyOut138 happy_x_2 of { happy_var_2 -> - happyIn138 - (happy_var_1 : happy_var_2 - )}} - -happyReduce_437 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_437 = happyReduce 4# 129# happyReduction_437 -happyReduction_437 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOut30 happy_x_1 of { happy_var_1 -> - case happyOutTok happy_x_2 of { (TokSymbol SymDoubleOpenBrace happy_var_2) -> - case happyOutTok happy_x_3 of { (TokSymbol SymEllipsis happy_var_3) -> - case happyOut21 happy_x_4 of { happy_var_4 -> - happyIn139 - ((\ts -> - if null ts then return $ RecordModuleInstance (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4)) happy_var_1 - else parseError "No bindings allowed for record module with non-canonical implicits" ) - ) `HappyStk` happyRest}}}} - -happyReduce_438 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_438 = happySpecReduce_2 129# happyReduction_438 -happyReduction_438 happy_x_2 - happy_x_1 - = case happyOut30 happy_x_1 of { happy_var_1 -> - case happyOut138 happy_x_2 of { happy_var_2 -> - happyIn139 - ((\ts -> return $ SectionApp (getRange (happy_var_1, happy_var_2)) ts (RawApp (fuseRange happy_var_1 happy_var_2) (Ident happy_var_1 : happy_var_2)) ) - )}} - -happyReduce_439 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_439 = happyMonadReduce 6# 130# happyReduction_439 -happyReduction_439 (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 { (TokKeyword KwModule happy_var_1) -> - case happyOut30 happy_x_2 of { happy_var_2 -> - case happyOut82 happy_x_3 of { happy_var_3 -> - case happyOut139 happy_x_5 of { happy_var_5 -> - case happyOut88 happy_x_6 of { happy_var_6 -> - ( do { ma <- happy_var_5 (map addType happy_var_3) - ; name <- ensureUnqual happy_var_2 - ; return $ ModuleMacro (getRange (happy_var_1, happy_var_2, ma, happy_var_6)) name ma DontOpen happy_var_6 })}}}}}) - ) (\r -> happyReturn (happyIn140 r)) - -happyReduce_440 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_440 = happyMonadReduce 7# 130# happyReduction_440 -happyReduction_440 (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 { (TokKeyword KwOpen happy_var_1) -> - case happyOutTok happy_x_2 of { (TokKeyword KwModule happy_var_2) -> - case happyOut19 happy_x_3 of { happy_var_3 -> - case happyOut82 happy_x_4 of { happy_var_4 -> - case happyOut139 happy_x_6 of { happy_var_6 -> - case happyOut88 happy_x_7 of { happy_var_7 -> - ( do {ma <- happy_var_6 (map addType happy_var_4); return $ ModuleMacro (getRange (happy_var_1, happy_var_2, happy_var_3, ma, happy_var_7)) happy_var_3 ma DoOpen happy_var_7 })}}}}}}) - ) (\r -> happyReturn (happyIn140 r)) - -happyReduce_441 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_441 = happyReduce 5# 131# happyReduction_441 -happyReduction_441 (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 { (TokKeyword KwModule happy_var_1) -> - case happyOut30 happy_x_2 of { happy_var_2 -> - case happyOut82 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokKeyword KwWhere happy_var_4) -> - case happyOut182 happy_x_5 of { happy_var_5 -> - happyIn141 - (Module (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4,happy_var_5)) happy_var_2 (map addType happy_var_3) happy_var_5 - ) `HappyStk` happyRest}}}}} - -happyReduce_442 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_442 = happyReduce 5# 131# happyReduction_442 -happyReduction_442 (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 { (TokKeyword KwModule happy_var_1) -> - case happyOut142 happy_x_2 of { happy_var_2 -> - case happyOut82 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokKeyword KwWhere happy_var_4) -> - case happyOut182 happy_x_5 of { happy_var_5 -> - happyIn141 - (Module (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4,happy_var_5)) (QName happy_var_2) (map addType happy_var_3) happy_var_5 - ) `HappyStk` happyRest}}}}} - -happyReduce_443 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_443 = happySpecReduce_1 132# happyReduction_443 -happyReduction_443 happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymUnderscore happy_var_1) -> - happyIn142 - (noName (getRange happy_var_1) - )} - -happyReduce_444 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_444 = happySpecReduce_1 133# happyReduction_444 -happyReduction_444 happy_x_1 - = case happyOut184 happy_x_1 of { happy_var_1 -> - happyIn143 - (figureOutTopLevelModule happy_var_1 - )} - -happyReduce_445 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_445 = happySpecReduce_1 134# happyReduction_445 -happyReduction_445 happy_x_1 - = case happyOut145 happy_x_1 of { happy_var_1 -> - happyIn144 - (Pragma happy_var_1 - )} - -happyReduce_446 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_446 = happySpecReduce_1 135# happyReduction_446 -happyReduction_446 happy_x_1 - = case happyOut147 happy_x_1 of { happy_var_1 -> - happyIn145 - (happy_var_1 - )} - -happyReduce_447 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_447 = happySpecReduce_1 135# happyReduction_447 -happyReduction_447 happy_x_1 - = case happyOut148 happy_x_1 of { happy_var_1 -> - happyIn145 - (happy_var_1 - )} - -happyReduce_448 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_448 = happySpecReduce_1 135# happyReduction_448 -happyReduction_448 happy_x_1 - = case happyOut150 happy_x_1 of { happy_var_1 -> - happyIn145 - (happy_var_1 - )} - -happyReduce_449 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_449 = happySpecReduce_1 135# happyReduction_449 -happyReduction_449 happy_x_1 - = case happyOut149 happy_x_1 of { happy_var_1 -> - happyIn145 - (happy_var_1 - )} - -happyReduce_450 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_450 = happySpecReduce_1 135# happyReduction_450 -happyReduction_450 happy_x_1 - = case happyOut151 happy_x_1 of { happy_var_1 -> - happyIn145 - (happy_var_1 - )} - -happyReduce_451 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_451 = happySpecReduce_1 135# happyReduction_451 -happyReduction_451 happy_x_1 - = case happyOut154 happy_x_1 of { happy_var_1 -> - happyIn145 - (happy_var_1 - )} - -happyReduce_452 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_452 = happySpecReduce_1 135# happyReduction_452 -happyReduction_452 happy_x_1 - = case happyOut152 happy_x_1 of { happy_var_1 -> - happyIn145 - (happy_var_1 - )} - -happyReduce_453 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_453 = happySpecReduce_1 135# happyReduction_453 -happyReduction_453 happy_x_1 - = case happyOut153 happy_x_1 of { happy_var_1 -> - happyIn145 - (happy_var_1 - )} - -happyReduce_454 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_454 = happySpecReduce_1 135# happyReduction_454 -happyReduction_454 happy_x_1 - = case happyOut162 happy_x_1 of { happy_var_1 -> - happyIn145 - (happy_var_1 - )} - -happyReduce_455 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_455 = happySpecReduce_1 135# happyReduction_455 -happyReduction_455 happy_x_1 - = case happyOut159 happy_x_1 of { happy_var_1 -> - happyIn145 - (happy_var_1 - )} - -happyReduce_456 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_456 = happySpecReduce_1 135# happyReduction_456 -happyReduction_456 happy_x_1 - = case happyOut158 happy_x_1 of { happy_var_1 -> - happyIn145 - (happy_var_1 - )} - -happyReduce_457 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_457 = happySpecReduce_1 135# happyReduction_457 -happyReduction_457 happy_x_1 - = case happyOut157 happy_x_1 of { happy_var_1 -> - happyIn145 - (happy_var_1 - )} - -happyReduce_458 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_458 = happySpecReduce_1 135# happyReduction_458 -happyReduction_458 happy_x_1 - = case happyOut166 happy_x_1 of { happy_var_1 -> - happyIn145 - (happy_var_1 - )} - -happyReduce_459 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_459 = happySpecReduce_1 135# happyReduction_459 -happyReduction_459 happy_x_1 - = case happyOut160 happy_x_1 of { happy_var_1 -> - happyIn145 - (happy_var_1 - )} - -happyReduce_460 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_460 = happySpecReduce_1 135# happyReduction_460 -happyReduction_460 happy_x_1 - = case happyOut161 happy_x_1 of { happy_var_1 -> - happyIn145 - (happy_var_1 - )} - -happyReduce_461 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_461 = happySpecReduce_1 135# happyReduction_461 -happyReduction_461 happy_x_1 - = case happyOut155 happy_x_1 of { happy_var_1 -> - happyIn145 - (happy_var_1 - )} - -happyReduce_462 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_462 = happySpecReduce_1 135# happyReduction_462 -happyReduction_462 happy_x_1 - = case happyOut156 happy_x_1 of { happy_var_1 -> - happyIn145 - (happy_var_1 - )} - -happyReduce_463 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_463 = happySpecReduce_1 135# happyReduction_463 -happyReduction_463 happy_x_1 - = case happyOut163 happy_x_1 of { happy_var_1 -> - happyIn145 - (happy_var_1 - )} - -happyReduce_464 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_464 = happySpecReduce_1 135# happyReduction_464 -happyReduction_464 happy_x_1 - = case happyOut164 happy_x_1 of { happy_var_1 -> - happyIn145 - (happy_var_1 - )} - -happyReduce_465 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_465 = happySpecReduce_1 135# happyReduction_465 -happyReduction_465 happy_x_1 - = case happyOut165 happy_x_1 of { happy_var_1 -> - happyIn145 - (happy_var_1 - )} - -happyReduce_466 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_466 = happySpecReduce_1 135# happyReduction_466 -happyReduction_466 happy_x_1 - = case happyOut146 happy_x_1 of { happy_var_1 -> - happyIn145 - (happy_var_1 - )} - -happyReduce_467 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_467 = happyReduce 4# 136# happyReduction_467 -happyReduction_467 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOutTok happy_x_2 of { (TokKeyword KwOPTIONS happy_var_2) -> - case happyOut36 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymClosePragma happy_var_4) -> - happyIn146 - (OptionsPragma (getRange (happy_var_1,happy_var_2,happy_var_4)) happy_var_3 - ) `HappyStk` happyRest}}}} - -happyReduce_468 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_468 = happyReduce 5# 137# happyReduction_468 -happyReduction_468 (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 { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOutTok happy_x_2 of { (TokKeyword KwBUILTIN happy_var_2) -> - case happyOutTok happy_x_3 of { (TokString happy_var_3) -> - case happyOut41 happy_x_4 of { happy_var_4 -> - case happyOutTok happy_x_5 of { (TokSymbol SymClosePragma happy_var_5) -> - happyIn147 - (BuiltinPragma (getRange (happy_var_1,happy_var_2,fst happy_var_3,happy_var_4,happy_var_5)) (snd happy_var_3) happy_var_4 - ) `HappyStk` happyRest}}}}} - -happyReduce_469 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_469 = happyReduce 5# 137# happyReduction_469 -happyReduction_469 (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 { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOutTok happy_x_2 of { (TokKeyword KwBUILTIN happy_var_2) -> - case happyOutTok happy_x_3 of { (TokKeyword KwREWRITE happy_var_3) -> - case happyOut41 happy_x_4 of { happy_var_4 -> - case happyOutTok happy_x_5 of { (TokSymbol SymClosePragma happy_var_5) -> - happyIn147 - (BuiltinPragma (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4,happy_var_5)) "REWRITE" happy_var_4 - ) `HappyStk` happyRest}}}}} - -happyReduce_470 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_470 = happyReduce 4# 138# happyReduction_470 -happyReduction_470 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOutTok happy_x_2 of { (TokKeyword KwREWRITE happy_var_2) -> - case happyOut42 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymClosePragma happy_var_4) -> - happyIn148 - (RewritePragma (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4)) happy_var_3 - ) `HappyStk` happyRest}}}} - -happyReduce_471 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_471 = happyReduce 5# 139# happyReduction_471 -happyReduction_471 (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 { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOutTok happy_x_2 of { (TokKeyword KwFOREIGN happy_var_2) -> - case happyOutTok happy_x_3 of { (TokString happy_var_3) -> - case happyOut39 happy_x_4 of { happy_var_4 -> - case happyOutTok happy_x_5 of { (TokSymbol SymClosePragma happy_var_5) -> - happyIn149 - (ForeignPragma (getRange (happy_var_1, happy_var_2, fst happy_var_3, happy_var_5)) (snd happy_var_3) (recoverLayout happy_var_4) - ) `HappyStk` happyRest}}}}} - -happyReduce_472 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_472 = happyReduce 6# 140# happyReduction_472 -happyReduction_472 (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 { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOutTok happy_x_2 of { (TokKeyword KwCOMPILE happy_var_2) -> - case happyOutTok happy_x_3 of { (TokString happy_var_3) -> - case happyOut41 happy_x_4 of { happy_var_4 -> - case happyOut36 happy_x_5 of { happy_var_5 -> - case happyOutTok happy_x_6 of { (TokSymbol SymClosePragma happy_var_6) -> - happyIn150 - (CompilePragma (getRange (happy_var_1,happy_var_2,fst happy_var_3,happy_var_4,happy_var_6)) (snd happy_var_3) happy_var_4 (unwords happy_var_5) - ) `HappyStk` happyRest}}}}}} - -happyReduce_473 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_473 = happyReduce 4# 141# happyReduction_473 -happyReduction_473 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOutTok happy_x_2 of { (TokKeyword KwSTATIC happy_var_2) -> - case happyOut41 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymClosePragma happy_var_4) -> - happyIn151 - (StaticPragma (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4)) happy_var_3 - ) `HappyStk` happyRest}}}} - -happyReduce_474 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_474 = happyReduce 4# 142# happyReduction_474 -happyReduction_474 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOutTok happy_x_2 of { (TokKeyword KwINLINE happy_var_2) -> - case happyOut41 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymClosePragma happy_var_4) -> - happyIn152 - (InlinePragma (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4)) True happy_var_3 - ) `HappyStk` happyRest}}}} - -happyReduce_475 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_475 = happyReduce 4# 143# happyReduction_475 -happyReduction_475 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOutTok happy_x_2 of { (TokKeyword KwNOINLINE happy_var_2) -> - case happyOut41 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymClosePragma happy_var_4) -> - happyIn153 - (InlinePragma (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4)) False happy_var_3 - ) `HappyStk` happyRest}}}} - -happyReduce_476 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_476 = happyReduce 4# 144# happyReduction_476 -happyReduction_476 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOutTok happy_x_2 of { (TokKeyword KwINJECTIVE happy_var_2) -> - case happyOut41 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymClosePragma happy_var_4) -> - happyIn154 - (InjectivePragma (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4)) happy_var_3 - ) `HappyStk` happyRest}}}} - -happyReduce_477 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_477 = happyMonadReduce 5# 145# happyReduction_477 -happyReduction_477 (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 { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOutTok happy_x_3 of { (TokString happy_var_3) -> - case happyOut36 happy_x_4 of { happy_var_4 -> - case happyOutTok happy_x_5 of { (TokSymbol SymClosePragma happy_var_5) -> - ( - let (r, s) = happy_var_3 in - parseDisplayPragma (fuseRange happy_var_1 happy_var_5) (iStart r) (unwords (s : happy_var_4)))}}}}) - ) (\r -> happyReturn (happyIn155 r)) - -happyReduce_478 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_478 = happyReduce 4# 146# happyReduction_478 -happyReduction_478 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOutTok happy_x_2 of { (TokKeyword KwETA happy_var_2) -> - case happyOut41 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymClosePragma happy_var_4) -> - happyIn156 - (EtaPragma (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4)) happy_var_3 - ) `HappyStk` happyRest}}}} - -happyReduce_479 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_479 = happySpecReduce_3 147# happyReduction_479 -happyReduction_479 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOutTok happy_x_2 of { (TokKeyword KwNO_TERMINATION_CHECK happy_var_2) -> - case happyOutTok happy_x_3 of { (TokSymbol SymClosePragma happy_var_3) -> - happyIn157 - (TerminationCheckPragma (getRange (happy_var_1,happy_var_2,happy_var_3)) NoTerminationCheck - )}}} - -happyReduce_480 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_480 = happySpecReduce_3 148# happyReduction_480 -happyReduction_480 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOutTok happy_x_2 of { (TokKeyword KwNON_TERMINATING happy_var_2) -> - case happyOutTok happy_x_3 of { (TokSymbol SymClosePragma happy_var_3) -> - happyIn158 - (TerminationCheckPragma (getRange (happy_var_1,happy_var_2,happy_var_3)) NonTerminating - )}}} - -happyReduce_481 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_481 = happySpecReduce_3 149# happyReduction_481 -happyReduction_481 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOutTok happy_x_2 of { (TokKeyword KwTERMINATING happy_var_2) -> - case happyOutTok happy_x_3 of { (TokSymbol SymClosePragma happy_var_3) -> - happyIn159 - (TerminationCheckPragma (getRange (happy_var_1,happy_var_2,happy_var_3)) Terminating - )}}} - -happyReduce_482 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_482 = happyReduce 4# 150# happyReduction_482 -happyReduction_482 (happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) - = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOutTok happy_x_2 of { (TokKeyword KwMEASURE happy_var_2) -> - case happyOut40 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokSymbol SymClosePragma happy_var_4) -> - happyIn160 - (let r = getRange (happy_var_1, happy_var_2, happy_var_3, happy_var_4) in - TerminationCheckPragma r (TerminationMeasure r happy_var_3) - ) `HappyStk` happyRest}}}} - -happyReduce_483 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_483 = happySpecReduce_3 151# happyReduction_483 -happyReduction_483 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOutTok happy_x_2 of { (TokKeyword KwCATCHALL happy_var_2) -> - case happyOutTok happy_x_3 of { (TokSymbol SymClosePragma happy_var_3) -> - happyIn161 - (CatchallPragma (getRange (happy_var_1,happy_var_2,happy_var_3)) - )}}} - -happyReduce_484 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_484 = happySpecReduce_3 152# happyReduction_484 -happyReduction_484 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOutTok happy_x_2 of { (TokKeyword KwIMPOSSIBLE happy_var_2) -> - case happyOutTok happy_x_3 of { (TokSymbol SymClosePragma happy_var_3) -> - happyIn162 - (ImpossiblePragma (getRange (happy_var_1,happy_var_2,happy_var_3)) - )}}} - -happyReduce_485 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_485 = happySpecReduce_3 153# happyReduction_485 -happyReduction_485 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOutTok happy_x_2 of { (TokKeyword KwNO_POSITIVITY_CHECK happy_var_2) -> - case happyOutTok happy_x_3 of { (TokSymbol SymClosePragma happy_var_3) -> - happyIn163 - (NoPositivityCheckPragma (getRange (happy_var_1,happy_var_2,happy_var_3)) - )}}} - -happyReduce_486 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_486 = happySpecReduce_3 154# happyReduction_486 -happyReduction_486 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOutTok happy_x_2 of { (TokKeyword KwNO_UNIVERSE_CHECK happy_var_2) -> - case happyOutTok happy_x_3 of { (TokSymbol SymClosePragma happy_var_3) -> - happyIn164 - (NoUniverseCheckPragma (getRange (happy_var_1,happy_var_2,happy_var_3)) - )}}} - -happyReduce_487 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_487 = happyReduce 5# 155# happyReduction_487 -happyReduction_487 (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 { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOutTok happy_x_2 of { (TokKeyword KwPOLARITY happy_var_2) -> - case happyOut40 happy_x_3 of { happy_var_3 -> - case happyOut167 happy_x_4 of { happy_var_4 -> - case happyOutTok happy_x_5 of { (TokSymbol SymClosePragma happy_var_5) -> - happyIn165 - (let (rs, occs) = unzip (reverse happy_var_4) in - PolarityPragma (getRange (happy_var_1,happy_var_2,happy_var_3,rs,happy_var_5)) happy_var_3 occs - ) `HappyStk` happyRest}}}}} - -happyReduce_488 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_488 = happyMonadReduce 5# 156# happyReduction_488 -happyReduction_488 (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 { (TokSymbol SymOpenPragma happy_var_1) -> - case happyOutTok happy_x_2 of { (TokKeyword KwWARNING_ON_USAGE happy_var_2) -> - case happyOut41 happy_x_3 of { happy_var_3 -> - case happyOutTok happy_x_4 of { (TokLiteral happy_var_4) -> - case happyOutTok happy_x_5 of { (TokSymbol SymClosePragma happy_var_5) -> - ( case happy_var_4 of - { LitString r str -> return $ WarningOnUsage (getRange (happy_var_1,happy_var_2,happy_var_3,r,happy_var_5)) happy_var_3 str - ; _ -> parseError "Expected string literal" - })}}}}}) - ) (\r -> happyReturn (happyIn166 r)) - -happyReduce_489 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_489 = happySpecReduce_0 157# happyReduction_489 -happyReduction_489 = happyIn167 - ([] - ) - -happyReduce_490 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_490 = happySpecReduce_2 157# happyReduction_490 -happyReduction_490 happy_x_2 - happy_x_1 - = case happyOut167 happy_x_1 of { happy_var_1 -> - case happyOut168 happy_x_2 of { happy_var_2 -> - happyIn167 - (happy_var_2 : happy_var_1 - )}} - -happyReduce_491 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_491 = happyMonadReduce 1# 158# happyReduction_491 -happyReduction_491 (happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOutTok happy_x_1 of { (TokString happy_var_1) -> - ( polarity happy_var_1)}) - ) (\r -> happyReturn (happyIn168 r)) - -happyReduce_492 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_492 = happySpecReduce_2 159# happyReduction_492 -happyReduction_492 happy_x_2 - happy_x_1 - = happyIn169 - ([] - ) - -happyReduce_493 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_493 = happySpecReduce_1 159# happyReduction_493 -happyReduction_493 happy_x_1 - = case happyOut170 happy_x_1 of { happy_var_1 -> - happyIn169 - (happy_var_1 - )} - -happyReduce_494 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_494 = happySpecReduce_3 160# happyReduction_494 -happyReduction_494 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut171 happy_x_2 of { happy_var_2 -> - happyIn170 - (reverse happy_var_2 - )} - -happyReduce_495 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_495 = happySpecReduce_3 161# happyReduction_495 -happyReduction_495 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut171 happy_x_1 of { happy_var_1 -> - case happyOut107 happy_x_3 of { happy_var_3 -> - happyIn171 - (reverse happy_var_3 ++ happy_var_1 - )}} - -happyReduce_496 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_496 = happySpecReduce_1 161# happyReduction_496 -happyReduction_496 happy_x_1 - = case happyOut107 happy_x_1 of { happy_var_1 -> - happyIn171 - (reverse happy_var_1 - )} - -happyReduce_497 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_497 = happySpecReduce_3 162# happyReduction_497 -happyReduction_497 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut173 happy_x_2 of { happy_var_2 -> - happyIn172 - (reverse happy_var_2 - )} - -happyReduce_498 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_498 = happySpecReduce_3 163# happyReduction_498 -happyReduction_498 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut173 happy_x_1 of { happy_var_1 -> - case happyOut108 happy_x_3 of { happy_var_3 -> - happyIn173 - (reverse happy_var_3 ++ happy_var_1 - )}} - -happyReduce_499 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_499 = happySpecReduce_1 163# happyReduction_499 -happyReduction_499 happy_x_1 - = case happyOut108 happy_x_1 of { happy_var_1 -> - happyIn173 - (reverse happy_var_1 - )} - -happyReduce_500 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_500 = happySpecReduce_3 164# happyReduction_500 -happyReduction_500 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut175 happy_x_2 of { happy_var_2 -> - happyIn174 - (reverse happy_var_2 - )} - -happyReduce_501 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_501 = happySpecReduce_3 165# happyReduction_501 -happyReduction_501 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut175 happy_x_1 of { happy_var_1 -> - case happyOut108 happy_x_3 of { happy_var_3 -> - happyIn175 - (reverse happy_var_3 ++ happy_var_1 - )}} - -happyReduce_502 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_502 = happySpecReduce_1 165# happyReduction_502 -happyReduction_502 happy_x_1 - = case happyOut108 happy_x_1 of { happy_var_1 -> - happyIn175 - (reverse happy_var_1 - )} - -happyReduce_503 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_503 = happySpecReduce_0 165# happyReduction_503 -happyReduction_503 = happyIn175 - ([] - ) - -happyReduce_504 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_504 = happyMonadReduce 3# 166# happyReduction_504 -happyReduction_504 (happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOut177 happy_x_2 of { happy_var_2 -> - ( ((,) `fmap` verifyRecordDirectives happy_var_2 <*> pure []))}) - ) (\r -> happyReturn (happyIn176 r)) - -happyReduce_505 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_505 = happyMonadReduce 5# 166# happyReduction_505 -happyReduction_505 (happy_x_5 `HappyStk` - happy_x_4 `HappyStk` - happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOut177 happy_x_2 of { happy_var_2 -> - case happyOut183 happy_x_4 of { happy_var_4 -> - ( ((,) `fmap` verifyRecordDirectives happy_var_2 <*> pure happy_var_4))}}) - ) (\r -> happyReturn (happyIn176 r)) - -happyReduce_506 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_506 = happyMonadReduce 3# 166# happyReduction_506 -happyReduction_506 (happy_x_3 `HappyStk` - happy_x_2 `HappyStk` - happy_x_1 `HappyStk` - happyRest) tk - = happyThen ((case happyOut183 happy_x_2 of { happy_var_2 -> - ( ((,) `fmap` verifyRecordDirectives [] <*> pure happy_var_2))}) - ) (\r -> happyReturn (happyIn176 r)) - -happyReduce_507 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_507 = happySpecReduce_0 167# happyReduction_507 -happyReduction_507 = happyIn177 - ([] - ) - -happyReduce_508 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_508 = happySpecReduce_3 167# happyReduction_508 -happyReduction_508 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut177 happy_x_1 of { happy_var_1 -> - case happyOut178 happy_x_3 of { happy_var_3 -> - happyIn177 - (happy_var_3 : happy_var_1 - )}} - -happyReduce_509 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_509 = happySpecReduce_1 167# happyReduction_509 -happyReduction_509 happy_x_1 - = case happyOut178 happy_x_1 of { happy_var_1 -> - happyIn177 - ([happy_var_1] - )} - -happyReduce_510 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_510 = happySpecReduce_1 168# happyReduction_510 -happyReduction_510 happy_x_1 - = case happyOut115 happy_x_1 of { happy_var_1 -> - happyIn178 - (Constructor happy_var_1 - )} - -happyReduce_511 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_511 = happySpecReduce_1 168# happyReduction_511 -happyReduction_511 happy_x_1 - = case happyOut180 happy_x_1 of { happy_var_1 -> - happyIn178 - (Induction happy_var_1 - )} - -happyReduce_512 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_512 = happySpecReduce_1 168# happyReduction_512 -happyReduction_512 happy_x_1 - = case happyOut179 happy_x_1 of { happy_var_1 -> - happyIn178 - (Eta happy_var_1 - )} - -happyReduce_513 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_513 = happySpecReduce_1 169# happyReduction_513 -happyReduction_513 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwEta happy_var_1) -> - happyIn179 - (Ranged (getRange happy_var_1) YesEta - )} - -happyReduce_514 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_514 = happySpecReduce_1 169# happyReduction_514 -happyReduction_514 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwNoEta happy_var_1) -> - happyIn179 - (Ranged (getRange happy_var_1) NoEta - )} - -happyReduce_515 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_515 = happySpecReduce_1 170# happyReduction_515 -happyReduction_515 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwInductive happy_var_1) -> - happyIn180 - (Ranged (getRange happy_var_1) Inductive - )} - -happyReduce_516 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_516 = happySpecReduce_1 170# happyReduction_516 -happyReduction_516 happy_x_1 - = case happyOutTok happy_x_1 of { (TokKeyword KwCoInductive happy_var_1) -> - happyIn180 - (Ranged (getRange happy_var_1) CoInductive - )} - -happyReduce_517 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_517 = happySpecReduce_3 171# happyReduction_517 -happyReduction_517 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut183 happy_x_2 of { happy_var_2 -> - happyIn181 - (happy_var_2 - )} - -happyReduce_518 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_518 = happySpecReduce_2 172# happyReduction_518 -happyReduction_518 happy_x_2 - happy_x_1 - = happyIn182 - ([] - ) - -happyReduce_519 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_519 = happySpecReduce_1 172# happyReduction_519 -happyReduction_519 happy_x_1 - = case happyOut181 happy_x_1 of { happy_var_1 -> - happyIn182 - (happy_var_1 - )} - -happyReduce_520 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_520 = happySpecReduce_3 173# happyReduction_520 -happyReduction_520 happy_x_3 - happy_x_2 - happy_x_1 - = case happyOut106 happy_x_1 of { happy_var_1 -> - case happyOut183 happy_x_3 of { happy_var_3 -> - happyIn183 - (happy_var_1 ++ happy_var_3 - )}} - -happyReduce_521 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_521 = happySpecReduce_2 173# happyReduction_521 -happyReduction_521 happy_x_2 - happy_x_1 - = case happyOut106 happy_x_1 of { happy_var_1 -> - happyIn183 - (happy_var_1 - )} - -happyReduce_522 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_522 = happySpecReduce_1 173# happyReduction_522 -happyReduction_522 happy_x_1 - = case happyOut106 happy_x_1 of { happy_var_1 -> - happyIn183 - (happy_var_1 - )} - -happyReduce_523 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_523 = happySpecReduce_0 174# happyReduction_523 -happyReduction_523 = happyIn184 - ([] - ) - -happyReduce_524 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) -happyReduce_524 = happySpecReduce_1 174# happyReduction_524 -happyReduction_524 happy_x_1 - = case happyOut183 happy_x_1 of { happy_var_1 -> - happyIn184 - (happy_var_1 - )} - -happyNewToken action sts stk - = lexer(\tk -> - let cont i = happyDoAction i tk action sts stk in - case tk of { - TokEOF{} -> happyDoAction 103# tk action sts stk; - TokKeyword KwAbstract happy_dollar_dollar -> cont 1#; - TokKeyword KwCoData happy_dollar_dollar -> cont 2#; - TokKeyword KwCoInductive happy_dollar_dollar -> cont 3#; - TokKeyword KwConstructor happy_dollar_dollar -> cont 4#; - TokKeyword KwData happy_dollar_dollar -> cont 5#; - TokKeyword KwEta happy_dollar_dollar -> cont 6#; - TokKeyword KwField happy_dollar_dollar -> cont 7#; - TokKeyword KwForall happy_dollar_dollar -> cont 8#; - TokKeyword KwVariable happy_dollar_dollar -> cont 9#; - TokKeyword KwHiding happy_dollar_dollar -> cont 10#; - TokKeyword KwImport happy_dollar_dollar -> cont 11#; - TokKeyword KwIn happy_dollar_dollar -> cont 12#; - TokKeyword KwInductive happy_dollar_dollar -> cont 13#; - TokKeyword KwInfix happy_dollar_dollar -> cont 14#; - TokKeyword KwInfixL happy_dollar_dollar -> cont 15#; - TokKeyword KwInfixR happy_dollar_dollar -> cont 16#; - TokKeyword KwInstance happy_dollar_dollar -> cont 17#; - TokKeyword KwOverlap happy_dollar_dollar -> cont 18#; - TokKeyword KwLet happy_dollar_dollar -> cont 19#; - TokKeyword KwMacro happy_dollar_dollar -> cont 20#; - TokKeyword KwModule happy_dollar_dollar -> cont 21#; - TokKeyword KwMutual happy_dollar_dollar -> cont 22#; - TokKeyword KwNoEta happy_dollar_dollar -> cont 23#; - TokKeyword KwOpen happy_dollar_dollar -> cont 24#; - TokKeyword KwPatternSyn happy_dollar_dollar -> cont 25#; - TokKeyword KwPostulate happy_dollar_dollar -> cont 26#; - TokKeyword KwPrimitive happy_dollar_dollar -> cont 27#; - TokKeyword KwPrivate happy_dollar_dollar -> cont 28#; - TokKeyword KwProp happy_dollar_dollar -> cont 29#; - TokKeyword KwPublic happy_dollar_dollar -> cont 30#; - TokKeyword KwQuote happy_dollar_dollar -> cont 31#; - TokKeyword KwQuoteContext happy_dollar_dollar -> cont 32#; - TokKeyword KwQuoteGoal happy_dollar_dollar -> cont 33#; - TokKeyword KwQuoteTerm happy_dollar_dollar -> cont 34#; - TokKeyword KwRecord happy_dollar_dollar -> cont 35#; - TokKeyword KwRenaming happy_dollar_dollar -> cont 36#; - TokKeyword KwRewrite happy_dollar_dollar -> cont 37#; - TokKeyword KwSet happy_dollar_dollar -> cont 38#; - TokKeyword KwSyntax happy_dollar_dollar -> cont 39#; - TokKeyword KwTactic happy_dollar_dollar -> cont 40#; - TokKeyword KwTo happy_dollar_dollar -> cont 41#; - TokKeyword KwUnquote happy_dollar_dollar -> cont 42#; - TokKeyword KwUnquoteDecl happy_dollar_dollar -> cont 43#; - TokKeyword KwUnquoteDef happy_dollar_dollar -> cont 44#; - TokKeyword KwUsing happy_dollar_dollar -> cont 45#; - TokKeyword KwWhere happy_dollar_dollar -> cont 46#; - TokKeyword KwDo happy_dollar_dollar -> cont 47#; - TokKeyword KwWith happy_dollar_dollar -> cont 48#; - TokKeyword KwBUILTIN happy_dollar_dollar -> cont 49#; - TokKeyword KwCATCHALL happy_dollar_dollar -> cont 50#; - TokKeyword KwDISPLAY happy_dollar_dollar -> cont 51#; - TokKeyword KwETA happy_dollar_dollar -> cont 52#; - TokKeyword KwFOREIGN happy_dollar_dollar -> cont 53#; - TokKeyword KwCOMPILE happy_dollar_dollar -> cont 54#; - TokKeyword KwIMPOSSIBLE happy_dollar_dollar -> cont 55#; - TokKeyword KwINJECTIVE happy_dollar_dollar -> cont 56#; - TokKeyword KwINLINE happy_dollar_dollar -> cont 57#; - TokKeyword KwNOINLINE happy_dollar_dollar -> cont 58#; - TokKeyword KwMEASURE happy_dollar_dollar -> cont 59#; - TokKeyword KwNO_TERMINATION_CHECK happy_dollar_dollar -> cont 60#; - TokKeyword KwNO_POSITIVITY_CHECK happy_dollar_dollar -> cont 61#; - TokKeyword KwNO_UNIVERSE_CHECK happy_dollar_dollar -> cont 62#; - TokKeyword KwNON_TERMINATING happy_dollar_dollar -> cont 63#; - TokKeyword KwOPTIONS happy_dollar_dollar -> cont 64#; - TokKeyword KwPOLARITY happy_dollar_dollar -> cont 65#; - TokKeyword KwWARNING_ON_USAGE happy_dollar_dollar -> cont 66#; - TokKeyword KwREWRITE happy_dollar_dollar -> cont 67#; - TokKeyword KwSTATIC happy_dollar_dollar -> cont 68#; - TokKeyword KwTERMINATING happy_dollar_dollar -> cont 69#; - TokSetN happy_dollar_dollar -> cont 70#; - TokPropN happy_dollar_dollar -> cont 71#; - TokTeX happy_dollar_dollar -> cont 72#; - TokComment happy_dollar_dollar -> cont 73#; - TokSymbol SymEllipsis happy_dollar_dollar -> cont 74#; - TokSymbol SymDotDot happy_dollar_dollar -> cont 75#; - TokSymbol SymDot happy_dollar_dollar -> cont 76#; - TokSymbol SymSemi happy_dollar_dollar -> cont 77#; - TokSymbol SymColon happy_dollar_dollar -> cont 78#; - TokSymbol SymEqual happy_dollar_dollar -> cont 79#; - TokSymbol SymUnderscore happy_dollar_dollar -> cont 80#; - TokSymbol SymQuestionMark happy_dollar_dollar -> cont 81#; - TokSymbol SymArrow happy_dollar_dollar -> cont 82#; - TokSymbol SymLambda happy_dollar_dollar -> cont 83#; - TokSymbol SymAs happy_dollar_dollar -> cont 84#; - TokSymbol SymBar happy_dollar_dollar -> cont 85#; - TokSymbol SymOpenParen happy_dollar_dollar -> cont 86#; - TokSymbol SymCloseParen happy_dollar_dollar -> cont 87#; - TokSymbol SymOpenIdiomBracket happy_dollar_dollar -> cont 88#; - TokSymbol SymCloseIdiomBracket happy_dollar_dollar -> cont 89#; - TokSymbol SymDoubleOpenBrace happy_dollar_dollar -> cont 90#; - TokSymbol SymDoubleCloseBrace happy_dollar_dollar -> cont 91#; - TokSymbol SymOpenBrace happy_dollar_dollar -> cont 92#; - TokSymbol SymCloseBrace happy_dollar_dollar -> cont 93#; - TokSymbol SymOpenVirtualBrace happy_dollar_dollar -> cont 94#; - TokSymbol SymCloseVirtualBrace happy_dollar_dollar -> cont 95#; - TokSymbol SymVirtualSemi happy_dollar_dollar -> cont 96#; - TokSymbol SymOpenPragma happy_dollar_dollar -> cont 97#; - TokSymbol SymClosePragma happy_dollar_dollar -> cont 98#; - TokId happy_dollar_dollar -> cont 99#; - TokQId happy_dollar_dollar -> cont 100#; - TokString happy_dollar_dollar -> cont 101#; - TokLiteral happy_dollar_dollar -> cont 102#; - _ -> happyError' (tk, []) - }) - -happyError_ explist 103# tk = happyError' (tk, explist) -happyError_ explist _ tk = happyError' (tk, explist) - -happyThen :: () => Parser a -> (a -> Parser b) -> Parser b -happyThen = (>>=) -happyReturn :: () => a -> Parser a -happyReturn = (return) -happyParse :: () => Happy_GHC_Exts.Int# -> Parser (HappyAbsSyn ) - -happyNewToken :: () => Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) - -happyDoAction :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) - -happyReduceArr :: () => Happy_Data_Array.Array Int (Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn )) - -happyThen1 :: () => Parser a -> (a -> Parser b) -> Parser b -happyThen1 = happyThen -happyReturn1 :: () => a -> Parser a -happyReturn1 = happyReturn -happyError' :: () => ((Token), [String]) -> Parser a -happyError' tk = (\(tokens, explist) -> happyError) tk -tokensParser = happySomeParser where - happySomeParser = happyThen (happyParse 0#) (\x -> happyReturn (happyOut10 x)) - -exprParser = happySomeParser where - happySomeParser = happyThen (happyParse 1#) (\x -> happyReturn (happyOut43 x)) - -exprWhereParser = happySomeParser where - happySomeParser = happyThen (happyParse 2#) (\x -> happyReturn (happyOut105 x)) - -moduleParser = happySomeParser where - happySomeParser = happyThen (happyParse 3#) (\x -> happyReturn (happyOut13 x)) - -moduleNameParser = happySomeParser where - happySomeParser = happyThen (happyParse 4#) (\x -> happyReturn (happyOut30 x)) - -funclauseParser = happySomeParser where - happySomeParser = happyThen (happyParse 5#) (\x -> happyReturn (happyOut109 x)) - -holeContentParser = happySomeParser where - happySomeParser = happyThen (happyParse 6#) (\x -> happyReturn (happyOut103 x)) - -happySeq = happyDontSeq - - -{-------------------------------------------------------------------------- - Parsers - --------------------------------------------------------------------------} - --- | Parse the token stream. Used by the TeX compiler. -tokensParser :: Parser [Token] - --- | Parse an expression. Could be used in interactions. -exprParser :: Parser Expr - --- | Parse an expression followed by a where clause. Could be used in interactions. -exprWhereParser :: Parser ExprWhere - --- | Parse a module. -moduleParser :: Parser Module - - -{-------------------------------------------------------------------------- - Happy stuff - --------------------------------------------------------------------------} - --- | Required by Happy. -happyError :: Parser a -happyError = parseError "Parse error" - - -{-------------------------------------------------------------------------- - Utility functions - --------------------------------------------------------------------------} - --- | Grab leading OPTIONS pragmas. -takeOptionsPragmas :: [Declaration] -> ([Pragma], [Declaration]) -takeOptionsPragmas = spanJust $ \ d -> case d of - Pragma p@OptionsPragma{} -> Just p - _ -> Nothing - --- | Insert a top-level module if there is none. --- Also fix-up for the case the declarations in the top-level module --- are not indented (this is allowed as a special case). -figureOutTopLevelModule :: [Declaration] -> [Declaration] -figureOutTopLevelModule ds = - case spanAllowedBeforeModule ds of - -- Andreas 2016-02-01, issue #1388. - -- We need to distinguish two additional cases. - - -- Case 1: Regular file layout: imports followed by one module. Nothing to do. - (ds0, [ Module{} ]) -> ds - - -- Case 2: The declarations in the module are not indented. - -- This is allowed for the top level module, and thus rectified here. - (ds0, Module r m tel [] : ds2) -> ds0 ++ [Module r m tel ds2] - - -- Case 3: There is a module with indented declarations, - -- followed by non-indented declarations. This should be a - -- parse error and be reported later (see @toAbstract TopLevel{}@), - -- thus, we do not do anything here. - (ds0, Module r m tel ds1 : ds2) -> ds -- Gives parse error in scope checker. - -- OLD code causing issue 1388: - -- (ds0, Module r m tel ds1 : ds2) -> ds0 ++ [Module r m tel $ ds1 ++ ds2] - - -- Case 4: a top-level module declaration is missing. - -- Andreas, 2017-01-01, issue #2229: - -- Put everything (except OPTIONS pragmas) into an anonymous module. - _ -> ds0 ++ [Module r (QName $ noName r) [] ds1] - where - (ds0, ds1) = (`span` ds) $ \case - Pragma OptionsPragma{} -> True - _ -> False - -- Andreas, 2017-05-17, issue #2574. - -- Since the module noName will act as jump target, it needs a range. - -- We use the beginning of the file as beginning of the top level module. - r = beginningOfFile $ getRange ds1 - --- | Create a name from a string. - -mkName :: (Interval, String) -> Parser Name -mkName (i, s) = do - let xs = C.stringNameParts s - mapM_ isValidId xs - unless (alternating xs) $ parseError $ "a name cannot contain two consecutive underscores" - return $ Name (getRange i) InScope xs - where - isValidId Hole = return () - isValidId (Id y) = do - let x = rawNameToString y - err = "in the name " ++ s ++ ", the part " ++ x ++ " is not valid" - case parse defaultParseFlags [0] (lexer return) x of - ParseOk _ TokId{} -> return () - ParseFailed{} -> parseError err - ParseOk _ TokEOF{} -> parseError err - ParseOk _ t -> parseError . ((err ++ " because it is ") ++) $ case t of - TokId{} -> __IMPOSSIBLE__ - TokQId{} -> __IMPOSSIBLE__ -- "qualified" - TokKeyword{} -> "a keyword" - TokLiteral{} -> "a literal" - TokSymbol s _ -> case s of - SymDot -> __IMPOSSIBLE__ -- "reserved" - SymSemi -> "used to separate declarations" - SymVirtualSemi -> __IMPOSSIBLE__ - SymBar -> "used for with-arguments" - SymColon -> "part of declaration syntax" - SymArrow -> "the function arrow" - SymEqual -> "part of declaration syntax" - SymLambda -> "used for lambda-abstraction" - SymUnderscore -> "used for anonymous identifiers" - SymQuestionMark -> "a meta variable" - SymAs -> "used for as-patterns" - SymOpenParen -> "used to parenthesize expressions" - SymCloseParen -> "used to parenthesize expressions" - SymOpenIdiomBracket -> "an idiom bracket" - SymCloseIdiomBracket -> "an idiom bracket" - SymDoubleOpenBrace -> "used for instance arguments" - SymDoubleCloseBrace -> "used for instance arguments" - SymOpenBrace -> "used for hidden arguments" - SymCloseBrace -> "used for hidden arguments" - SymOpenVirtualBrace -> __IMPOSSIBLE__ - SymCloseVirtualBrace -> __IMPOSSIBLE__ - SymOpenPragma -> __IMPOSSIBLE__ -- "used for pragmas" - SymClosePragma -> __IMPOSSIBLE__ -- "used for pragmas" - SymEllipsis -> "used for function clauses" - SymDotDot -> __IMPOSSIBLE__ -- "a modality" - SymEndComment -> "the end-of-comment brace" - TokString{} -> __IMPOSSIBLE__ - TokSetN{} -> "a type universe" - TokPropN{} -> "a prop universe" - TokTeX{} -> __IMPOSSIBLE__ -- used by the LaTeX backend only - TokMarkup{} -> __IMPOSSIBLE__ -- ditto - TokComment{} -> __IMPOSSIBLE__ - TokDummy{} -> __IMPOSSIBLE__ - TokEOF{} -> __IMPOSSIBLE__ - - -- we know that there are no two Ids in a row - alternating (Hole : Hole : _) = False - alternating (_ : xs) = alternating xs - alternating [] = True - --- | Create a qualified name from a list of strings -mkQName :: [(Interval, String)] -> Parser QName -mkQName ss = do - xs <- mapM mkName ss - return $ foldr Qual (QName $ last xs) (init xs) - --- | Create a qualified name from a string (used in pragmas). --- Range of each name component is range of whole string. --- TODO: precise ranges! - -pragmaQName :: (Interval, String) -> Parser QName -pragmaQName (r, s) = do - let ss = chopWhen (== '.') s - mkQName $ map (r,) ss - -mkNamedArg :: Maybe QName -> Either QName Range -> Parser (NamedArg BoundName) -mkNamedArg x y = do - lbl <- case x of - Nothing -> return $ Just $ unranged "_" - Just (QName x) -> return $ Just $ Ranged (getRange x) (prettyShow x) - _ -> parseError "expected unqualified variable name" - var <- case y of - Left (QName y) -> return $ BName y noFixity' - Right r -> return $ BName (noName r) noFixity' - _ -> parseError "expected unqualified variable name" - return $ defaultArg $ Named lbl var - --- | Polarity parser. - -polarity :: (Interval, String) -> Parser (Range, Occurrence) -polarity (i, s) = - case s of - "_" -> ret Unused - "++" -> ret StrictPos - "+" -> ret JustPos - "-" -> ret JustNeg - "*" -> ret Mixed - _ -> parseError $ "Not a valid polarity: " ++ s - where - ret x = return (getRange i, x) - -recoverLayout :: [(Interval, String)] -> String -recoverLayout [] = "" -recoverLayout xs@((i, _) : _) = go (iStart i) xs - where - c0 = posCol (iStart i) - - go cur [] = "" - go cur ((i, s) : xs) = padding cur (iStart i) ++ s ++ go (iEnd i) xs - - padding Pn{ posLine = l1, posCol = c1 } Pn{ posLine = l2, posCol = c2 } - | l1 < l2 = genericReplicate (l2 - l1) '\n' ++ genericReplicate (max 0 (c2 - c0)) ' ' - | l1 == l2 = genericReplicate (c2 - c1) ' ' - -ensureUnqual :: QName -> Parser Name -ensureUnqual (QName x) = return x -ensureUnqual q@Qual{} = parseError' (rStart' $ getRange q) "Qualified name not allowed here" - --- | Match a particular name. -isName :: String -> (Interval, String) -> Parser () -isName s (_,s') - | s == s' = return () - | otherwise = parseError $ "expected " ++ s ++ ", found " ++ s' - --- | Build a forall pi (forall x y z -> ...) -forallPi :: [LamBinding] -> Expr -> Expr -forallPi bs e = Pi (map addType bs) e - --- | Converts lambda bindings to typed bindings. -addType :: LamBinding -> TypedBinding -addType (DomainFull b) = b -addType (DomainFree x) = TBind r [x] $ Underscore r Nothing - where r = getRange x - -boundNamesOrAbsurd :: [Expr] -> Parser (Either [NamedArg BoundName] [Expr]) -boundNamesOrAbsurd es - | any isAbsurd es = return $ Right es - | otherwise = - case mapM getBName es of - Just good -> return $ Left $ map defaultNamedArg good - Nothing -> parseError $ "expected sequence of bound identifiers" - where - getName :: Expr -> Maybe Name - getName (Ident (QName x)) = Just x - getName (Underscore r _) = Just $ Name r NotInScope [Hole] - getName _ = Nothing - - getBName :: Expr -> Maybe BoundName - getBName e = fmap mkBoundName_ $ getName e - - isAbsurd :: Expr -> Bool - isAbsurd (Absurd _) = True - isAbsurd (HiddenArg _ (Named _ e)) = isAbsurd e - isAbsurd (InstanceArg _ (Named _ e)) = isAbsurd e - isAbsurd (Paren _ expr) = isAbsurd expr - isAbsurd (RawApp _ exprs) = any isAbsurd exprs - isAbsurd _ = False - --- | Build a do-statement -buildDoStmt :: Expr -> [LamClause] -> Parser DoStmt -buildDoStmt (RawApp r [e]) cs = buildDoStmt e cs -buildDoStmt (Let r ds Nothing) [] = return $ DoLet r ds -buildDoStmt (RawApp r es) cs - | (es1, arr : es2) <- break isLeftArrow es = - case filter isLeftArrow es2 of - arr : _ -> parseError' (rStart' $ getRange arr) $ "Unexpected " ++ prettyShow arr - [] -> DoBind (getRange arr) - <$> exprToPattern (RawApp (getRange es1) es1) - <*> pure (RawApp (getRange es2) es2) - <*> pure cs - where - isLeftArrow (Ident (QName (Name _ _ [Id arr]))) = elem arr ["<-", "←"] - isLeftArrow _ = False -buildDoStmt e (_ : _) = parseError' (rStart' $ getRange e) "Only pattern matching do-statements can have where clauses." -buildDoStmt e [] = return $ DoThen e - -mergeImportDirectives :: [ImportDirective] -> Parser ImportDirective -mergeImportDirectives is = do - i <- foldl merge (return defaultImportDir) is - verifyImportDirective i - where - merge mi i2 = do - i1 <- mi - let err = parseError' (rStart' $ getRange i2) "Cannot mix using and hiding module directives" - return $ ImportDirective - { importDirRange = fuseRange i1 i2 - , using = mappend (using i1) (using i2) - , hiding = hiding i1 ++ hiding i2 - , impRenaming = impRenaming i1 ++ impRenaming i2 - , publicOpen = publicOpen i1 || publicOpen i2 } - --- | Check that an import directive doesn't contain repeated names -verifyImportDirective :: ImportDirective -> Parser ImportDirective -verifyImportDirective i = - case filter ((>1) . length) - $ group - $ sort xs - of - [] -> return i - yss -> parseErrorRange (head $ concat yss) $ - "Repeated name" ++ s ++ " in import directive: " ++ - concat (intersperse ", " $ map (prettyShow . head) yss) - where - s = case yss of - [_] -> "" - _ -> "s" - where - xs = names (using i) ++ hiding i ++ map renFrom (impRenaming i) - names (Using xs) = xs - names UseEverything = [] - -data RecordDirective - = Induction (Ranged Induction) - | Constructor (Name, IsInstance) - | Eta (Ranged HasEta) - deriving (Eq,Show) - -verifyRecordDirectives :: [RecordDirective] -> Parser (Maybe (Ranged Induction), Maybe HasEta, Maybe (Name, IsInstance)) -verifyRecordDirectives xs - | null rs = return (ltm is, ltm es, ltm cs) - | otherwise = parseErrorRange (head rs) $ "Repeated record directives at: \n" ++ intercalate "\n" (map prettyShow rs) - where - ltm :: [a] -> Maybe a - ltm [] = Nothing - ltm (x:xs) = Just x - errorFromList [] = [] - errorFromList [x] = [] - errorFromList xs = map getRange xs - rs = sort (concat ([errorFromList is, errorFromList es', errorFromList cs])) - is = [ i | Induction i <- xs ] - es' = [ i | Eta i <- xs ] - es = map rangedThing es' - cs = [ i | Constructor i <- xs ] - - --- | Breaks up a string into substrings. Returns every maximal --- subsequence of zero or more characters distinct from @'.'@. --- --- > splitOnDots "" == [""] --- > splitOnDots "foo.bar" == ["foo", "bar"] --- > splitOnDots ".foo.bar" == ["", "foo", "bar"] --- > splitOnDots "foo.bar." == ["foo", "bar", ""] --- > splitOnDots "foo..bar" == ["foo", "", "bar"] -splitOnDots :: String -> [String] -splitOnDots "" = [""] -splitOnDots ('.' : s) = [] : splitOnDots s -splitOnDots (c : s) = case splitOnDots s of - p : ps -> (c : p) : ps - - --- | Returns 'True' iff the name is a valid Haskell (hierarchical) --- module name. -validHaskellModuleName :: String -> Bool -validHaskellModuleName = all ok . splitOnDots - where - -- Checks if a dot-less module name is well-formed. - ok :: String -> Bool - ok [] = False - ok (c : s) = - isUpper c && - all (\c -> isLower c || c == '_' || - isUpper c || - generalCategory c == DecimalNumber || - c == '\'') - s - -{-------------------------------------------------------------------------- - Patterns - --------------------------------------------------------------------------} - --- | Turn an expression into a left hand side. -exprToLHS :: Expr -> Parser ([Expr] -> [Expr] -> LHS) -exprToLHS e = LHS <$> exprToPattern e - --- | Turn an expression into a pattern. Fails if the expression is not a --- valid pattern. -exprToPattern :: Expr -> Parser Pattern -exprToPattern e = do - let failure = parseErrorRange e $ "Not a valid pattern: " ++ prettyShow e - case e of - Ident x -> return $ IdentP x - App _ e1 e2 -> AppP <$> exprToPattern e1 - <*> T.mapM (T.mapM exprToPattern) e2 - Paren r e -> ParenP r - <$> exprToPattern e - Underscore r _ -> return $ WildP r - Absurd r -> return $ AbsurdP r - As r x e -> AsP r x <$> exprToPattern e - Dot r (HiddenArg _ e) -> return $ HiddenP r $ fmap (DotP r) e - Dot r e -> return $ DotP r e - Lit l -> return $ LitP l - HiddenArg r e -> HiddenP r <$> T.mapM exprToPattern e - InstanceArg r e -> InstanceP r <$> T.mapM exprToPattern e - RawApp r es -> RawAppP r <$> mapM exprToPattern es - Quote r -> return $ QuoteP r - Rec r es | Just fs <- mapM maybeLeft es -> do - RecP r <$> T.mapM (T.mapM exprToPattern) fs - Equal r e1 e2 -> return $ EqualP r [(e1, e2)] - Ellipsis r -> return $ EllipsisP r - -- WithApp has already lost the range information of the bars '|' - WithApp r e es -> do - p <- exprToPattern e - ps <- forM es $ \ e -> defaultNamedArg . WithP (getRange e) <$> exprToPattern e -- TODO #2822: Range! - return $ foldl AppP p ps - _ -> failure - -opAppExprToPattern :: OpApp Expr -> Parser Pattern -opAppExprToPattern (SyntaxBindingLambda _ _ _) = parseError "Syntax binding lambda cannot appear in a pattern" -opAppExprToPattern (Ordinary e) = exprToPattern e - --- | Turn an expression into a name. Fails if the expression is not a --- valid identifier. -exprToName :: Expr -> Parser Name -exprToName (Ident (QName x)) = return x -exprToName e = parseErrorRange e $ "Not a valid identifier: " ++ prettyShow e - -stripSingletonRawApp :: Expr -> Expr -stripSingletonRawApp (RawApp _ [e]) = stripSingletonRawApp e -stripSingletonRawApp e = e - -isEqual :: Expr -> Maybe (Expr, Expr) -isEqual e = - case stripSingletonRawApp e of - Equal _ a b -> Just (stripSingletonRawApp a, stripSingletonRawApp b) - _ -> Nothing - -maybeNamed :: Expr -> Named_ Expr -maybeNamed e = - case isEqual e of - Just (Ident (QName x), b) -> named (Ranged (getRange x) (nameToRawName x)) b - _ -> unnamed e - -patternSynArgs :: [Either Hiding LamBinding] -> Parser [Arg Name] -patternSynArgs = mapM pSynArg - where - pSynArg Left{} = parseError "Absurd patterns are not allowed in pattern synonyms" - pSynArg (Right DomainFull{}) = parseError "Unexpected type signature in pattern synonym argument" - pSynArg (Right (DomainFree x)) - | let h = getHiding x, h `notElem` [Hidden, NotHidden] = parseError $ prettyShow h ++ " arguments not allowed to pattern synonyms" - | getRelevance x /= Relevant = parseError "Arguments to pattern synonyms must be relevant" - | otherwise = return $ fmap (boundName . namedThing) x - -parsePanic s = parseError $ "Internal parser error: " ++ s ++ ". Please report this as a bug." - -{- RHS or type signature -} - -data RHSOrTypeSigs - = JustRHS RHS - | TypeSigsRHS Expr - deriving Show - -patternToNames :: Pattern -> Parser [(ArgInfo, Name)] -patternToNames p = - case p of - IdentP (QName i) -> return [(defaultArgInfo, i)] - WildP r -> return [(defaultArgInfo, C.noName r)] - DotP _ (Ident (QName i)) -> return [(setRelevance Irrelevant defaultArgInfo, i)] - RawAppP _ ps -> concat <$> mapM patternToNames ps - _ -> parseError $ - "Illegal name in type signature: " ++ prettyShow p - -funClauseOrTypeSigs :: [Attr] -> LHS -> RHSOrTypeSigs -> WhereClause -> Parser [Declaration] -funClauseOrTypeSigs attrs lhs mrhs wh = do - -- traceShowM lhs - case mrhs of - JustRHS rhs -> do - unless (null attrs) $ parseErrorRange attrs $ "A function clause cannot have attributes" - return [FunClause lhs rhs wh False] - TypeSigsRHS e -> case wh of - NoWhere -> case lhs of - LHS p _ _ | hasEllipsis p -> parseError "The ellipsis ... cannot have a type signature" - LHS _ _ (_:_) -> parseError "Illegal: with in type signature" - LHS _ (_:_) _ -> parseError "Illegal: rewrite in type signature" - LHS p _ _ | hasWithPatterns p -> parseError "Illegal: with patterns in type signature" - LHS p [] [] -> forMM (patternToNames p) $ \ (info, x) -> do - info <- applyAttrs attrs info - return $ typeSig info x e - _ -> parseError "A type signature cannot have a where clause" - -parseDisplayPragma :: Range -> Position -> String -> Parser Pragma -parseDisplayPragma r pos s = - case parsePosString pos defaultParseFlags [normal] funclauseParser s of - ParseOk s [FunClause (LHS lhs [] []) (RHS rhs) NoWhere ca] | null (parseInp s) -> - return $ DisplayPragma r lhs rhs - _ -> parseError "Invalid DISPLAY pragma. Should have form {-# DISPLAY LHS = RHS #-}." - -typeSig :: ArgInfo -> Name -> Expr -> Declaration -typeSig i n e = TypeSig i n (Generalized e) - --- * Attributes - --- | Parsed attribute. - -data Attr = Attr - { attrRange :: Range -- ^ Range includes the @. - , attrName :: String -- ^ Concrete, user written attribute for error reporting. - , theAttr :: Attribute -- ^ Parsed attribute. - } - -instance HasRange Attr where - getRange = attrRange - -instance SetRange Attr where - setRange r (Attr _ x a) = Attr r x a - --- | Parse an attribute. -toAttribute :: (HasRange e, Pretty e) => e -> Parser Attr -toAttribute x = maybe failure (return . Attr (getRange x) y) $ stringToAttribute y - where - y = prettyShow x - failure = parseErrorRange x $ "Unknown attribute: " ++ y - --- | Apply an attribute to thing (usually `Arg`). --- This will fail if one of the attributes is already set --- in the thing to something else than the default value. -applyAttr :: (LensAttribute a) => Attr -> a -> Parser a -applyAttr attr@(Attr r x a) = maybe failure return . setPristineAttribute a - where - failure = errorConflictingAttribute attr - --- | Apply attributes to thing (usually `Arg`). --- Expects a reversed list of attributes. --- This will fail if one of the attributes is already set --- in the thing to something else than the default value. -applyAttrs :: (LensAttribute a) => [Attr] -> a -> Parser a -applyAttrs rattrs arg = do - let attrs = reverse rattrs - checkForUniqueAttribute (isJust . isQuantityAttribute ) attrs - checkForUniqueAttribute (isJust . isRelevanceAttribute) attrs - foldM (flip applyAttr) arg attrs - --- | Report a parse error if two attributes in the list are of the same kind, --- thus, present conflicting information. -checkForUniqueAttribute :: (Attribute -> Bool) -> [Attr] -> Parser () -checkForUniqueAttribute p attrs = do - let pAttrs = filter (p . theAttr) attrs - when (length pAttrs >= 2) $ - errorConflictingAttributes pAttrs - --- | Report an attribute as conflicting (e.g., with an already set value). -errorConflictingAttribute :: Attr -> Parser a -errorConflictingAttribute a = parseErrorRange a $ "Conflicting attribute: " ++ attrName a - --- | Report attributes as conflicting (e.g., with each other). --- Precondition: List not emtpy. -errorConflictingAttributes :: [Attr] -> Parser a -errorConflictingAttributes [a] = errorConflictingAttribute a -errorConflictingAttributes as = parseErrorRange as $ - "Conflicting attributes: " ++ unwords (map attrName as) -{-# LINE 1 "templates/GenericTemplate.hs" #-} -{-# LINE 1 "templates/GenericTemplate.hs" #-} -{-# LINE 1 "" #-} -{-# LINE 1 "" #-} -{-# LINE 10 "" #-} -# 1 "/usr/include/stdc-predef.h" 1 3 4 - -# 17 "/usr/include/stdc-predef.h" 3 4 - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -{-# LINE 10 "" #-} -{-# LINE 1 "/usr/local/stow/ghc-8.6.5/lib/ghc-8.6.5/include/ghcversion.h" #-} - - - - - - - - - - - - - - - -{-# LINE 10 "" #-} -{-# LINE 1 "/tmp/ghc31894_0/ghc_2.h" #-} - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -{-# LINE 10 "" #-} -{-# 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)) :: Bool) -#define GTE(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.>=# m)) :: Bool) -#define EQ(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.==# m)) :: 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 -{-# LINE 43 "templates/GenericTemplate.hs" #-} - -data Happy_IntList = HappyCons Happy_GHC_Exts.Int# Happy_IntList - - - - - - - -{-# LINE 65 "templates/GenericTemplate.hs" #-} - -{-# LINE 75 "templates/GenericTemplate.hs" #-} - -{-# LINE 84 "templates/GenericTemplate.hs" #-} - -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 0#, 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)) :: 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 False - action - | check = indexShortOffAddr happyTable off_i - | 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 `mod` 16) - where unbox_int (Happy_GHC_Exts.I# x) = x - - - - - - -data HappyAddr = HappyA# Happy_GHC_Exts.Addr# - - ------------------------------------------------------------------------------ --- HappyState data type (not arrays) - -{-# LINE 180 "templates/GenericTemplate.hs" #-} - ------------------------------------------------------------------------------ --- 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 (0# 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 0# tk old_st (HappyCons ((action)) (sts)) - (saved_tok `HappyStk` _ `HappyStk` stk) = --- trace ("discarding state, depth " ++ show (length stk)) $ - happyDoAction 0# tk action 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) +{-# LANGUAGE PatternGuards #-} + +{-| The parser is generated by Happy (). + - + - Ideally, ranges should be as precise as possible, to get messages that + - emphasize precisely the faulting term(s) upon error. + - + - However, interactive highlighting is only applied at the end of each + - mutual block, keywords are only highlighted once (see + - `TypeChecking.Rules.Decl'). So if the ranges of two declarations + - interleave, one must ensure that keyword ranges are not included in + - the intersection. (Otherwise they are uncolored by the interactive + - highlighting.) + - + -} +module Agda.Syntax.Parser.Parser ( + moduleParser + , moduleNameParser + , exprParser + , exprWhereParser + , tokensParser + , holeContentParser + , splitOnDots -- only used by the internal test-suite + ) where + +import Control.Applicative ( (<|>) ) +import Control.Monad + +import Data.Bifunctor (first) +import Data.Char +import Data.List +import Data.Maybe +import Data.Monoid +import qualified Data.Traversable as T + +import Debug.Trace + +import Agda.Syntax.Position hiding (tests) +import Agda.Syntax.Parser.Monad +import Agda.Syntax.Parser.Lexer +import Agda.Syntax.Parser.Tokens +import Agda.Syntax.Concrete as C +import Agda.Syntax.Concrete.Attribute +import Agda.Syntax.Concrete.Pattern +import Agda.Syntax.Common +import Agda.Syntax.Fixity +import Agda.Syntax.Notation +import Agda.Syntax.Literal + +import Agda.TypeChecking.Positivity.Occurrence hiding (tests) + +import Agda.Utils.Either hiding (tests) +import Agda.Utils.Functor +import Agda.Utils.Hash +import Agda.Utils.List ( spanJust, chopWhen ) +import Agda.Utils.Monad +import Agda.Utils.Pretty +import qualified Agda.Utils.Maybe.Strict as Strict + +import Agda.Utils.Impossible +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.19.12 + +newtype HappyAbsSyn = HappyAbsSyn HappyAny +#if __GLASGOW_HASKELL__ >= 607 +type HappyAny = Happy_GHC_Exts.Any +#else +type HappyAny = forall a . a +#endif +newtype HappyWrap10 = HappyWrap10 ([Token]) +happyIn10 :: ([Token]) -> (HappyAbsSyn ) +happyIn10 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap10 x) +{-# INLINE happyIn10 #-} +happyOut10 :: (HappyAbsSyn ) -> HappyWrap10 +happyOut10 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut10 #-} +newtype HappyWrap11 = HappyWrap11 ([Token]) +happyIn11 :: ([Token]) -> (HappyAbsSyn ) +happyIn11 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap11 x) +{-# INLINE happyIn11 #-} +happyOut11 :: (HappyAbsSyn ) -> HappyWrap11 +happyOut11 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut11 #-} +newtype HappyWrap12 = HappyWrap12 (Token) +happyIn12 :: (Token) -> (HappyAbsSyn ) +happyIn12 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap12 x) +{-# INLINE happyIn12 #-} +happyOut12 :: (HappyAbsSyn ) -> HappyWrap12 +happyOut12 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut12 #-} +newtype HappyWrap13 = HappyWrap13 (([Pragma], [Declaration])) +happyIn13 :: (([Pragma], [Declaration])) -> (HappyAbsSyn ) +happyIn13 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap13 x) +{-# INLINE happyIn13 #-} +happyOut13 :: (HappyAbsSyn ) -> HappyWrap13 +happyOut13 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut13 #-} +newtype HappyWrap14 = HappyWrap14 (()) +happyIn14 :: (()) -> (HappyAbsSyn ) +happyIn14 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap14 x) +{-# INLINE happyIn14 #-} +happyOut14 :: (HappyAbsSyn ) -> HappyWrap14 +happyOut14 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut14 #-} +newtype HappyWrap15 = HappyWrap15 (()) +happyIn15 :: (()) -> (HappyAbsSyn ) +happyIn15 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap15 x) +{-# INLINE happyIn15 #-} +happyOut15 :: (HappyAbsSyn ) -> HappyWrap15 +happyOut15 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut15 #-} +newtype HappyWrap16 = HappyWrap16 (Interval) +happyIn16 :: (Interval) -> (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 (()) +happyIn17 :: (()) -> (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 (Ranged Double) +happyIn18 :: (Ranged Double) -> (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 (Name) +happyIn19 :: (Name) -> (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 ([Name]) +happyIn20 :: ([Name]) -> (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 (Range) +happyIn21 :: (Range) -> (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 (Arg Name) +happyIn22 :: (Arg Name) -> (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 ([Arg Name]) +happyIn23 :: ([Arg Name]) -> (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 ([Arg Name]) +happyIn24 :: ([Arg Name]) -> (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 (([Attr], [Arg Name])) +happyIn25 :: (([Attr], [Arg Name])) -> (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 (Attr) +happyIn26 :: (Attr) -> (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 ([Attr]) +happyIn27 :: ([Attr]) -> (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 ([Attr]) +happyIn28 :: ([Attr]) -> (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 (QName) +happyIn29 :: (QName) -> (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 (QName) +happyIn30 :: (QName) -> (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 (Name) +happyIn31 :: (Name) -> (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 ([Name]) +happyIn32 :: ([Name]) -> (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 ([NamedArg Binder]) +happyIn33 :: ([NamedArg Binder]) -> (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 (Either [NamedArg Binder] [Expr]) +happyIn34 :: (Either [NamedArg Binder] [Expr]) -> (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 ([NamedArg Binder]) +happyIn35 :: ([NamedArg Binder]) -> (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 ([String]) +happyIn36 :: ([String]) -> (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 ([(Interval, String)]) +happyIn37 :: ([(Interval, String)]) -> (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 ([(Interval, String)]) +happyIn38 :: ([(Interval, String)]) -> (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 (Name) +happyIn39 :: (Name) -> (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 (QName) +happyIn40 :: (QName) -> (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 ([QName]) +happyIn41 :: ([QName]) -> (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 (Expr) +happyIn42 :: (Expr) -> (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 (Expr) +happyIn43 :: (Expr) -> (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 ([Expr]) +happyIn44 :: ([Expr]) -> (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 ([Expr]) +happyIn45 :: ([Expr]) -> (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 (Expr) +happyIn46 :: (Expr) -> (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 (Maybe Expr) +happyIn47 :: (Maybe Expr) -> (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 (Expr) +happyIn48 :: (Expr) -> (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 ([Expr]) +happyIn49 :: ([Expr]) -> (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 ([Expr]) +happyIn50 :: ([Expr]) -> (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 (Expr) +happyIn51 :: (Expr) -> (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 (Expr) +happyIn52 :: (Expr) -> (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 (Expr) +happyIn53 :: (Expr) -> (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 (Expr) +happyIn54 :: (Expr) -> (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 (RecordAssignments) +happyIn55 :: (RecordAssignments) -> (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 (RecordAssignments) +happyIn56 :: (RecordAssignments) -> (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 (RecordAssignment) +happyIn57 :: (RecordAssignment) -> (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 (ModuleAssignment) +happyIn58 :: (ModuleAssignment) -> (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 ([FieldAssignment]) +happyIn59 :: ([FieldAssignment]) -> (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 ([FieldAssignment]) +happyIn60 :: ([FieldAssignment]) -> (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 (FieldAssignment) +happyIn61 :: (FieldAssignment) -> (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 (Telescope) +happyIn62 :: (Telescope) -> (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 (Telescope) +happyIn63 :: (Telescope) -> (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 ([TypedBinding]) +happyIn64 :: ([TypedBinding]) -> (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 (TypedBinding) +happyIn65 :: (TypedBinding) -> (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 (TypedBinding) +happyIn66 :: (TypedBinding) -> (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 (TypedBinding) +happyIn67 :: (TypedBinding) -> (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 (TypedBinding) +happyIn68 :: (TypedBinding) -> (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 (TypedBinding) +happyIn69 :: (TypedBinding) -> (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 ([LamBinding]) +happyIn70 :: ([LamBinding]) -> (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 (Either ([LamBinding], Hiding) [Expr]) +happyIn71 :: (Either ([LamBinding], Hiding) [Expr]) -> (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 ([Either Hiding LamBinding]) +happyIn72 :: ([Either Hiding LamBinding]) -> (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 (Either [Either Hiding LamBinding] [Expr]) +happyIn73 :: (Either [Either Hiding LamBinding] [Expr]) -> (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 (LamClause) +happyIn74 :: (LamClause) -> (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 (LamClause) +happyIn75 :: (LamClause) -> (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 (LamClause) +happyIn76 :: (LamClause) -> (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 ([LamClause]) +happyIn77 :: ([LamClause]) -> (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 ([LamClause]) +happyIn78 :: ([LamClause]) -> (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 ([LamBinding]) +happyIn79 :: ([LamBinding]) -> (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 ([LamBinding]) +happyIn80 :: ([LamBinding]) -> (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 ([LamBinding]) +happyIn81 :: ([LamBinding]) -> (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 ([LamBinding]) +happyIn82 :: ([LamBinding]) -> (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 (Maybe Pattern) +happyIn83 :: (Maybe Pattern) -> (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 (Either [LamBinding] [Expr]) +happyIn84 :: (Either [LamBinding] [Expr]) -> (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 ([DoStmt]) +happyIn85 :: ([DoStmt]) -> (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 (DoStmt) +happyIn86 :: (DoStmt) -> (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 ([LamClause]) +happyIn87 :: ([LamClause]) -> (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 (ImportDirective) +happyIn88 :: (ImportDirective) -> (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 ([ImportDirective]) +happyIn89 :: ([ImportDirective]) -> (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 (ImportDirective) +happyIn90 :: (ImportDirective) -> (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 ((Using, Range)) +happyIn91 :: ((Using, Range)) -> (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 (([ImportedName], Range)) +happyIn92 :: (([ImportedName], Range)) -> (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 (([Renaming] , Range)) +happyIn93 :: (([Renaming] , Range)) -> (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 ([Renaming]) +happyIn94 :: ([Renaming]) -> (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 (Renaming) +happyIn95 :: (Renaming) -> (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 ((Maybe Fixity, Name)) +happyIn96 :: ((Maybe Fixity, Name)) -> (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 (ImportedName) +happyIn97 :: (ImportedName) -> (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 (ImportedName) +happyIn98 :: (ImportedName) -> (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 ([ImportedName]) +happyIn99 :: ([ImportedName]) -> (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 ([ImportedName]) +happyIn100 :: ([ImportedName]) -> (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 (LHS) +happyIn101 :: (LHS) -> (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 ([Either RewriteEqn [Expr]]) +happyIn102 :: ([Either RewriteEqn [Expr]]) -> (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 (HoleContent) +happyIn103 :: (HoleContent) -> (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 (WhereClause) +happyIn104 :: (WhereClause) -> (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 (ExprWhere) +happyIn105 :: (ExprWhere) -> (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 ([Declaration]) +happyIn106 :: ([Declaration]) -> (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 ([Declaration]) +happyIn107 :: ([Declaration]) -> (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 ([Arg Declaration]) +happyIn108 :: ([Arg Declaration]) -> (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 ([Declaration]) +happyIn109 :: ([Declaration]) -> (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 (RHSOrTypeSigs) +happyIn110 :: (RHSOrTypeSigs) -> (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 (Declaration) +happyIn111 :: (Declaration) -> (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 (Declaration) +happyIn112 :: (Declaration) -> (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 (Declaration) +happyIn113 :: (Declaration) -> (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 (Declaration) +happyIn114 :: (Declaration) -> (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 ((Name, IsInstance)) +happyIn115 :: ((Name, IsInstance)) -> (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 (Declaration) +happyIn116 :: (Declaration) -> (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 (Declaration) +happyIn117 :: (Declaration) -> (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 ([Declaration]) +happyIn118 :: ([Declaration]) -> (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 (Declaration) +happyIn119 :: (Declaration) -> (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 (Declaration) +happyIn120 :: (Declaration) -> (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 (Declaration) +happyIn121 :: (Declaration) -> (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 (Declaration) +happyIn122 :: (Declaration) -> (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 (Declaration) +happyIn123 :: (Declaration) -> (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 (Declaration) +happyIn124 :: (Declaration) -> (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 (Declaration) +happyIn125 :: (Declaration) -> (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 (Declaration) +happyIn126 :: (Declaration) -> (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 (Declaration) +happyIn127 :: (Declaration) -> (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 (Declaration) +happyIn128 :: (Declaration) -> (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 ([Arg Name]) +happyIn129 :: ([Arg Name]) -> (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 ([RString]) +happyIn130 :: ([RString]) -> (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 ([NamedArg HoleName]) +happyIn131 :: ([NamedArg HoleName]) -> (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 (NamedArg HoleName) +happyIn132 :: (NamedArg HoleName) -> (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 (HoleName) +happyIn133 :: (HoleName) -> (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 (HoleName) +happyIn134 :: (HoleName) -> (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 (RString) +happyIn135 :: (RString) -> (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 (Maybe Range) +happyIn136 :: (Maybe Range) -> (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 ([Declaration]) +happyIn137 :: ([Declaration]) -> (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 ([Expr]) +happyIn138 :: ([Expr]) -> (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 (Telescope -> Parser ModuleApplication) +happyIn139 :: (Telescope -> Parser ModuleApplication) -> (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 (Declaration) +happyIn140 :: (Declaration) -> (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 (Declaration) +happyIn141 :: (Declaration) -> (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 (Name) +happyIn142 :: (Name) -> (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 ([Declaration]) +happyIn143 :: ([Declaration]) -> (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 (Declaration) +happyIn144 :: (Declaration) -> (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 (Pragma) +happyIn145 :: (Pragma) -> (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 (Pragma) +happyIn146 :: (Pragma) -> (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 (Pragma) +happyIn147 :: (Pragma) -> (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 (Pragma) +happyIn148 :: (Pragma) -> (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 (Pragma) +happyIn149 :: (Pragma) -> (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 (Pragma) +happyIn150 :: (Pragma) -> (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 (Pragma) +happyIn151 :: (Pragma) -> (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 (Pragma) +happyIn152 :: (Pragma) -> (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 (Pragma) +happyIn153 :: (Pragma) -> (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 (Pragma) +happyIn154 :: (Pragma) -> (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 (Pragma) +happyIn155 :: (Pragma) -> (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 (Pragma) +happyIn156 :: (Pragma) -> (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 (Pragma) +happyIn157 :: (Pragma) -> (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 (Pragma) +happyIn158 :: (Pragma) -> (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 (Pragma) +happyIn159 :: (Pragma) -> (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 (Pragma) +happyIn160 :: (Pragma) -> (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 (Pragma) +happyIn161 :: (Pragma) -> (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 (Pragma) +happyIn162 :: (Pragma) -> (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 (Pragma) +happyIn163 :: (Pragma) -> (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 (Pragma) +happyIn164 :: (Pragma) -> (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 (Pragma) +happyIn165 :: (Pragma) -> (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 (Pragma) +happyIn166 :: (Pragma) -> (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 (Pragma) +happyIn167 :: (Pragma) -> (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 (Pragma) +happyIn168 :: (Pragma) -> (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 ([(Range, Occurrence)]) +happyIn169 :: ([(Range, Occurrence)]) -> (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 ((Range, Occurrence)) +happyIn170 :: ((Range, Occurrence)) -> (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 ([TypeSignature]) +happyIn171 :: ([TypeSignature]) -> (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 ([TypeSignature]) +happyIn172 :: ([TypeSignature]) -> (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 ([TypeSignature]) +happyIn173 :: ([TypeSignature]) -> (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 ([Arg TypeSignature]) +happyIn174 :: ([Arg TypeSignature]) -> (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 ([Arg TypeSignature]) +happyIn175 :: ([Arg TypeSignature]) -> (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 ([Arg TypeSignature]) +happyIn176 :: ([Arg TypeSignature]) -> (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 ([Arg TypeSignature]) +happyIn177 :: ([Arg TypeSignature]) -> (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 (((Maybe (Ranged Induction), Maybe HasEta, Maybe (Name, IsInstance)), [Declaration])) +happyIn178 :: (((Maybe (Ranged Induction), Maybe HasEta, Maybe (Name, IsInstance)), [Declaration])) -> (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 ([RecordDirective]) +happyIn179 :: ([RecordDirective]) -> (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 (RecordDirective) +happyIn180 :: (RecordDirective) -> (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 (Ranged HasEta) +happyIn181 :: (Ranged HasEta) -> (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 (Ranged Induction) +happyIn182 :: (Ranged Induction) -> (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 ([Declaration]) +happyIn183 :: ([Declaration]) -> (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 ([Declaration]) +happyIn184 :: ([Declaration]) -> (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 ([Declaration]) +happyIn185 :: ([Declaration]) -> (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 ([Declaration]) +happyIn186 :: ([Declaration]) -> (HappyAbsSyn ) +happyIn186 x = Happy_GHC_Exts.unsafeCoerce# (HappyWrap186 x) +{-# INLINE happyIn186 #-} +happyOut186 :: (HappyAbsSyn ) -> HappyWrap186 +happyOut186 x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyOut186 #-} +happyInTok :: (Token) -> (HappyAbsSyn ) +happyInTok x = Happy_GHC_Exts.unsafeCoerce# x +{-# INLINE happyInTok #-} +happyOutTok :: (HappyAbsSyn ) -> (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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x40\x00\x9d\x0a\x01\x00\x00\xe6\xd8\x6a\x81\x05\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\x01\x74\x2a\x04\x00\x00\x98\x63\xab\x05\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x08\x40\x00\x9d\x0a\x01\x00\x00\xe6\xd8\x6a\x81\x05\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\x01\x74\x2b\x0c\x00\x00\x98\x63\xab\x05\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\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\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\xd0\x89\x00\x00\x00\x60\x8e\xa9\x16\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x04\xd0\xa9\x10\x00\x00\x60\x8e\xa5\x16\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\x02\x10\x40\xa7\x42\x00\x00\x80\x39\xb6\x5a\x60\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\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\x0c\x20\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x23\x08\x05\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\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\xd0\x89\x00\x00\x00\x60\x8e\xa1\x16\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\x02\x10\x40\xa7\x42\x00\x00\x80\x39\x96\x5a\x60\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\x74\x22\x00\x00\x00\x98\x63\xa8\x05\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x08\x40\x00\x9d\x0a\x01\x00\x00\xe6\x58\x6a\x81\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x08\x00\x00\x00\xe6\x18\x6a\x81\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\x74\x22\x00\x00\x00\x98\x63\xa8\x05\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xc0\x08\x42\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x16\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\x84\xd0\xa9\x10\x00\x00\x60\x8e\xed\x16\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\x02\x10\x40\xa7\x42\x00\x00\x80\x39\x96\x5a\x60\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\x20\x00\x01\x74\x2a\x04\x00\x00\x98\x63\xab\x0f\x16\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\x04\xd0\xa9\x10\x00\x00\x60\x8e\xad\x36\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x04\xd0\xa9\x10\x00\x00\x60\x8e\xad\x16\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\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\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\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\x40\x27\x02\x00\x00\x80\x39\x86\x5a\x60\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\x9d\x08\x00\x00\x00\xe6\x18\x6a\x81\x05\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\x01\x74\x2a\x04\x00\x00\x98\x63\xbb\x05\x16\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\x04\xd0\xa9\x10\x00\x00\x60\x8e\xad\x3e\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\x02\x10\x40\xa7\x42\x00\x00\x80\x39\xb6\xda\x60\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\x10\x1d\xde\xfb\x9d\x3b\x01\x00\x00\xe6\xd8\x6a\xa1\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\x01\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\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\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\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\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\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\x08\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\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\x10\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\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\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\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\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\x40\x27\x02\x00\x00\x80\x39\x86\x5a\x60\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\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\x10\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\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\xff\xff\x7f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\x10\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\x02\x10\x40\xa7\x42\x00\x00\x80\x39\xb6\x5a\x60\x01\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\x00\x9d\x0a\x01\x00\x00\xe6\xd8\x6a\x81\x05\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\x01\x74\x2a\x04\x00\x00\x98\x63\xa9\x05\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x20\x00\x01\x74\x2a\x04\x00\x00\x98\x63\xab\x05\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\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\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\x08\x40\x00\x9d\x0a\x01\x00\x00\xe6\xd8\x6a\x81\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\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\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\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\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\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\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\x20\x00\x01\x74\x2a\x04\x00\x00\x98\x63\xab\x05\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xc0\x08\x42\x81\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\x01\x74\x2a\x04\x00\x00\x98\x63\xab\x05\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x23\x08\x05\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\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\x08\x42\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x08\x05\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\x02\x10\x42\xa7\x42\x00\x00\x80\x39\xb6\x5b\x60\x01\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\x00\x9d\x0a\x01\x00\x00\xe6\xd8\xea\x83\x05\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\x01\x74\x2a\x04\x00\x00\x98\x63\xab\x8d\x16\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\x04\xd0\xa9\x10\x00\x00\x60\x8e\xed\x16\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\x02\x10\x40\xa7\x42\x00\x00\x80\x39\xb6\xfa\x60\x01\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\x00\x9d\x0a\x01\x00\x00\xe6\xd8\x6a\x83\x05\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\x01\x74\x2a\x04\x00\x00\x98\x63\xbb\x05\x16\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\x04\xd0\xa9\x10\x00\x00\x60\x8e\xad\x3e\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\x02\x10\x40\xa7\x42\x00\x00\x80\x39\xb6\xda\x60\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\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\x20\x00\x01\x74\x2a\x04\x00\x00\x98\x63\xab\x05\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x27\x02\x00\x00\x80\x39\x86\x5a\x60\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\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\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\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\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\x10\x1d\xde\xfb\x9d\x3b\x01\x00\x00\xe6\xd8\x6a\xa1\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\x23\x08\x05\x02\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\x04\xd0\xa9\x10\x00\x00\x60\x8e\xad\x16\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\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\xc0\x08\x42\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x84\xd0\xa9\x10\x00\x00\x60\x8e\xad\x16\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\x02\x10\x40\xa7\x42\x00\x00\x80\x39\xb6\x5a\x60\x01\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\x00\x9d\x0a\x01\x00\x00\xe6\xd8\x6a\x81\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x50\x00\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\x08\x9d\x0a\x01\x00\x00\xe6\xd8\x6a\x81\x05\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\x01\x74\x2a\x04\x00\x00\x98\x63\xab\x05\x16\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\x04\xd0\xa9\x10\x00\x00\x60\x8e\xad\x16\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\xa7\x42\x00\x00\x80\x39\xb6\x5a\x60\x01\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\x00\x9d\x0a\x01\x00\x00\xe6\xd8\x6a\x81\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\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\xd0\x89\x00\x00\x00\x60\x8e\xa1\x16\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x00\x9d\x0a\x01\x00\x00\xe6\xd8\x6a\x81\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\xa7\x42\x00\x00\x80\x39\xb6\x5a\x60\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\x20\x00\x01\x74\x2a\x04\x00\x00\x98\x63\xa9\x05\x16\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\x04\xd0\xa9\x10\x00\x00\x60\x8e\xad\x16\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\x00\x00\x00\x00\x00\x00\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\x00\x9d\x0a\x01\x00\x00\xe6\x58\x6a\x81\x05\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\x01\x74\x2a\x04\x00\x00\x98\x63\xa9\x05\x16\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\x04\xd0\xa9\x10\x00\x00\x60\x8e\xa5\x16\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\x02\x10\x40\xa7\x42\x00\x00\x80\x39\x96\x5a\x60\x01\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\x00\x9d\x0a\x01\x00\x00\xe6\x58\x6a\x81\x05\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\x01\x74\x2a\x04\x00\x00\x98\x63\xa9\x05\x16\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\x04\xd0\xa9\x10\x00\x00\x60\x8e\xad\x16\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\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\x08\x40\x00\x9d\x0a\x01\x00\x00\xe6\xd8\x6a\x81\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\x08\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\x80\x00\x04\xd0\xa9\x10\x00\x00\x60\x8e\xad\x16\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\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\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\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\x80\x00\x04\xd0\xa9\x10\x00\x00\x60\x8e\xad\x16\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\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\x9d\x08\x00\x00\x00\xe6\x18\x6a\x81\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\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\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\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\x80\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\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\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\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\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\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\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\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\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\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\x08\x40\x00\x9d\x0a\x01\x00\x00\xe6\x58\x6a\x81\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\x00\x80\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\x08\x40\x00\x9d\x0a\x01\x00\x00\xe6\x58\x6a\x81\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\x00\x00\x00\x00\x00\x00\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\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\x80\x00\x04\xd0\xa9\x10\x00\x00\x60\x8e\xa5\x16\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\x02\x10\x40\xa7\x42\x00\x00\x80\x39\x96\x5a\x60\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\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\x20\x00\x01\x74\x2a\x04\x00\x00\x98\x63\xa9\x05\x16\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\x04\xd0\xa9\x10\x00\x00\x60\x8e\xa5\x16\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\x02\x10\x40\xa7\x42\x00\x00\x80\x39\x96\x5a\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\xc0\x08\x42\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x20\x14\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\x02\x10\x42\xa7\x42\x00\x00\x80\x39\xb6\x5b\x60\x01\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\x00\x9d\x0a\x01\x00\x00\xe6\xd8\xea\x83\x05\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\x01\x74\x2a\x04\x00\x00\x98\x63\xab\x0d\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x89\x00\x00\x00\x60\x8e\xa1\x16\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\x40\x27\x02\x00\x00\x80\x39\x86\x5a\x60\x01\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\x08\x40\x00\x9d\x0a\x01\x00\x00\xe6\xd8\x6a\x81\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\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\x20\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\x08\x40\x00\x9d\x0a\x01\x00\x00\xe6\xd8\x6a\x81\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\x20\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\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\x40\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\x40\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\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\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\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\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\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\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\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\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\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\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\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\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\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\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\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\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\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\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\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\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\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\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\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\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\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\x80\x00\x04\xd0\xa9\x10\x00\x00\x60\x8e\xad\x16\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\x00\x00\x00\x80\x50\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\xc0\x08\x42\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x44\x87\xf7\x7e\xe7\x4e\x00\x00\x80\x39\xb6\x5a\x6a\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\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\x80\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\xc0\x08\x42\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x30\x82\x50\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\xc0\x08\x42\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\x80\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\x02\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\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\x30\x82\x50\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\x60\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x10\x1d\xde\xfb\x9d\x3b\x01\x00\x00\xe6\xd8\x6a\xa1\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\x74\x22\x00\x00\x00\x98\x63\xa8\x05\x16\x00\x00\x00\x00\x00\x00\x00\x00\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\x20\x14\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\x20\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\xc0\x08\x42\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x0c\x08\x14\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\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\x01\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\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\x02\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\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\x80\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\x23\x08\x05\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\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\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\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\x40\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\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\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\x08\x40\x00\x9d\x0a\x01\x00\x00\xe6\xd8\x6a\x81\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\x10\x08\x05\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\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\x04\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\x10\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\x80\x00\x04\xd0\xa9\x10\x00\x00\x60\x8e\xad\x16\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\x02\x10\x40\xa7\x42\x00\x00\x80\x39\xb6\x5a\x60\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\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\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\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\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\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\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\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\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\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\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\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\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\x20\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\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\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\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\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\x02\x10\x40\xa7\x42\x00\x00\x80\x39\xb6\x5a\x60\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\x20\x00\x01\x74\x2a\x04\x00\x00\x98\x63\xab\x05\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x08\x00\x00\x00\xe6\x18\x6a\x81\x05\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\x88\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\x80\x00\x04\xd0\xa9\x10\x00\x00\x60\x8e\xad\x3e\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x04\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\x20\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\x80\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\x08\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\x20\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x00\x04\xd0\xa9\x10\x00\x00\x60\x8e\xa5\x16\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x01\x74\x2a\x04\x00\x00\x98\x63\xa9\x85\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\xa7\x42\x00\x00\x80\x39\xb6\x5a\x60\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\x80\x00\x04\xd0\xa9\x10\x00\x00\x60\x8e\xad\x16\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\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\x80\x00\x00\x88\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\x80\x00\x04\xd0\xa9\x10\x00\x00\x60\x8e\xad\x16\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x08\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\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\x08\x00\x80\x08\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\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\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\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\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\x80\x00\x04\xd0\xa9\x10\x00\x00\x60\x8e\xa5\x16\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x40\xa7\x42\x00\x00\x80\x39\xb6\x5a\x60\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\x20\x00\x01\x74\x2a\x04\x00\x00\x98\x63\xa9\x85\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\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\x20\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\x80\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\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\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\x02\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\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\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\x80\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\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\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\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\x02\x10\x40\xa7\x42\x00\x00\x80\x39\xb6\x5a\x60\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\x02\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\x04\xd0\xa9\x10\x00\x00\x60\x8e\xad\x16\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\x02\x10\x40\xa7\x42\x00\x00\x80\x39\xb6\x5a\x60\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\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\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\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\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\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\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x30\x00\x50\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\x14\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\x50\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\xc0\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\x03\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\x80\x00\x04\xd0\xa9\x10\x00\x00\x60\x8e\xad\x16\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x20\x00\x01\x74\x2a\x04\x00\x00\x98\x63\xab\x05\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x80\x08\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\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\x0c\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\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\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\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\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\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\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\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\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\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\x01\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\x20\x00\x01\x74\x2a\x04\x00\x00\x98\x63\xab\x05\x16\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x27\x02\x00\x00\x80\x39\x86\x5a\x60\x01\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\x22\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\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\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\xd0\x1f\xdf\xff\x9d\x3b\x01\x00\x00\xe6\xd8\x6a\xa1\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\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\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\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\x01\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\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\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\x01\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\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\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\x02\x00\x20\x02\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\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\x04\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\x40\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\x01\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\x04\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\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\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\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\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\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\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\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\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\x80\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\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\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\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\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\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\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\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\x01\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\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\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\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\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\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\x20\x00\x00\x22\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\x02\x10\x40\xa7\x42\x00\x00\x80\x39\xb6\xfa\x60\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\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\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\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\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\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\x30\x00\x50\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\xc0\x00\x40\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x0c\x00\x14\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\x30\x00\x50\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\xc0\x00\x40\x81\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\x05\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\x40\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\xe1\xbd\xdf\xb9\x13\x00\x00\x60\x8e\xad\x96\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfd\xf1\xfd\xdf\xb9\x13\x00\x00\x60\x8e\xad\x16\x5a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\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\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\x0e\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\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\x10\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\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\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\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\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\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\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\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\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\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\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\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"# + +{-# NOINLINE happyExpListPerState #-} +happyExpListPerState st = + token_strs_expected + where token_strs = ["error","%dummy","%start_tokensParser","%start_exprParser","%start_exprWhereParser","%start_moduleParser","%start_moduleNameParser","%start_funclauseParser","%start_holeContentParser","Tokens","TokensR","Token","File","maybe_vclose","close","semi","beginImpDir","Float","Id","SpaceIds","DoubleCloseBrace","MaybeDottedId","MaybeDottedIds","ArgIds","ModalArgIds","Attribute","Attributes","Attributes1","QId","ModuleName","BId","SpaceBIds","CommaBIds","CommaBIdAndAbsurds","BIdsWithHiding","PragmaStrings","Strings","ForeignCode","PragmaName","PragmaQName","PragmaQNames","Expr","Expr1","WithExprs","Application","Expr2","LetBody","ExtendedOrAbsurdLam","Application3","Application3PossiblyEmpty","Expr3Curly","Expr3NoCurly","ExprOrAttr","Expr3","RecordAssignments","RecordAssignments1","RecordAssignment","ModuleAssignment","FieldAssignments","FieldAssignments1","FieldAssignment","TeleArrow","Telescope1","TypedBindings","TypedBinding","TBind","ModalTBind","TBindWithHiding","ModalTBindWithHiding","LamBindings","AbsurdLamBindings","LamBinds","LamBindsAbsurd","NonAbsurdLamClause","AbsurdLamClause","LamClause","LamClauses","LamWhereClauses","ForallBindings","TypedUntypedBindings1","TypedUntypedBindings","DomainFreeBinding","MaybeAsPattern","DomainFreeBindingAbsurd","DoStmts","DoStmt","DoWhere","ImportDirective","ImportDirectives","ImportDirective1","Using","Hiding","RenamingDir","Renamings","Renaming","RenamingTarget","ImportName_","ImportName","CommaImportNames","CommaImportNames1","LHS","WithRewriteExpressions","HoleContent","WhereClause","ExprWhere","Declaration","TypeSigs","ArgTypeSigs","FunClause","RHS","Data","DataSig","Record","RecordSig","RecordConstructorName","Infix","Fields","Generalize","Mutual","Abstract","Private","Instance","Macro","Postulate","Primitive","UnquoteDecl","Syntax","PatternSyn","PatternSynArgs","SimpleIds","HoleNames","HoleName","SimpleTopHole","SimpleHole","SimpleId","MaybeOpen","Open","OpenArgs","ModuleApplication","ModuleMacro","Module","Underscore","TopLevel","Pragma","DeclarationPragma","OptionsPragma","BuiltinPragma","RewritePragma","ForeignPragma","CompilePragma","StaticPragma","InlinePragma","NoInlinePragma","InjectivePragma","DisplayPragma","EtaPragma","NoTerminationCheckPragma","NonTerminatingPragma","TerminatingPragma","NonCoveringPragma","MeasurePragma","CatchallPragma","ImpossiblePragma","NoPositivityCheckPragma","NoUniverseCheckPragma","PolarityPragma","WarningOnUsagePragma","WarningOnImportPragma","Polarities","Polarity","TypeSignatures0","TypeSignatures","TypeSignatures1","ArgTypeSignatures","ArgTypeSignatures1","ArgTypeSignaturesOrEmpty","ArgTypeSignatures0","RecordDeclarations","RecordDirectives","RecordDirective","RecordEta","RecordInduction","Declarations","Declarations0","Declarations1","TopDeclarations","'abstract'","'codata'","'coinductive'","'constructor'","'data'","'eta-equality'","'field'","'forall'","'variable'","'hiding'","'import'","'in'","'inductive'","'infix'","'infixl'","'infixr'","'instance'","'overlap'","'let'","'macro'","'module'","'mutual'","'no-eta-equality'","'open'","'pattern'","'postulate'","'primitive'","'private'","'Prop'","'public'","'quote'","'quoteTerm'","'record'","'renaming'","'rewrite'","'Set'","'syntax'","'tactic'","'to'","'unquote'","'unquoteDecl'","'unquoteDef'","'using'","'where'","'do'","'with'","'BUILTIN'","'CATCHALL'","'DISPLAY'","'ETA'","'FOREIGN'","'COMPILE'","'IMPOSSIBLE'","'INJECTIVE'","'INLINE'","'NOINLINE'","'MEASURE'","'NO_TERMINATION_CHECK'","'NO_POSITIVITY_CHECK'","'NO_UNIVERSE_CHECK'","'NON_TERMINATING'","'NON_COVERING'","'OPTIONS'","'POLARITY'","'WARNING_ON_USAGE'","'WARNING_ON_IMPORT'","'REWRITE'","'STATIC'","'TERMINATING'","setN","propN","tex","comment","'...'","'..'","'.'","';'","':'","'='","'_'","'?'","'->'","'\\\\'","'@'","'|'","'('","')'","'(|'","'|)'","'(|)'","'{{'","'}}'","'{'","'}'","vopen","vclose","vsemi","'{-#'","'#-}'","id","q_id","string","literal","%eof"] + bit_start = st * 290 + bit_end = (st + 1) * 290 + read_bit = readArrayBit happyExpList + bits = map read_bit [bit_start..bit_end - 1] + bits_indexed = zip bits [0..289] + token_strs_expected = concatMap f bits_indexed + f (False, _) = [] + f (True, nr) = [token_strs !! nr] + +happyActOffsets :: HappyAddr +happyActOffsets = HappyA# "\x00\x00\x37\x0e\x37\x0e\xaa\xff\x71\x00\x84\x0e\x73\x07\x00\x00\x90\x05\xc2\xff\x00\x00\x53\x18\x00\x00\x00\x00\xcd\xff\x00\x00\x00\x00\x00\x00\x00\x00\xc1\x00\x00\x00\x00\x00\x00\x00\x2c\x0b\xd1\x0e\xe3\xff\x00\x00\xd7\x02\x00\x00\xd4\xff\xb3\x02\xeb\xff\x00\x00\x00\x00\x00\x00\x95\x18\x51\x16\x00\x00\xd7\x18\x00\x00\x22\x00\x51\x16\x00\x00\x00\x00\x00\x00\x19\x19\x5b\x19\x00\x00\x00\x00\xd7\x05\x15\x02\xc9\x07\x51\x16\x00\x00\x16\x08\x78\x0b\x00\x00\x00\x00\x00\x00\x1e\x0f\xeb\x01\x53\x00\x89\x02\x10\x00\x9d\x19\x9d\x19\xc5\x0b\x63\x08\x12\x0c\x00\x00\x00\x00\x10\x00\x10\x00\x28\x05\xf8\xff\x10\x00\x10\x00\x10\x00\x00\x00\x67\x00\x50\x00\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\xdd\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\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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\xf6\x00\x0c\x01\x0c\x01\x0a\x01\x0a\x01\x0a\x01\x2d\x01\x2d\x01\x05\x01\x2d\x01\x3b\x01\x40\x01\xa0\x01\xac\x01\xb1\x01\xdf\x19\xb3\x01\x83\x00\xb3\x01\x1d\x0f\xbc\x01\x00\x00\x00\x00\x6b\x01\x00\x00\xcc\x01\xad\x01\x00\x00\x00\x00\x00\x00\xf8\xff\x6b\x0f\x6b\x0f\x51\x16\x00\x00\x00\x00\x89\x02\xb8\x0f\x17\x02\x1a\x02\x00\x00\x18\x02\x0c\x02\x0f\x02\x24\x02\x6b\x01\x6b\x01\x1f\x02\x05\x10\x2d\x02\x52\x01\x35\x02\x39\x02\x3e\x02\x3c\x02\xe5\x02\x00\x00\x52\x10\x00\x00\x4c\x02\x52\x03\x52\x10\x00\x00\x51\x02\x00\x00\xc3\x0a\xa8\x04\x49\x02\xca\x02\xc1\x03\x00\x00\xba\x08\x07\x09\x54\x09\x5f\x0c\xa1\x09\xac\x0c\xf9\x0c\xa1\x09\x46\x0d\xeb\x01\x52\x10\x00\x00\x21\x1a\xeb\x01\x58\x02\xe5\x02\xad\x02\x26\x07\xf6\x0b\x52\x10\x73\x02\xf6\x0b\x00\x00\x9d\x0d\x9f\x10\x9f\x10\x00\x00\xda\x02\xe8\x02\x9d\x0d\x9f\x10\x9f\x10\x00\x00\x00\x00\x00\x00\x00\x00\xec\x10\xec\x10\x87\x02\x21\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xec\x10\x00\x00\x00\x00\x39\x11\x00\x00\x51\x16\x86\x11\x00\x00\x51\x16\x9d\x16\x9d\x16\xe9\x16\x35\x17\x35\x17\xd3\x11\x62\x02\xd3\x11\x87\x01\xd3\x11\x86\x02\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x20\x12\xae\x02\x21\x1a\xa3\x02\x00\x00\xbd\x02\x00\x00\x00\x00\xab\x02\x00\x00\xf8\x02\x17\x00\x81\x01\x00\x00\xf6\x02\x6b\x01\x04\x03\x0b\x03\x6b\x01\x14\x03\x19\x01\x20\x03\x6d\x12\x00\x00\xa1\x01\x20\x01\x81\x17\x40\x03\x69\x03\x4a\x03\x53\x03\x76\x03\xcd\x17\xcd\x17\x76\x03\xcd\x17\xcd\x17\xb9\x12\xc8\x0d\x6b\x03\xc8\x0d\xf8\x09\x45\x0a\xea\x0d\x00\x00\x00\x00\x7f\x03\x00\x00\x21\x1a\x63\x1a\x09\x00\x00\x00\x00\x00\x00\x00\x05\x13\x8c\x03\x00\x00\x00\x00\x00\x00\x16\x01\x00\x00\x00\x00\x05\x13\x78\x01\x91\x03\xf8\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe6\xff\x8d\x03\xa5\x03\xc2\x03\xcd\x03\xd6\x03\xa0\x03\xe2\x03\xe2\x03\xe2\x03\xe5\x03\xb3\x03\xe1\x03\xed\x03\xf0\x03\xf5\x03\xf4\x03\x07\x04\x0c\x04\xfa\x03\x13\x04\x1c\x04\x26\x04\x33\x04\x54\x04\x59\x04\x05\x13\x57\x02\x15\x0e\x00\x00\x00\x00\xc3\x04\x00\x00\x00\x00\x19\x00\x00\x00\x62\x0e\x56\x04\x00\x00\xaf\x0e\xaf\x0e\x00\x00\x00\x00\x00\x00\xa6\x01\x00\x00\xa6\x01\xa6\x01\x00\x00\xbb\x01\x00\x00\xaf\x0e\x00\x00\x00\x00\x00\x00\xe5\x02\x26\x07\x00\x00\xc1\x06\x00\x00\x92\x04\x9b\x04\x5d\x04\x5d\x04\x00\x00\xa5\x1a\xaf\x0e\xef\xff\xaf\x0e\x7b\x04\x40\x04\x00\x00\xae\x00\x76\x04\x00\x00\xa6\x01\x00\x00\x00\x00\x00\x00\xae\x04\x2d\x00\xaf\x0e\x00\x00\x9f\x04\x00\x00\x93\x04\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x86\x00\x52\x13\x9d\x03\x00\x00\x00\x00\x00\x00\x97\x04\x87\x00\x87\x00\x00\x00\x00\x00\x9f\x13\x9f\x13\x00\x00\x00\x00\x96\x04\x00\x00\x00\x00\x9a\x04\x8f\x04\x9c\x04\xa1\x04\x00\x00\x00\x00\x9e\x04\x91\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaf\x04\xb2\x04\xb7\x04\xb9\x04\x00\x00\xc8\x04\xe0\x01\xd2\x04\xd4\x04\x00\x00\xd9\x04\xd9\x04\x00\x00\x9f\x13\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x13\x00\x00\x00\x00\xa5\x1a\xb5\x00\x92\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x00\x82\x01\x87\x01\x00\x00\xb7\x01\x87\x01\x00\x00\x00\x00\xcd\x04\xec\x13\x00\x00\x00\x00\xec\x13\x00\x00\x38\x14\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x38\x14\x85\x14\x00\x00\x00\x00\xac\x04\x00\x05\xa6\x04\x00\x00\x06\x05\xe5\x02\x00\x00\xb5\x00\xd2\x14\x00\x00\x00\x00\x00\x00\x03\x05\x0d\x05\x00\x00\xa5\x01\x00\x00\xfa\x04\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x10\x05\x00\x00\x21\x05\x24\x05\x00\x00\x19\x05\x00\x00\x1f\x15\x00\x00\x00\x00\x00\x00\x00\x00\x6b\x15\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb8\x15\x6b\x01\x00\x00\x00\x00\x00\x00\x00\x00\x1c\x05\x1e\x05\x2b\x05\x00\x00\x96\x05\xe0\x01\xe0\x01\x23\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe1\x00\x9e\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2d\x05\x35\x05\xa8\x01\xad\x05\xc6\x05\xb0\x01\x00\x00\xcf\x05\x54\x01\xbf\x05\x04\x16\x00\x00\xd8\x05\x04\x16\x04\x16\xfa\x05\xef\x05\xe5\x02\xef\x05\x00\x00\xf8\x05\x00\x00\xb2\x03\x00\x00\xb2\x03\x00\x00\x5e\x03\x00\x00\x00\x00\xe6\x01\x78\x02\xf4\x00\xf4\x00\x04\x16\x00\x00\xf1\x05\x04\x16\x00\x00\xb5\x00\x00\x00\x00\x00\x00\x00\x27\x06\x00\x00\x00\x00\xf4\x00\xf9\x05\x0a\x06\x0a\x06\x6b\x01\x00\x00\x0a\x06\x0a\x06\x00\x00\x0a\x06\x0a\x06\x00\x00\x00\x00\x00\x00\xae\x00\x04\x16\x00\x00\xe7\x1a\xb5\x00\x00\x00\x62\x03\x00\x00\x00\x00\x00\x00\x52\x06\x00\x00\xf7\x05\x1b\x06\x00\x00\x31\x06\x35\x06\x87\x00\x00\x00\x42\x06\x44\x06\x87\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x06\x00\x00\x32\x06\x00\x00\x00\x00\x00\x00\x00\x00\xb5\x00\x00\x00\x00\x00\xae\x00\x00\x00\xf6\xff\xfe\xff\xf6\xff\x00\x00\x00\x00\x4a\x06\x4d\x06\x00\x00\x36\x06\x36\x06\x53\x06\x58\x06\x82\x06\x00\x00\x00\x00\x54\x06\x00\x00\x00\x00\xe0\x01\x00\x00\x50\x06\x00\x00\x4f\x06\x4f\x06\x59\x06\x56\x06\x56\x06\x00\x00\x00\x00\xae\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x57\x06\x00\x00\x00\x00\x5d\x06\x00\x00\x65\x06\xb5\x00\x00\x00\x00\x00\xdf\x0a\x00\x00\x00\x00\xec\x03\x5a\x06\x6b\x01\x67\x06\x6b\x01\x5e\x03\x5e\x03\x00\x00\x68\x06\x00\x00\x00\x00\x00\x00\x5e\x03\x5e\x03\x5e\x03\x5e\x03\x00\x00\x6b\x01\x00\x00\x00\x00\x5b\x04\x00\x00\x00\x00\x00\x00\x5c\x06\x76\x06\x77\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6f\x06\x3f\x00\xc3\x06\x00\x00\x00\x00\x00\x00\x00\x00\xf6\xff\x00\x00\x00\x00\x00\x00\x00\x00\x7c\x06\x7c\x06\x7c\x06\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x80\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x17\x00\x00\x00\x80\x06\x80\x06\x80\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"# + +happyGotoOffsets :: HappyAddr +happyGotoOffsets = HappyA# "\xff\x03\x07\x1e\x19\x18\xe5\x06\x99\x01\x2b\x04\x38\x18\xeb\x06\xef\x06\x00\x00\x00\x00\x43\x03\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4e\x0d\x26\x1e\x00\x00\x00\x00\xd2\x03\x00\x00\x00\x00\xd6\x01\x46\x06\x00\x00\x00\x00\x00\x00\xb1\x00\x4d\x0a\x00\x00\xb9\x07\x00\x00\x00\x00\xa2\x0a\x00\x00\x00\x00\x00\x00\x14\x02\x80\x02\x00\x00\x00\x00\xfb\x03\x25\x00\xac\x03\x6f\x0c\x00\x00\xe0\x1b\x0a\x1c\x00\x00\x00\x00\x00\x00\x7b\x02\x98\x06\x00\x00\x91\x06\x00\x00\x16\x04\x79\x07\x45\x1e\xe8\x1d\x64\x1e\x00\x00\x00\x00\x00\x00\x00\x00\x92\x00\x99\x06\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x74\x03\xf0\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\xf4\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\x79\x03\xf1\x06\x55\x06\x5b\x06\xf7\x06\xfa\x06\xfb\x06\x99\x03\xb0\x03\x23\x00\xe4\x03\xfe\x02\xf3\x06\xf2\x03\x94\x03\xfc\x03\x5f\x01\xfc\x06\x74\x04\xbc\x04\x00\x00\x00\x00\x00\x00\x00\x00\xee\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa6\x06\x83\x1e\xa2\x1e\xb4\x0c\x00\x00\x00\x00\xa2\x06\x85\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xfe\x06\xff\x06\x00\x00\xf1\x0a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x06\xfe\x02\x00\x00\xc1\x1e\x00\x00\xc6\x06\xf3\x02\xe0\x1e\x00\x00\x00\x00\x00\x00\xd0\x03\x00\x00\x00\x00\x98\x00\xc4\x00\x00\x00\x16\x03\x58\x1c\x88\x03\x91\x1b\x36\x1d\x8f\x1d\xb0\x1b\x66\x1d\xb8\x1d\xb4\x06\x33\x1b\x00\x00\x28\x08\xb7\x06\x00\x00\xf5\x01\xf5\x06\x5c\x02\xd3\x03\xff\x1e\x00\x00\x50\x04\x00\x00\x16\x03\x9a\x1c\xb8\x1c\x00\x00\x00\x00\x00\x00\xcb\x03\xd6\x1c\xf4\x1c\x00\x00\x00\x00\x00\x00\x00\x00\x1e\x1f\x3d\x1f\x00\x00\xa9\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\x5c\x1f\x00\x00\x00\x00\x37\x0b\x00\x00\xaf\x0d\x0b\x0d\x00\x00\xa8\x18\xd4\x07\x21\x08\xea\x18\x6e\x08\xc5\x08\x91\x0b\x00\x00\xd0\x0b\x12\x07\x24\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x13\x07\x00\x00\x7b\x1f\x00\x00\x4a\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0f\x00\x00\x00\xd2\x06\x1c\x07\x1a\x07\x00\x00\x00\x00\x1e\x07\x00\x00\x00\x00\x1f\x07\x00\x00\x00\x00\x00\x00\xff\x0c\x00\x00\x2b\x07\x2c\x07\xa3\x0d\x00\x00\x00\x00\x00\x00\x00\x00\xe3\x06\x12\x09\x5f\x09\xea\x06\xac\x09\x03\x0a\x07\x00\xb8\x04\x00\x00\x1d\x05\xe9\x03\x7c\x1c\x12\x1d\x00\x00\x00\x00\x00\x00\x00\x00\x75\x08\xb9\x00\x18\x07\x00\x00\x00\x00\x00\x00\x9a\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x35\x01\x00\x00\x00\x00\xb9\x1f\x66\x01\x00\x00\xda\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2a\x07\x00\x00\x00\x00\x00\x00\x2f\x07\x33\x07\x38\x07\x3b\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x3f\x07\x3d\x07\x3e\x07\x00\x00\x2c\x02\x40\x07\x00\x00\xc6\x04\x00\x00\x00\x00\xd8\x1f\x70\x03\x0f\x05\x00\x00\x00\x00\xfc\xff\x00\x00\x00\x00\xfd\xff\x00\x00\x2e\x01\x52\x07\x00\x00\x43\x06\x51\x06\x00\x00\x00\x00\x00\x00\x67\x01\x00\x00\xa8\x02\xcb\x02\x00\x00\x03\x00\x00\x00\xa8\x06\x00\x00\x00\x00\x00\x00\x3b\x03\xf2\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x38\x04\x44\x04\x00\x00\xc5\x00\xb6\x06\x00\x00\x0d\x07\x00\x00\xaa\x02\x00\x00\xf6\x04\xa5\x06\xe5\x00\xf7\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x1b\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x01\x05\x00\x00\x00\x00\x00\x00\x00\x00\x34\x1c\x3d\x03\x00\x00\x00\x00\x00\x00\x00\x00\x94\x04\xa5\x04\x00\x00\x00\x00\xf7\x1f\x16\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x42\x07\x00\x00\x00\x00\xc0\x06\x00\x00\x00\x00\x46\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x07\x48\x07\x00\x00\x4c\x07\x00\x00\x49\x07\x4a\x07\x00\x00\x35\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x54\x20\x00\x00\x00\x00\xe0\x00\xde\x03\xe8\x1d\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x05\x00\x00\x5e\x07\x00\x00\x00\x00\x5f\x07\x00\x00\x00\x00\x00\x00\x33\x01\x00\x00\x00\x00\xd1\x01\x00\x00\x73\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x03\x00\x00\x0e\x05\x92\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd9\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x08\x00\x00\x00\x9d\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb1\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x6e\x02\x63\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x53\x07\x57\x07\x5a\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd5\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x00\x00\x00\x00\x02\x07\x00\x00\x69\x01\x00\x00\xd0\x06\xd0\x20\x00\x00\x3c\x00\xef\x20\x0e\x21\x00\x00\x86\x04\x2b\x00\x9d\x04\x00\x00\x00\x00\x00\x00\xf9\xff\x00\x00\x47\x00\x00\x00\x81\x02\x00\x00\x00\x00\x7b\x07\x7c\x07\x6a\x03\x8a\x03\x2d\x21\x00\x00\xb5\x04\x4c\x21\x00\x00\x1a\x05\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9a\x03\x00\x00\x7e\x07\x80\x07\x84\x07\x00\x00\x67\x05\x6c\x05\x00\x00\x7d\x05\x10\x06\x00\x00\x00\x00\x00\x00\x20\x06\x6b\x21\x00\x00\x5b\x01\xe7\x05\x00\x00\x30\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x28\x01\x14\x07\x00\x00\x00\x00\x00\x00\xb2\x05\x00\x00\x00\x00\x00\x00\xb4\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\x40\x06\x00\x00\x00\x00\x3a\x06\x00\x00\x77\x00\xdf\x00\x09\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x91\x07\x95\x07\x00\x00\x00\x00\x00\x00\x98\x07\x00\x00\x00\x00\x00\x00\x00\x00\x8a\x07\x00\x00\x00\x00\x00\x00\x2d\x07\x30\x07\x00\x00\x36\x07\x37\x07\x00\x00\x00\x00\x3f\x06\x00\x00\x00\x00\x00\x00\xa2\x07\x00\x00\xac\x07\x00\x00\x00\x00\xa8\x05\x00\x00\x0e\x07\x4e\x06\x00\x00\x00\x00\xe8\x1d\x00\x00\x00\x00\xdb\x00\x00\x00\xad\x07\x00\x00\xb0\x07\x2a\x03\x81\x04\x00\x00\xba\x05\x00\x00\x00\x00\x00\x00\x87\x04\x90\x04\xa4\x04\xab\x04\x00\x00\xb5\x07\x00\x00\x00\x00\xfc\xff\x00\x00\x00\x00\x00\x00\xc6\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xae\x07\xfb\xff\x2b\x01\x00\x00\x00\x00\x00\x00\x00\x00\xfa\xff\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x07\xc0\x07\xc2\x07\x00\x00\x00\x00\x00\x00\x00\x00\xbc\x07\xc6\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd1\x07\x00\x00\xd0\x07\xd2\x07\xd5\x07\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"# + +happyAdjustOffset :: Happy_GHC_Exts.Int# -> Happy_GHC_Exts.Int# +happyAdjustOffset off = off + +happyDefActions :: HappyAddr +happyDefActions = HappyA# "\xf6\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\xfe\x00\x00\xf8\xff\x66\xff\x69\xff\x00\x00\x1e\xff\xa0\xfe\x4b\xff\x4a\xff\x48\xff\x47\xff\x44\xff\x00\x00\x1b\xff\x1a\xff\x1f\xff\x40\xff\x00\x00\x00\x00\x0c\xff\x0a\xff\x9f\xfe\x00\x00\x00\x00\x00\x00\x31\xff\x2f\xff\x2e\xff\x00\x00\x00\x00\x30\xff\x00\x00\x2d\xff\x00\x00\x00\x00\x2c\xff\x2b\xff\x20\xff\x00\x00\x00\x00\x32\xff\x33\xff\x00\x00\x00\x00\x4e\xfe\x00\x00\x28\xff\x00\x00\x00\x00\x85\xff\x67\xff\x1d\xff\x00\x00\xa3\xfe\x00\x00\x7b\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x66\xff\x65\xff\x00\x00\x00\x00\x4e\xfe\x9e\xfe\x00\x00\x00\x00\x00\x00\x9a\xfe\x00\x00\x00\x00\xef\xfd\x98\xfe\x97\xfe\x96\xfe\x95\xfe\x94\xfe\x93\xfe\x99\xfe\x92\xfe\x91\xfe\x90\xfe\x8f\xfe\x8e\xfe\x8d\xfe\x8c\xfe\x8b\xfe\x84\xfe\x86\xfe\x85\xfe\x00\x00\x8a\xfe\x89\xfe\x88\xfe\x8d\xff\x87\xfe\x40\xfe\x29\xfe\x3f\xfe\x3e\xfe\x3c\xfe\x3d\xfe\x3b\xfe\x39\xfe\x38\xfe\x3a\xfe\x2e\xfe\x2d\xfe\x34\xfe\x35\xfe\x36\xfe\x33\xfe\x30\xfe\x2f\xfe\x37\xfe\x2c\xfe\x2b\xfe\x2a\xfe\x32\xfe\x31\xfe\xed\xfd\x41\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x34\xff\x26\xff\x00\x00\x82\xff\x00\x00\x00\x00\x27\xff\x24\xff\x23\xff\x9e\xfe\x00\x00\x00\x00\x00\x00\xa4\xfe\x68\xff\x7b\xfe\x00\x00\x1e\xff\x00\x00\x60\xff\x5f\xff\x00\x00\x00\x00\x32\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5a\xff\x00\x00\x00\x00\x00\x00\x00\x00\x4f\xfe\x6c\xff\x00\x00\x64\xff\xd2\xfe\xeb\xfe\x00\x00\x3a\xff\x00\x00\xf6\xfe\xf3\xfe\xec\xfe\x00\x00\x00\x00\x00\x00\x63\xff\x4e\xfe\x00\x00\x37\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa3\xfe\x00\x00\x3f\xff\x39\xff\xa3\xfe\x00\x00\x19\xff\x3d\xff\x4e\xfe\xd8\xfe\x00\x00\x00\x00\xd9\xfe\xd4\xfe\x4e\xfe\x00\x00\x00\x00\x0b\xff\x00\x00\x00\x00\x4e\xfe\x00\x00\x00\x00\x0d\xff\x4f\xff\x46\xff\x38\xff\x00\x00\x00\x00\x00\x00\x00\x00\xf7\xff\xf5\xff\xf4\xff\xf3\xff\xf2\xff\xf1\xff\xef\xff\xee\xff\xed\xff\xca\xff\xec\xff\xeb\xff\xea\xff\xe9\xff\xe8\xff\xe7\xff\xe6\xff\xe5\xff\xde\xff\xe4\xff\xe3\xff\xe2\xff\xe1\xff\xe0\xff\xdf\xff\xdd\xff\xdc\xff\xdb\xff\xda\xff\xd9\xff\xd8\xff\xd7\xff\xd6\xff\xd5\xff\xd4\xff\xd3\xff\xd2\xff\xd1\xff\xd0\xff\xcf\xff\xce\xff\xcd\xff\xcc\xff\xcb\xff\xc9\xff\xf0\xff\xc8\xff\xc7\xff\xc6\xff\xc4\xff\xc3\xff\xc2\xff\xc5\xff\xc1\xff\xc0\xff\xbf\xff\xbd\xff\xbe\xff\xbb\xff\xbc\xff\xba\xff\xb9\xff\xb8\xff\xb7\xff\xb6\xff\xb1\xff\xb2\xff\xb5\xff\xb4\xff\xb3\xff\xb0\xff\xaf\xff\xae\xff\xad\xff\xac\xff\xab\xff\xaa\xff\xa9\xff\xa8\xff\xa7\xff\xa6\xff\xa5\xff\xa4\xff\xa3\xff\xa2\xff\xa1\xff\xa0\xff\x9f\xff\x9e\xff\x9d\xff\x9c\xff\x9b\xff\x9a\xff\x99\xff\x98\xff\x97\xff\x96\xff\x95\xff\x94\xff\x93\xff\x92\xff\x91\xff\x90\xff\x8f\xff\x25\xff\x00\x00\x4c\xff\x4e\xff\x00\x00\x5f\xff\x40\xff\x00\x00\x5a\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x60\xff\x00\x00\x00\x00\x00\x00\x5a\xff\xdb\xfe\xdc\xfe\x43\xff\xda\xfe\x00\x00\x42\xff\x00\x00\x66\xff\x4a\xfe\x00\x00\x18\xff\x17\xff\x14\xff\x15\xff\x12\xff\xa1\xfe\xc0\xfe\x00\x00\xc4\xfe\xa2\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe5\xfe\x00\x00\x40\xff\xdf\xfe\x00\x00\x00\x00\x37\xff\xe9\xfe\x00\x00\xe8\xfe\xea\xfe\xd2\xfe\x00\x00\x00\x00\xd2\xfe\x00\x00\x00\x00\x37\xff\xf2\xfe\xee\xfe\xf3\xfe\x4e\xfe\x00\x00\x00\x00\xf7\xfe\x45\xff\xed\xfe\xd1\xfe\x00\x00\x4a\xfe\x3d\xff\xfd\xfe\x02\xff\x03\xff\x00\x00\x00\x00\x29\xff\x00\xff\x01\xff\x00\x00\xfe\xfe\xff\xfe\x00\x00\x00\x00\x00\x00\x9e\xfe\x49\xff\x7d\xfe\x7c\xfe\x7f\xfe\x1c\xff\x81\xff\x2a\xff\x35\xff\x00\x00\x00\x00\x00\x00\x00\x00\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\xff\x00\x00\x00\x00\x00\x00\x57\xff\x00\x00\x00\x00\x83\xff\x00\x00\x00\x00\x00\x00\x00\x00\xd5\xfe\xf2\xfd\x6b\xfe\x00\x00\x67\xfe\x0c\xfe\x00\x00\x68\xfe\x61\xfe\x00\x00\x6d\xfe\xd5\xfe\xd5\xfe\x42\xfe\x69\xfe\x6a\xfe\x00\x00\x86\xff\x00\x00\x00\x00\x6e\xfe\x02\xfe\x6f\xfe\xd5\xfe\x6c\xfe\x8e\xff\x8c\xff\x00\x00\x4e\xfe\x89\xff\xf0\xfd\x9d\xfe\x00\x00\x00\x00\x00\x00\x00\x00\xf1\xfd\x4a\xfe\xd5\xfe\x00\x00\xd5\xfe\x00\x00\x00\x00\x03\xfe\x00\x00\x00\x00\x6b\xff\x61\xff\x72\xfe\x71\xfe\x70\xfe\x00\x00\x00\x00\xd5\xfe\x60\xfe\x00\x00\x0d\xfe\x00\x00\x09\xfe\x00\x00\x8a\xff\x8b\xff\xf3\xfd\x00\x00\x12\xff\x00\x00\x5d\xfe\x5b\xfe\x56\xfe\x00\x00\x00\x00\x00\x00\x50\xfe\x66\xfe\x00\x00\x00\x00\x84\xff\x1a\xfe\x00\x00\x51\xff\x50\xff\x00\x00\x57\xff\x00\x00\x00\x00\x10\xfe\x52\xff\x00\x00\x59\xff\x19\xfe\x1b\xfe\x14\xfe\x15\xfe\x1c\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x16\xfe\x00\x00\x55\xff\x00\x00\x59\xff\x17\xfe\x00\x00\x00\x00\x7e\xfe\x00\x00\x5e\xff\x5c\xff\xfb\xfe\x5d\xff\x5b\xff\x00\x00\xf9\xfe\xfc\xfe\x4a\xfe\xbc\xfe\x00\x00\xd3\xfe\xf0\xfe\xef\xfe\xf1\xfe\xf5\xfe\xf4\xfe\xe5\xfe\xe3\xfe\xe2\xfe\xdd\xfe\x00\x00\x00\x00\x00\x00\xcf\xfe\x00\x00\x00\x00\xd0\xfe\xe4\xfe\x00\x00\x37\xff\x3c\xff\x88\xff\x37\xff\x36\xff\x00\x00\x09\xff\x07\xff\x08\xff\x06\xff\x04\xff\x05\xff\x00\x00\xc3\xfe\x41\xff\xc1\xfe\x00\x00\x00\x00\x00\x00\x11\xff\x10\xff\x00\x00\x22\xff\xbc\xfe\x00\x00\x3e\xff\xf4\xfd\xce\xfe\x00\x00\x5a\xff\xca\xfe\x00\x00\xcc\xfe\x60\xff\x4d\xff\xcb\xfe\xc9\xfe\xcd\xfe\x0e\xff\x13\xff\xbe\xfe\xbc\xfe\xba\xfe\xb9\xfe\xb8\xfe\x00\x00\xbb\xfe\x00\x00\x00\x00\x16\xff\x00\x00\x21\xff\x37\xff\xc2\xfe\xe7\xfe\xe0\xfe\xe1\xfe\x00\x00\xc7\xfe\xc8\xfe\xc5\xfe\xc6\xfe\x3b\xff\x37\xff\x20\xff\x4c\xfe\x49\xfe\xf8\xfe\xfa\xfe\x00\x00\x00\x00\x00\x00\x1d\xfe\x00\x00\x55\xff\x55\xff\x59\xff\x1f\xfe\x21\xfe\x20\xfe\x18\xfe\x58\xff\x28\xfe\x00\x00\x00\x00\x11\xfe\x56\xff\x25\xfe\x22\xfe\x64\xfe\x65\xfe\x00\x00\x53\xfe\x00\x00\x00\x00\x53\xfe\x00\x00\x5c\xfe\x00\x00\x66\xff\x00\x00\x00\x00\x0b\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x62\xff\x00\x00\x80\xfe\x6b\xff\x05\xfe\x6b\xff\x7e\xff\x7a\xff\x6d\xff\x6a\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd7\xfe\x00\x00\x00\x00\xd6\xfe\xbc\xfe\x9c\xfe\x9b\xfe\x4d\xfe\x78\xfe\x79\xfe\x82\xfe\x7c\xff\x00\x00\x00\x00\x00\x00\x00\x00\x7f\xff\x00\x00\x00\x00\x80\xff\x00\x00\x00\x00\x7b\xff\x04\xfe\x06\xfe\x00\x00\x00\x00\x43\xfe\x4a\xfe\xbc\xfe\x44\xfe\x00\x00\x62\xfe\x83\xfe\x0a\xfe\x75\xfe\x76\xfe\xfe\xfd\x63\xfe\x5f\xfe\x00\x00\x00\x00\x00\x00\x59\xfe\x00\x00\x00\x00\x00\x00\x5a\xfe\x12\xfe\x0f\xfe\x13\xfe\x0e\xfe\x00\x00\x54\xff\x00\x00\x24\xfe\x1e\xfe\x26\xfe\x27\xfe\xbc\xfe\xde\xfe\xe6\xfe\x00\x00\x0f\xff\xa8\xfe\x87\xff\xa8\xfe\xbd\xfe\xaa\xfe\xa6\xfe\x00\x00\xa7\xfe\x00\x00\x00\x00\x00\x00\xb2\xfe\x00\x00\x87\xff\xb4\xfe\x00\x00\xbf\xfe\x4b\xfe\x55\xff\x23\xfe\x00\x00\x53\xfe\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\xfe\xfb\xfd\x00\x00\xfc\xfd\xf9\xfd\xfa\xfd\x00\x00\xf5\xfd\x00\x00\xf8\xfd\xf6\xfd\x00\x00\xf7\xfd\x00\x00\xbc\xfe\x46\xfe\x47\xfe\x00\x00\x81\xfe\x08\xfe\x6b\xff\x00\x00\x00\x00\x00\x00\x00\x00\x78\xff\x76\xff\x7d\xff\x00\x00\x7a\xfe\x77\xff\x79\xff\x72\xff\x74\xff\x6e\xff\x70\xff\x07\xfe\x20\xff\x45\xfe\x77\xfe\x00\x00\x74\xfe\xff\xfd\x01\xfe\x4e\xfe\x00\x00\x00\x00\x57\xfe\x52\xfe\x51\xfe\x58\xfe\x53\xff\xb7\xfe\x00\x00\x00\x00\x87\xff\xb5\xfe\xac\xfe\xa9\xfe\xb6\xfe\x00\x00\xa5\xfe\xb3\xfe\xb0\xfe\xb1\xfe\x00\x00\x00\x00\x00\x00\xab\xfe\x54\xfe\x55\xfe\xfd\xfd\x00\x00\x00\x00\x48\xfe\x71\xff\x6f\xff\x75\xff\x73\xff\x00\x00\x00\xfe\x00\x00\x00\x00\x00\x00\xaf\xfe\xae\xfe\xad\xfe\x73\xfe"# + +happyCheck :: HappyAddr +happyCheck = HappyA# "\xff\xff\x05\x00\x05\x00\x09\x00\x09\x00\x09\x00\x09\x00\x0a\x00\x0f\x00\x5f\x00\x11\x00\x15\x00\x10\x00\x15\x00\x12\x00\x13\x00\x09\x00\x09\x00\x0f\x00\x15\x00\x11\x00\x0c\x00\x54\x00\x00\x00\x09\x00\x00\x00\x13\x00\x2c\x00\x4f\x00\x21\x00\x22\x00\x23\x00\x24\x00\x09\x00\x26\x00\x27\x00\x2c\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x43\x00\x23\x00\x24\x00\x09\x00\x26\x00\x09\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x09\x00\x52\x00\x13\x00\x14\x00\x13\x00\x09\x00\x32\x00\x33\x00\x68\x00\x4e\x00\x13\x00\x14\x00\x31\x00\x32\x00\x33\x00\x13\x00\x14\x00\x09\x00\x0a\x00\x40\x00\x41\x00\x42\x00\x5f\x00\x44\x00\x66\x00\x0e\x00\x0f\x00\x10\x00\x2b\x00\x56\x00\x58\x00\x09\x00\x5a\x00\x57\x00\x0f\x00\x5b\x00\x11\x00\x2c\x00\x64\x00\x62\x00\x60\x00\x13\x00\x61\x00\x63\x00\x57\x00\x65\x00\x66\x00\x67\x00\x68\x00\x62\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\x29\x00\x2a\x00\x2b\x00\x2c\x00\x60\x00\x68\x00\x60\x00\x7e\x00\x7f\x00\x4f\x00\x64\x00\x82\x00\x83\x00\x09\x00\x5f\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x09\x00\x84\x00\x61\x00\xa5\x00\x98\x00\xa3\x00\x09\x00\x10\x00\x64\x00\x12\x00\x13\x00\x09\x00\x84\x00\x55\x00\x62\x00\xa7\x00\xaf\x00\x81\x00\x15\x00\x00\x00\x5f\x00\x13\x00\x81\x00\x2c\x00\x21\x00\x22\x00\x23\x00\x24\x00\x50\x00\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x0a\x00\x23\x00\x24\x00\x09\x00\x26\x00\x13\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x80\x00\x64\x00\x13\x00\x09\x00\x09\x00\x58\x00\x59\x00\x5a\x00\x4f\x00\x1e\x00\x4e\x00\x64\x00\x65\x00\x22\x00\x13\x00\x15\x00\x53\x00\x2a\x00\x2b\x00\x40\x00\x41\x00\x42\x00\x2b\x00\x44\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x07\x00\x64\x00\x0b\x00\x09\x00\x0f\x00\x64\x00\x11\x00\x5b\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x60\x00\x13\x00\x0f\x00\x63\x00\x11\x00\x65\x00\x66\x00\x67\x00\x68\x00\x4d\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\x29\x00\x2a\x00\x2b\x00\x2c\x00\x60\x00\x60\x00\x61\x00\x7e\x00\x7f\x00\x09\x00\x52\x00\x82\x00\x83\x00\x55\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x09\x00\x07\x00\x54\x00\x55\x00\x98\x00\x57\x00\x09\x00\x10\x00\x80\x00\x12\x00\x13\x00\x09\x00\x62\x00\x09\x00\x4b\x00\x4c\x00\xaf\x00\xb0\x00\x15\x00\x63\x00\x80\x00\x13\x00\x66\x00\x13\x00\x21\x00\x22\x00\x23\x00\x24\x00\x5f\x00\x26\x00\x27\x00\x15\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x50\x00\x23\x00\x24\x00\x64\x00\x26\x00\x64\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x80\x00\x58\x00\x59\x00\x5a\x00\x09\x00\x37\x00\x50\x00\x4e\x00\x09\x00\x64\x00\x65\x00\x5f\x00\x3e\x00\x4d\x00\x13\x00\x09\x00\x09\x00\x67\x00\x13\x00\x40\x00\x41\x00\x42\x00\x48\x00\x5e\x00\x4a\x00\x13\x00\x64\x00\x65\x00\x15\x00\x16\x00\x5e\x00\x54\x00\x55\x00\x61\x00\x57\x00\x5b\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x60\x00\x2a\x00\x2b\x00\x63\x00\x5f\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\x64\x00\x65\x00\x4f\x00\x09\x00\x4f\x00\x64\x00\x77\x00\x7e\x00\x7f\x00\x54\x00\x57\x00\x82\x00\x83\x00\x13\x00\x14\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x5c\x00\x50\x00\x5e\x00\x4d\x00\x98\x00\x11\x00\x12\x00\x4d\x00\x09\x00\x4e\x00\xa9\x00\xaa\x00\xab\x00\xac\x00\x4e\x00\x10\x00\xaf\x00\x12\x00\x13\x00\x09\x00\x80\x00\x64\x00\x65\x00\x61\x00\x09\x00\x5e\x00\x78\x00\x61\x00\x5c\x00\x13\x00\x5e\x00\x7d\x00\x21\x00\x22\x00\x23\x00\x24\x00\x15\x00\x26\x00\x27\x00\x4d\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x4e\x00\x23\x00\x24\x00\x50\x00\x26\x00\x50\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x09\x00\x5f\x00\x50\x00\x5c\x00\x61\x00\x5e\x00\x57\x00\x4e\x00\x4b\x00\x4c\x00\x13\x00\x14\x00\x64\x00\x5f\x00\x64\x00\x37\x00\x23\x00\x54\x00\x5f\x00\x40\x00\x41\x00\x42\x00\x64\x00\x5e\x00\x5b\x00\x64\x00\x5d\x00\x2e\x00\x5e\x00\x45\x00\x46\x00\x09\x00\x48\x00\x64\x00\x4a\x00\x5b\x00\x2d\x00\x2e\x00\x2f\x00\x30\x00\x60\x00\x13\x00\x33\x00\x63\x00\x5e\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\x29\x00\x2a\x00\x2b\x00\x2c\x00\x5b\x00\x62\x00\x5d\x00\x7e\x00\x7f\x00\x66\x00\x1b\x00\x82\x00\x83\x00\x64\x00\x1f\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x09\x00\x4f\x00\x4f\x00\x4e\x00\x98\x00\x5e\x00\x56\x00\x10\x00\x5e\x00\x12\x00\x13\x00\xaa\x00\xab\x00\xac\x00\x4f\x00\x5c\x00\xaf\x00\x5e\x00\x09\x00\x59\x00\x64\x00\x65\x00\x4e\x00\x67\x00\x21\x00\x22\x00\x23\x00\x24\x00\x13\x00\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x09\x00\x09\x00\x10\x00\x57\x00\x0c\x00\x13\x00\x0e\x00\x57\x00\x23\x00\x24\x00\x13\x00\x26\x00\x57\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x5f\x00\x21\x00\x22\x00\x23\x00\x24\x00\x54\x00\x26\x00\x27\x00\x52\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x5f\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x56\x00\x40\x00\x41\x00\x42\x00\x09\x00\x5b\x00\x09\x00\x5d\x00\x5d\x00\x0c\x00\x5b\x00\x0e\x00\x0c\x00\x10\x00\x64\x00\x60\x00\x15\x00\x16\x00\x63\x00\x5e\x00\x65\x00\x66\x00\x67\x00\x68\x00\x52\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\x5b\x00\x09\x00\x5d\x00\x5b\x00\x4e\x00\x4f\x00\x52\x00\x7e\x00\x7f\x00\x64\x00\x57\x00\x82\x00\x83\x00\x15\x00\x16\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x09\x00\x09\x00\x4f\x00\x4b\x00\x4c\x00\x09\x00\x5e\x00\x10\x00\x50\x00\x12\x00\x13\x00\x98\x00\x09\x00\x15\x00\x56\x00\x4d\x00\xaf\x00\x15\x00\x16\x00\x5b\x00\x64\x00\x5d\x00\x13\x00\x14\x00\x21\x00\x22\x00\x23\x00\x24\x00\x64\x00\x26\x00\x27\x00\x50\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x09\x00\x56\x00\x09\x00\x4b\x00\x4c\x00\x2c\x00\x5b\x00\x10\x00\x5d\x00\x12\x00\x13\x00\x37\x00\x13\x00\x14\x00\x56\x00\x64\x00\x19\x00\x56\x00\x3e\x00\x5b\x00\x09\x00\x5d\x00\x5b\x00\x0c\x00\x5d\x00\x0e\x00\x23\x00\x24\x00\x48\x00\x26\x00\x4a\x00\x56\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x5b\x00\x09\x00\x5d\x00\x2e\x00\x2f\x00\x30\x00\x64\x00\x65\x00\x33\x00\x09\x00\x5b\x00\x13\x00\x14\x00\x3a\x00\x3b\x00\x60\x00\x10\x00\x5e\x00\x63\x00\x13\x00\x65\x00\x66\x00\x67\x00\x68\x00\x57\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\x5e\x00\x27\x00\x57\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x7e\x00\x7f\x00\x52\x00\x09\x00\x82\x00\x83\x00\x0c\x00\x0d\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\x95\x00\x96\x00\x97\x00\x98\x00\x99\x00\x9a\x00\x9b\x00\x9c\x00\x9d\x00\x9e\x00\x09\x00\x52\x00\x09\x00\x7e\x00\x7f\x00\x0c\x00\x0d\x00\x10\x00\x30\x00\x12\x00\x13\x00\x52\x00\x4b\x00\x4c\x00\x17\x00\x18\x00\xaf\x00\x50\x00\x09\x00\x52\x00\x52\x00\x0c\x00\x0d\x00\x56\x00\x4b\x00\x4c\x00\x23\x00\x24\x00\x5b\x00\x26\x00\x5d\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x09\x00\x64\x00\x7a\x00\x7b\x00\x5b\x00\x7d\x00\x5d\x00\x10\x00\x52\x00\x12\x00\x13\x00\x38\x00\x39\x00\x64\x00\x11\x00\x12\x00\x19\x00\x64\x00\x65\x00\x40\x00\x41\x00\x54\x00\x43\x00\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\x52\x00\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x09\x00\x4e\x00\x10\x00\x09\x00\x12\x00\x13\x00\x4e\x00\x34\x00\x35\x00\x36\x00\x37\x00\x19\x00\x15\x00\x3a\x00\x3b\x00\x15\x00\x79\x00\x7a\x00\x7b\x00\x4f\x00\x7d\x00\x23\x00\x24\x00\x63\x00\x26\x00\x09\x00\x56\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x5b\x00\x10\x00\x5d\x00\x12\x00\x13\x00\x11\x00\x12\x00\x00\x00\x01\x00\x64\x00\x19\x00\x63\x00\x09\x00\x3a\x00\x3b\x00\x37\x00\x36\x00\x37\x00\x37\x00\x66\x00\x23\x00\x24\x00\x3e\x00\x26\x00\x15\x00\x50\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x63\x00\x56\x00\x48\x00\x46\x00\x4a\x00\x48\x00\x5b\x00\x4a\x00\x5d\x00\x09\x00\x98\x00\xad\x00\xae\x00\x3a\x00\x3b\x00\x64\x00\xad\x00\xae\x00\x66\x00\x13\x00\x7e\x00\x7f\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x37\x00\x66\x00\x09\x00\xa1\x00\xa2\x00\x3c\x00\x3d\x00\x3e\x00\x3f\x00\x10\x00\x66\x00\x12\x00\x13\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x48\x00\x63\x00\x4a\x00\xad\x00\xae\x00\x66\x00\x7e\x00\x7f\x00\x66\x00\x21\x00\x22\x00\x23\x00\x24\x00\x63\x00\x26\x00\x27\x00\x63\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x63\x00\x09\x00\x66\x00\x00\x00\x01\x00\xad\x00\xae\x00\x04\x00\x05\x00\x67\x00\x07\x00\x08\x00\x09\x00\x15\x00\x0b\x00\x7e\x00\x7f\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x66\x00\x13\x00\x14\x00\x15\x00\x16\x00\x66\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x66\x00\x1f\x00\x20\x00\x21\x00\x09\x00\x0a\x00\x24\x00\x25\x00\x26\x00\x66\x00\x28\x00\x29\x00\x2a\x00\x5b\x00\x37\x00\x2d\x00\x63\x00\x09\x00\x4b\x00\x4c\x00\x0c\x00\x63\x00\x0e\x00\x09\x00\xad\x00\xae\x00\x0c\x00\x54\x00\x0e\x00\x46\x00\x64\x00\x48\x00\x09\x00\x4a\x00\x5b\x00\x0c\x00\x5d\x00\x0e\x00\xad\x00\xae\x00\x46\x00\x47\x00\x4f\x00\x64\x00\x4a\x00\x4b\x00\x4c\x00\x4f\x00\xad\x00\xae\x00\x50\x00\x51\x00\x09\x00\x53\x00\x54\x00\x0c\x00\x56\x00\x0e\x00\x58\x00\x09\x00\x5a\x00\x5b\x00\x0c\x00\x5d\x00\x0e\x00\x64\x00\x60\x00\x5f\x00\x62\x00\x2c\x00\x64\x00\x65\x00\x09\x00\x67\x00\x00\x00\x01\x00\x09\x00\x0a\x00\x2c\x00\x05\x00\x4e\x00\x07\x00\x08\x00\x09\x00\x15\x00\x0b\x00\x09\x00\x0a\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x5f\x00\x13\x00\x14\x00\x15\x00\x16\x00\x2c\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x4e\x00\x1f\x00\x20\x00\x21\x00\xad\x00\xae\x00\x24\x00\x25\x00\x26\x00\x53\x00\x28\x00\x29\x00\x2a\x00\x4f\x00\x37\x00\x2d\x00\xad\x00\xae\x00\x4b\x00\x4c\x00\x66\x00\x3e\x00\x66\x00\x50\x00\x63\x00\x52\x00\x05\x00\x06\x00\x63\x00\x56\x00\x63\x00\x48\x00\x63\x00\x4a\x00\x5b\x00\x5e\x00\x5d\x00\x05\x00\x06\x00\x67\x00\x46\x00\x47\x00\x5f\x00\x64\x00\x4a\x00\x4b\x00\x4c\x00\x7c\x00\x7d\x00\x63\x00\x50\x00\x51\x00\x63\x00\x53\x00\x54\x00\x09\x00\x56\x00\x63\x00\x58\x00\x63\x00\x5a\x00\x5b\x00\x52\x00\x5d\x00\x7c\x00\x7d\x00\x60\x00\x15\x00\x62\x00\x09\x00\x64\x00\x65\x00\x01\x00\x67\x00\x05\x00\x06\x00\x05\x00\x66\x00\x07\x00\x08\x00\x09\x00\x15\x00\xad\x00\xae\x00\x63\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x66\x00\x13\x00\x14\x00\x15\x00\x16\x00\x66\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x37\x00\x1f\x00\x20\x00\x21\x00\xad\x00\xae\x00\x24\x00\x25\x00\x26\x00\x4f\x00\x28\x00\x29\x00\x2a\x00\x4d\x00\x37\x00\x2d\x00\x47\x00\x48\x00\x5e\x00\x4a\x00\x57\x00\x3e\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\xad\x00\xae\x00\x57\x00\x48\x00\x56\x00\x4a\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x46\x00\x47\x00\x09\x00\x0a\x00\x4a\x00\x4b\x00\x4c\x00\x09\x00\x0a\x00\x56\x00\x50\x00\x51\x00\x56\x00\x53\x00\x54\x00\x64\x00\x56\x00\x63\x00\x58\x00\x63\x00\x5a\x00\x5b\x00\x4f\x00\x5d\x00\x09\x00\x0a\x00\x60\x00\x66\x00\x62\x00\x5e\x00\x64\x00\x65\x00\x63\x00\x67\x00\x68\x00\x01\x00\x02\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x0a\x00\x0b\x00\x0c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x12\x00\x13\x00\x14\x00\x15\x00\x16\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\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\x01\x00\x63\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x63\x00\x0b\x00\x2c\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x5c\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x4f\x00\x1f\x00\x20\x00\x21\x00\x09\x00\x0a\x00\x24\x00\x25\x00\x26\x00\x5f\x00\x28\x00\x29\x00\x2a\x00\x4b\x00\x4c\x00\x2d\x00\x05\x00\x06\x00\x50\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x56\x00\x7c\x00\x7d\x00\x7c\x00\x7d\x00\x5b\x00\x64\x00\x5d\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x64\x00\x64\x00\x46\x00\x47\x00\x05\x00\x06\x00\x4a\x00\x4b\x00\x4c\x00\x05\x00\x06\x00\x4e\x00\x50\x00\x51\x00\x4f\x00\x53\x00\x54\x00\x09\x00\x56\x00\x5f\x00\x58\x00\x5f\x00\x5a\x00\x5b\x00\x2c\x00\x5d\x00\xad\x00\xae\x00\x5e\x00\x15\x00\x62\x00\x09\x00\x64\x00\x65\x00\x01\x00\x67\x00\x03\x00\x04\x00\x05\x00\x06\x00\x07\x00\x08\x00\x09\x00\x15\x00\xad\x00\xae\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x64\x00\x13\x00\x14\x00\x15\x00\x16\x00\x17\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x37\x00\x1f\x00\x20\x00\x21\x00\x2c\x00\x64\x00\x24\x00\x25\x00\x26\x00\x52\x00\x28\x00\x29\x00\x2a\x00\x52\x00\x37\x00\x2d\x00\x47\x00\x48\x00\x63\x00\x4a\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x52\x00\x63\x00\x52\x00\x4d\x00\x47\x00\x48\x00\x64\x00\x4a\x00\x4e\x00\x4f\x00\x50\x00\x51\x00\x52\x00\x53\x00\x46\x00\x47\x00\x57\x00\x4d\x00\x4a\x00\x4b\x00\x4c\x00\x27\x00\x57\x00\x57\x00\x50\x00\x51\x00\x5e\x00\x53\x00\x54\x00\x09\x00\x56\x00\x64\x00\x58\x00\x5c\x00\x5a\x00\x5b\x00\x5e\x00\x5d\x00\x64\x00\x64\x00\x5f\x00\x15\x00\x62\x00\x09\x00\x64\x00\x65\x00\x01\x00\x67\x00\x5f\x00\x5e\x00\x05\x00\x5f\x00\x07\x00\x08\x00\x09\x00\x15\x00\x0b\x00\x57\x00\x57\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x64\x00\x13\x00\x14\x00\x15\x00\x16\x00\x15\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x37\x00\x1f\x00\x20\x00\x21\x00\x67\x00\x64\x00\x24\x00\x25\x00\x26\x00\x03\x00\x28\x00\x29\x00\x2a\x00\x01\x00\x37\x00\x2d\x00\x47\x00\x48\x00\x02\x00\x4a\x00\xad\x00\x5c\x00\x64\x00\x06\x00\x5e\x00\x04\x00\x0b\x00\x09\x00\xa6\x00\x09\x00\x47\x00\x48\x00\x08\x00\x4a\x00\xa6\x00\x08\x00\x08\x00\x5e\x00\x09\x00\x64\x00\x46\x00\x47\x00\x0b\x00\x0b\x00\x4a\x00\x4b\x00\x4c\x00\xad\x00\x49\x00\x5c\x00\x50\x00\x51\x00\x5c\x00\x53\x00\x54\x00\x09\x00\x56\x00\x05\x00\x58\x00\x25\x00\x5a\x00\x5b\x00\x0b\x00\x5d\x00\x4d\x00\x06\x00\x05\x00\x15\x00\x62\x00\x09\x00\x64\x00\x65\x00\x01\x00\x67\x00\x0b\x00\x0b\x00\x05\x00\x49\x00\x07\x00\x08\x00\x09\x00\x15\x00\x06\x00\x06\x00\x49\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x5e\x00\x13\x00\x14\x00\x15\x00\x16\x00\x25\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x1c\x00\x1d\x00\x37\x00\x1f\x00\x20\x00\x21\x00\x1e\x00\xa4\x00\x24\x00\x25\x00\x26\x00\x1e\x00\x28\x00\x29\x00\x2a\x00\x1e\x00\x37\x00\x2d\x00\x47\x00\x48\x00\x1e\x00\x4a\x00\x1d\x00\x1a\x00\x1d\x00\x09\x00\x1e\x00\x1b\x00\x1e\x00\x9f\x00\x1a\x00\x1e\x00\x47\x00\x48\x00\x1c\x00\x4a\x00\x1a\x00\x1e\x00\x1e\x00\x0b\x00\x0b\x00\x0b\x00\x46\x00\x47\x00\x0b\x00\x1c\x00\x4a\x00\x4b\x00\x4c\x00\x1c\x00\x1a\x00\xa0\x00\x50\x00\x51\x00\xa8\x00\x53\x00\x54\x00\x08\x00\x56\x00\x7d\x00\x58\x00\x7d\x00\x5a\x00\x5b\x00\x09\x00\x5d\x00\x09\x00\x09\x00\x13\x00\x09\x00\x62\x00\x09\x00\x64\x00\x65\x00\x13\x00\x67\x00\x09\x00\x0b\x00\x1d\x00\x7d\x00\x1f\x00\x20\x00\x21\x00\x10\x00\x23\x00\x24\x00\x13\x00\x26\x00\x09\x00\x28\x00\x17\x00\x18\x00\x09\x00\x07\x00\x2d\x00\x2e\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x1c\x00\x05\x00\x23\x00\x24\x00\x7d\x00\x26\x00\x27\x00\x7d\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x09\x00\x7d\x00\x7d\x00\x09\x00\xa8\x00\x09\x00\x0b\x00\x46\x00\x47\x00\x0b\x00\x13\x00\x4a\x00\x4b\x00\x4c\x00\x0b\x00\x05\x00\x09\x00\x50\x00\x51\x00\x08\x00\x53\x00\x54\x00\x08\x00\x56\x00\x08\x00\x58\x00\x13\x00\x5a\x00\x5b\x00\x09\x00\x5d\x00\x08\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x05\x00\x64\x00\x65\x00\x09\x00\x67\x00\x09\x00\x13\x00\x09\x00\x09\x00\xff\xff\x27\x00\x18\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x1d\x00\x13\x00\x1f\x00\x20\x00\x21\x00\x17\x00\x18\x00\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x23\x00\x24\x00\xff\xff\x26\x00\xff\xff\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\x57\x00\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x13\x00\x09\x00\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\x09\x00\xff\xff\x1d\x00\x13\x00\x1f\x00\x20\x00\x21\x00\x17\x00\x18\x00\x24\x00\x13\x00\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x23\x00\x24\x00\xff\xff\x26\x00\xff\xff\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\x27\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\xff\xff\x13\x00\x09\x00\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\x09\x00\xff\xff\x1d\x00\x13\x00\x1f\x00\x20\x00\x21\x00\x17\x00\x18\x00\x24\x00\x13\x00\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x23\x00\x24\x00\xff\xff\x26\x00\xff\xff\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x08\x00\xff\xff\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\xff\xff\x13\x00\x09\x00\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1d\x00\x13\x00\x1f\x00\x20\x00\x21\x00\x17\x00\x18\x00\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x23\x00\x24\x00\xff\xff\x26\x00\xff\xff\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\x57\x00\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x13\x00\x09\x00\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\xff\xff\x1d\x00\x13\x00\x1f\x00\x20\x00\x21\x00\x17\x00\x18\x00\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x23\x00\x24\x00\xff\xff\x26\x00\xff\xff\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\xff\xff\x13\x00\x09\x00\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\xff\xff\x1d\x00\x13\x00\x1f\x00\x20\x00\x21\x00\x17\x00\x18\x00\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x23\x00\x24\x00\xff\xff\x26\x00\xff\xff\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\x5e\x00\xff\xff\x13\x00\x09\x00\x62\x00\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\xff\xff\x1d\x00\x13\x00\x1f\x00\x20\x00\x21\x00\x17\x00\x18\x00\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x23\x00\x24\x00\xff\xff\x26\x00\xff\xff\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\x08\x00\xff\xff\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\xff\xff\x13\x00\x09\x00\xff\xff\xff\xff\xff\xff\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\x1d\x00\x13\x00\x1f\x00\x20\x00\x21\x00\x17\x00\x18\x00\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x23\x00\x24\x00\xff\xff\x26\x00\xff\xff\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x38\x00\xff\xff\xff\xff\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\x57\x00\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\x09\x00\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\x13\x00\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\x21\x00\x22\x00\x23\x00\x24\x00\x2d\x00\x26\x00\x27\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\x09\x00\x67\x00\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\x13\x00\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\x09\x00\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x10\x00\xff\xff\x24\x00\x13\x00\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\x19\x00\xff\xff\x2d\x00\xff\xff\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\x56\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\x47\x00\x64\x00\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\x5c\x00\x5d\x00\x5e\x00\xff\xff\x13\x00\x09\x00\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\x10\x00\xff\xff\x1d\x00\x13\x00\x1f\x00\x20\x00\x21\x00\x17\x00\x18\x00\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x23\x00\x24\x00\xff\xff\x26\x00\xff\xff\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x08\x00\x55\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x09\x00\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\x10\x00\xff\xff\xff\xff\x13\x00\x2d\x00\xff\xff\xff\xff\x17\x00\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\x26\x00\xff\xff\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\x5e\x00\xff\xff\x13\x00\x09\x00\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\x10\x00\xff\xff\x1d\x00\x13\x00\x1f\x00\x20\x00\x21\x00\x17\x00\x18\x00\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\x23\x00\x24\x00\xff\xff\x26\x00\xff\xff\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\x57\x00\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\x09\x00\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x10\x00\xff\xff\x24\x00\x13\x00\x26\x00\xff\xff\x28\x00\xff\xff\x18\x00\x19\x00\xff\xff\x2d\x00\xff\xff\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x23\x00\x24\x00\xff\xff\x26\x00\xff\xff\x56\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\x47\x00\x64\x00\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\x5e\x00\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\x09\x00\x67\x00\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\x13\x00\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\x00\xff\xff\xff\xff\xff\xff\xff\xff\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\x57\x00\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\x09\x00\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\x13\x00\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\x22\x00\x23\x00\x24\x00\x2d\x00\x26\x00\x27\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\x09\x00\x5d\x00\x5e\x00\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\x13\x00\x67\x00\x09\x00\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x10\x00\xff\xff\x24\x00\x13\x00\x26\x00\xff\xff\x28\x00\x23\x00\x24\x00\x19\x00\x26\x00\x2d\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\x26\x00\xff\xff\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\x57\x00\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\x09\x00\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\x13\x00\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\x23\x00\x24\x00\x2d\x00\x26\x00\x27\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\x5e\x00\x08\x00\xff\xff\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\x09\x00\x67\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\x18\x00\x13\x00\xff\xff\x09\x00\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\x13\x00\x26\x00\xff\xff\x28\x00\x23\x00\x24\x00\xff\xff\x26\x00\x2d\x00\x28\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\x26\x00\xff\xff\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\x2d\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x64\x00\xff\xff\xff\xff\xff\xff\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\x5e\x00\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\x2d\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x64\x00\xff\xff\xff\xff\xff\xff\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\x2d\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x64\x00\xff\xff\xff\xff\xff\xff\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\x2d\x00\x50\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\xff\xff\xff\xff\xff\xff\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x64\x00\xff\xff\xff\xff\xff\xff\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\xff\xff\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\x52\x00\x53\x00\x08\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x08\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\x13\x00\xff\xff\xff\xff\x62\x00\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x08\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\x13\x00\xff\xff\xff\xff\x62\x00\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x08\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\x13\x00\xff\xff\xff\xff\x62\x00\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x08\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\x13\x00\xff\xff\xff\xff\x62\x00\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x54\x00\x08\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x08\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x08\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x08\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x08\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\x08\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\xff\xff\x26\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\xff\xff\x2d\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\x53\x00\xff\xff\x09\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\x10\x00\x5d\x00\x12\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\xff\xff\xff\xff\x24\x00\x5f\x00\xff\xff\xff\xff\x28\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\x5c\x00\x5d\x00\xff\xff\xff\xff\xff\xff\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\xff\xff\x54\x00\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\x09\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x64\x00\x65\x00\x24\x00\x67\x00\x13\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\x26\x00\xff\xff\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\x3a\x00\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\x09\x00\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x64\x00\x65\x00\x24\x00\x67\x00\x13\x00\xff\xff\x28\x00\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\x26\x00\xff\xff\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\x3a\x00\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x64\x00\x65\x00\x24\x00\x67\x00\xff\xff\xff\xff\x28\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x64\x00\x65\x00\x24\x00\x67\x00\xff\xff\xff\xff\x28\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x64\x00\x65\x00\x24\x00\x67\x00\xff\xff\xff\xff\x28\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x64\x00\x65\x00\x24\x00\x67\x00\xff\xff\xff\xff\x28\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x64\x00\x65\x00\x24\x00\x67\x00\xff\xff\xff\xff\x28\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x64\x00\x65\x00\x24\x00\x67\x00\xff\xff\xff\xff\x28\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x64\x00\x65\x00\x24\x00\x67\x00\xff\xff\xff\xff\x28\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\xff\xff\xff\xff\xff\xff\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\xff\xff\x5d\x00\xff\xff\x1d\x00\xff\xff\x1f\x00\x20\x00\x21\x00\x64\x00\x65\x00\x24\x00\x67\x00\xff\xff\xff\xff\x28\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\x46\x00\x47\x00\xff\xff\xff\xff\x4a\x00\x4b\x00\x4c\x00\xff\xff\xff\xff\xff\xff\x50\x00\x51\x00\xff\xff\xff\xff\xff\xff\x09\x00\x56\x00\xff\xff\x58\x00\xff\xff\x5a\x00\x5b\x00\x10\x00\x5d\x00\x12\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\x64\x00\x65\x00\xff\xff\x67\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x4b\x00\x4c\x00\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\x09\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x19\x00\xff\xff\xff\xff\x4b\x00\x4c\x00\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\x19\x00\xff\xff\x3a\x00\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\x09\x00\x3a\x00\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x39\x00\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\x26\x00\xff\xff\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\x09\x00\xff\xff\x0b\x00\xff\xff\x31\x00\x32\x00\x33\x00\x10\x00\xff\xff\x12\x00\x13\x00\x38\x00\x39\x00\xff\xff\x17\x00\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\x26\x00\xff\xff\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\x09\x00\xff\xff\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\x38\x00\x39\x00\xff\xff\x17\x00\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\x26\x00\x09\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\xff\xff\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\x26\x00\x09\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\xff\xff\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\x26\x00\x09\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\xff\xff\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\x26\x00\x09\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\xff\xff\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\x26\x00\x09\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\xff\xff\x38\x00\x39\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x23\x00\x24\x00\xff\xff\x26\x00\xff\xff\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\x09\x00\xff\xff\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\x38\x00\x39\x00\xff\xff\x17\x00\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x09\x00\xff\xff\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x09\x00\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\xff\xff\xff\xff\x17\x00\x18\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\x38\x00\x09\x00\xff\xff\x0b\x00\xff\xff\xff\xff\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\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\xff\xff\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\x09\x00\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\x10\x00\xff\xff\x12\x00\x13\x00\xff\xff\x34\x00\x35\x00\x36\x00\x37\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x20\x00\x21\x00\x22\x00\x23\x00\x24\x00\xff\xff\x26\x00\x27\x00\xff\xff\x29\x00\x2a\x00\x2b\x00\x2c\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\x34\x00\x35\x00\x36\x00\x37\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"# + +happyTable :: HappyAddr +happyTable = HappyA# "\x00\x00\x1b\x02\x15\x02\x28\x03\x7e\x03\x09\x00\xd8\x01\x16\x02\x06\x02\x4a\x00\x07\x02\x2d\x03\x0a\x00\x50\x00\x3b\x00\x0c\x00\x09\x00\x78\x02\x06\x02\x32\x03\x07\x02\x78\x01\xf4\x00\x1a\x02\x78\x02\x1a\x02\x0c\x00\xe6\x02\xf2\x00\x3c\x00\x0f\x00\x10\x00\x11\x00\xfd\x01\x12\x00\x3d\x00\x51\x00\x14\x00\x15\x00\x16\x00\x17\x00\x46\x02\x5a\x02\x11\x00\x45\x00\x12\x00\x45\x00\x8c\x01\x14\x00\x15\x00\x16\x00\x8d\x01\x45\x00\xed\x00\x46\x00\xe8\x01\x0c\x00\x45\x00\x23\x03\x7b\x02\xff\xff\xe7\x02\x46\x00\x00\x03\x79\x02\x7a\x02\x7b\x02\x46\x00\x00\x03\xd8\x01\x16\x02\x5b\x02\x5c\x02\x5d\x02\xde\x00\x5e\x02\x47\x02\x81\x03\x82\x03\x83\x03\xbd\x00\x7f\x03\x29\x03\x09\x00\x7c\x03\x33\x03\x06\x02\x3e\x00\x07\x02\xd3\x02\x39\x00\xfc\x02\x51\x00\x0c\x00\x17\x02\x52\x00\x51\x02\x53\x00\x54\x00\x55\x00\x56\x00\x08\x02\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\x14\x00\x15\x00\x16\x00\x51\x02\x1b\x02\xff\xff\x1b\x02\x64\x00\x65\x00\xd4\x02\x39\x00\x66\x00\x67\x00\x28\x03\xd7\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\x09\x00\xfe\x01\x06\x03\xfd\x02\x91\x01\x18\x02\xbf\x00\x0a\x00\x39\x00\x3b\x00\x0c\x00\x09\x00\xe9\x01\xa7\x00\xfb\x02\x09\x02\x75\x01\x01\x03\x99\x01\x1a\x02\xe1\x01\x0c\x00\x4d\x03\xcc\x02\x3c\x00\x0f\x00\x10\x00\x11\x00\xeb\x01\x12\x00\x3d\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x95\x02\x5a\x02\x11\x00\x09\x00\x12\x00\x0c\x00\x8c\x01\x14\x00\x15\x00\x16\x00\x8d\x01\x7e\x02\x39\x00\x0c\x00\xbf\x00\x09\x00\x29\x03\x33\x03\x2b\x03\xdc\x01\x96\x02\xcd\x02\x39\x00\x3a\x00\x97\x02\x0c\x00\x96\x01\xc5\x02\xda\x00\x16\x00\x5b\x02\x5c\x02\x5d\x02\x98\x02\x22\x03\x14\x00\x15\x00\x16\x00\x51\x02\x2d\x03\x39\x00\xf9\x01\x09\x00\x06\x02\x26\x02\x07\x02\x3e\x00\x14\x00\x15\x00\x16\x00\x51\x02\x51\x00\x0c\x00\xd6\x02\x52\x00\x07\x02\x53\x00\x54\x00\x55\x00\x56\x00\xfb\x01\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\x14\x00\x15\x00\x16\x00\x51\x02\xf8\x01\x1b\x02\x6a\x02\x64\x00\x65\x00\x28\x03\xf1\x00\x66\x00\x67\x00\xa7\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\x09\x00\x2d\x03\x2e\x03\x2f\x03\x91\x01\x30\x03\xbf\x00\x0a\x00\x52\x02\x3b\x00\x0c\x00\x09\x00\x63\x03\x45\x00\xf2\x02\xf3\x02\x82\x00\x83\x00\xc0\x00\x17\x03\xe8\x02\x0c\x00\x18\x03\x4c\x02\x3c\x00\x0f\x00\x10\x00\x11\x00\xe1\x01\x12\x00\x3d\x00\xe7\x01\x14\x00\x15\x00\x16\x00\x17\x00\xeb\x01\x5a\x02\x11\x00\x39\x00\x12\x00\x39\x00\x8c\x01\x14\x00\x15\x00\x16\x00\x8d\x01\xa9\x02\x29\x03\x2a\x03\x2b\x03\x09\x00\x9d\x01\x4e\x02\x5f\xff\x09\x00\x39\x00\x3a\x00\xf3\x01\x13\x02\xfb\x01\x0c\x00\x45\x00\xbf\x00\xef\x01\x0c\x00\x5b\x02\x5c\x02\x9f\x02\x9f\x01\x5f\xff\xe2\x00\x49\x02\x39\x00\x3a\x00\x0c\x02\x0f\x02\x69\x02\x7d\x03\x2f\x03\x6a\x02\x30\x03\x3e\x00\x14\x00\x15\x00\x16\x00\x51\x02\x51\x00\xdd\x01\x16\x00\x52\x00\xe1\x01\x53\x00\x54\x00\x55\x00\x56\x00\x40\x03\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\x39\x00\x3a\x00\x48\xff\x45\x00\x80\x02\x39\x00\x14\x02\x64\x00\x65\x00\xf4\x00\x48\xff\x66\x00\x67\x00\x46\x00\x47\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\x9e\x00\x4b\x02\x9f\x00\xfb\x01\x91\x01\x0b\x02\x0c\x02\xfb\x01\x09\x00\xb6\x01\x41\x03\x42\x03\x43\x03\x44\x03\xb6\x01\x0a\x00\x45\x03\x3b\x00\x0c\x00\x09\x00\x4f\x03\x39\x00\x3a\x00\xfc\x01\xbf\x00\xa5\x02\x0a\x03\x75\x02\x9e\x00\x0c\x00\x9f\x00\x0b\x03\x3c\x00\x0f\x00\x10\x00\x11\x00\xc0\x00\x12\x00\x3d\x00\xfb\x01\x14\x00\x15\x00\x16\x00\x17\x00\x49\x02\x5a\x02\x11\x00\xcc\x00\x12\x00\x12\x03\x8c\x01\x14\x00\x15\x00\x16\x00\x8d\x01\x78\x01\xe1\x01\x0e\x03\x9e\x00\x6a\x02\x9f\x00\xbe\x01\xb6\x01\x6b\xff\x6b\xff\x46\x00\x79\x01\x39\x00\xe4\x01\x26\x02\xde\x00\x25\x00\x6b\xff\xe1\x01\x5b\x02\x5c\x02\x9e\x02\x26\x02\xa3\x02\x6b\xff\x39\x00\x6b\xff\x2a\x00\xc1\x01\xdf\x00\xe0\x00\x09\x00\xe1\x00\x6b\xff\xe2\x00\x3e\x00\x7a\x01\x7b\x01\x7c\x01\x7d\x01\x51\x00\x0c\x00\x7e\x01\x52\x00\xbf\x01\x53\x00\x54\x00\x55\x00\x56\x00\x40\x03\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\x14\x00\x15\x00\x16\x00\xa2\x00\xf9\x02\xb2\x02\xfa\x02\x64\x00\x65\x00\xb3\x02\x2d\x02\x66\x00\x67\x00\x39\x00\x2e\x02\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\x09\x00\xb7\x01\x48\xff\xb6\x01\x91\x01\xb5\x01\xbf\x00\x0a\x00\xb4\x01\x3b\x00\x0c\x00\x86\x03\x43\x03\x44\x03\xb3\x01\x48\xff\x87\x03\x48\xff\x09\x00\xb0\x01\x39\x00\x3a\x00\xae\x01\x3b\x00\x3c\x00\x0f\x00\x10\x00\x11\x00\x0c\x00\x12\x00\x3d\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x09\x00\xdb\x02\xa8\x00\xad\x01\xdc\x02\x0c\x00\xfa\x02\xac\x01\x5a\x02\x11\x00\x0c\x00\x12\x00\xab\x01\x8c\x01\x14\x00\x15\x00\x16\x00\x8d\x01\xde\x00\x3c\x00\x0f\x00\x10\x00\x11\x00\xa8\x01\x12\x00\x3d\x00\xa4\x01\x14\x00\x15\x00\x16\x00\x17\x00\x9d\x01\x14\x00\x15\x00\x16\x00\xa1\x00\x23\x02\x5b\x02\x5c\x02\x20\x03\xbf\x00\x24\x02\xdb\x02\x25\x02\x80\x01\xdc\x02\x3e\x00\xdd\x02\x78\x01\xde\x02\x26\x02\x51\x00\x0c\x02\x0e\x02\x52\x00\x88\x02\x53\x00\x54\x00\x55\x00\x56\x00\x73\x01\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\xf6\x02\xbf\x00\xf7\x02\xa9\x00\xa5\x00\xa6\x00\x5e\x01\x64\x00\x65\x00\x39\x00\x83\x02\x66\x00\x67\x00\x0c\x02\x0d\x02\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\x09\x00\xbf\x00\x80\x02\xca\x00\xcb\x00\xbf\x00\x7e\x02\x0a\x00\xcc\x00\x3b\x00\x0c\x00\x91\x01\x45\x00\xc0\x00\xe4\x00\x7d\x02\x75\x01\x0c\x02\xd5\x02\xe5\x00\x39\x00\xe6\x00\x46\x00\xa8\x01\x3c\x00\x0f\x00\x10\x00\x11\x00\x39\x00\x12\x00\x3d\x00\xcc\x00\x14\x00\x15\x00\x16\x00\x17\x00\x09\x00\x69\x01\x78\x01\xe8\x00\xe9\x00\x78\x02\x9b\x01\x0a\x00\x9c\x01\x6f\x01\x0c\x00\x9d\x01\x46\x00\x79\x01\xea\x00\x39\x00\xb6\x00\x69\x01\xa5\x01\xeb\x00\xdb\x02\xec\x00\x6a\x01\xdc\x02\x6b\x01\x5e\x03\x70\x01\x11\x00\x9f\x01\x12\x00\xe2\x00\x66\x01\x14\x00\x15\x00\x16\x00\x62\x01\x67\x01\x45\x00\x68\x01\x98\x02\x7c\x01\x7d\x01\x39\x00\x3a\x00\x7e\x01\x09\x00\x3e\x00\x46\x00\x02\x02\xb8\x00\xb9\x00\x51\x00\xa8\x00\x73\x02\x52\x00\x0c\x00\x53\x00\x54\x00\x55\x00\x56\x00\x71\x02\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\x70\x02\xf2\x00\x6e\x02\x14\x00\x15\x00\x16\x00\xd8\x00\x64\x00\x65\x00\x6d\x02\xdb\x02\x66\x00\x67\x00\xef\x02\xf3\x02\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\x09\x00\xf0\xfe\xdb\x02\x64\x00\xba\x00\xef\x02\xf0\x02\x0a\x00\xc3\x01\x6b\x01\xab\x00\xef\xfe\xca\x00\xcb\x00\xac\x00\x6c\x01\x01\x02\xcc\x00\xdb\x02\xf2\xfe\xf1\xfe\xef\x02\x5a\x03\xa1\x01\xe0\x02\xe1\x02\x8b\x01\x11\x00\xa2\x01\x12\x00\xa3\x01\x8c\x01\x14\x00\x15\x00\x16\x00\x8d\x01\x09\x00\x39\x00\xc8\x02\x20\x02\xe2\x02\x21\x02\xe3\x02\x0a\x00\xf5\xfe\xb5\x00\x0c\x00\xaf\x00\xb0\x00\x39\x00\x0b\x02\x0c\x02\xb6\x00\x39\x00\x3a\x00\x8e\x01\x8f\x01\xa8\x01\x90\x01\x9f\x00\x0e\x00\x0f\x00\xb7\x00\x11\x00\xf4\xfe\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\xbf\x00\x4f\x02\x0a\x00\xbf\x00\x63\x01\x0c\x00\x49\x02\x18\x00\x19\x00\x1a\x00\x1b\x00\xb6\x00\xc0\x00\xb8\x00\xb9\x00\xc0\x00\x1e\x02\x1f\x02\x20\x02\xca\x02\x21\x02\x64\x01\x11\x00\x45\x02\x12\x00\x09\x00\x23\x02\x14\x00\x15\x00\x16\x00\x62\x01\x24\x02\x0a\x00\x25\x02\x6f\x01\x0c\x00\x0b\x02\x0c\x02\x4d\x00\x08\x00\x26\x02\xb6\x00\x40\x02\xbf\x00\xb8\x00\xb9\x00\x9d\x01\xe6\x00\x1b\x00\xde\x00\x44\x02\x70\x01\x11\x00\x9e\x01\x12\x00\xc0\x00\xcc\x00\x14\x00\x15\x00\x16\x00\x62\x01\x3b\x02\x66\x01\x9f\x01\x74\x01\xe2\x00\xe1\x00\x98\x01\xe2\x00\x99\x01\x09\x00\x91\x01\xde\x01\xfc\x01\xb8\x00\xb9\x00\x39\x00\xde\x01\xf5\x01\x2d\x02\x0c\x00\x64\x00\xba\x00\xa8\x02\x8f\x02\x90\x02\x91\x02\x92\x02\x93\x02\xc1\x00\x42\x02\x09\x00\xe1\x01\xe2\x01\xc2\x00\xc3\x00\xc4\x00\xc5\x00\x0a\x00\x41\x02\x3b\x00\x0c\x00\x14\x00\x15\x00\x16\x00\xa2\x00\xc6\x00\x3a\x02\xc7\x00\xde\x01\xec\x01\x2d\x02\x64\x00\xba\x00\x34\x02\x3c\x00\x0f\x00\x10\x00\x11\x00\x39\x02\x12\x00\x3d\x00\x38\x02\x14\x00\x15\x00\x16\x00\x17\x00\x37\x02\xbf\x00\x36\x02\x1a\x02\x85\x00\xde\x01\xeb\x01\x89\x03\x86\x00\x31\x02\x87\x00\x1f\x00\x88\x00\xc0\x00\x4e\xfe\x64\x00\xba\x00\x89\x00\x8a\x00\x8b\x00\x8c\x00\x34\x02\x20\x00\x8d\x00\x8e\x00\x8f\x00\x2d\x02\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x21\x00\x30\x02\x22\x00\x23\x00\x95\x00\xd8\x01\xda\x01\x26\x00\x96\x00\x27\x00\x2d\x02\x28\x00\x97\x00\x98\x00\x3e\x00\xde\x00\x29\x00\x2b\x02\xdb\x02\xe0\x02\xe1\x02\xdc\x02\x3f\x00\x5d\x03\xdb\x02\xde\x01\xe7\x01\xdc\x02\x33\x00\x8d\x03\x71\x01\x39\x00\xe1\x00\xdb\x02\xe2\x00\xe2\x02\xdc\x02\xe3\x02\x8c\x03\xde\x01\xe4\x01\x2b\x00\x2c\x00\x29\x02\x39\x00\x2d\x00\x41\x00\x42\x00\x28\x02\xde\x01\xdf\x01\x30\x00\x31\x00\xdb\x02\x32\x00\x33\x00\xdc\x02\x43\x00\x8b\x03\x35\x00\xdb\x02\x36\x00\x44\x00\xdc\x02\x45\x00\x8a\x03\x39\x00\x1b\x02\xe1\x01\x99\x00\x01\x02\x39\x00\x3a\x00\xbf\x00\x3b\x00\x1a\x02\x85\x00\xd8\x01\xd9\x01\x00\x02\x86\x00\xe4\x02\x87\x00\x1f\x00\x88\x00\xc0\x00\x4e\xfe\xd8\x01\x29\x02\x89\x00\x8a\x00\x8b\x00\x8c\x00\xd9\x02\x20\x00\x8d\x00\x8e\x00\x8f\x00\xd5\x02\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x21\x00\xd0\x02\x22\x00\x23\x00\x95\x00\xde\x01\xea\x02\x26\x00\x96\x00\x27\x00\xc8\x02\x28\x00\x97\x00\x98\x00\xd1\x02\x9d\x01\x29\x00\xde\x01\xe9\x02\xd4\xfe\xd4\xfe\x30\x02\x59\x02\x36\x02\xd4\xfe\xc0\x02\xd4\xfe\xd9\x02\xda\x02\xbf\x02\xd4\xfe\xbd\x02\x9f\x01\xba\x02\xe2\x00\xd4\xfe\x9b\x02\xd4\xfe\xcd\x02\xce\x02\xbc\x02\x2b\x00\x2c\x00\x9c\x02\xd4\xfe\x2d\x00\x41\x00\x42\x00\xc5\x02\xc6\x02\xb8\x02\x30\x00\x31\x00\xb7\x02\x32\x00\x33\x00\xbf\x00\x43\x00\xb6\x02\x35\x00\xb5\x02\x36\x00\x44\x00\xa1\x02\x45\x00\xc2\x02\xc3\x02\x1b\x02\xc0\x00\x99\x00\xbf\x00\x39\x00\x3a\x00\x85\x00\x3b\x00\xa5\x02\xa6\x02\x86\x00\x2d\x02\x87\x00\x1f\x00\x88\x00\xc0\x00\xde\x01\x02\x03\xb0\x02\x89\x00\x8a\x00\x8b\x00\x8c\x00\x36\x02\x20\x00\x8d\x00\x8e\x00\x8f\x00\x2d\x02\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x21\x00\x03\x02\x22\x00\x23\x00\x95\x00\xde\x01\xff\x02\x26\x00\x96\x00\x27\x00\x80\x02\x28\x00\x97\x00\x98\x00\x9a\x02\x9d\x01\x29\x00\x1c\x02\x05\x02\x8b\x02\xe2\x00\x8d\x02\x58\x02\x8e\x02\x8f\x02\x90\x02\x91\x02\x92\x02\x93\x02\xde\x01\xed\x02\x5f\xff\x9f\x01\x27\x03\xe2\x00\xeb\x02\x8f\x02\x90\x02\x91\x02\x92\x02\x93\x02\x2b\x00\x2c\x00\xd8\x01\x57\x03\x2d\x00\x41\x00\x42\x00\xd8\x01\x56\x03\x26\x03\x30\x00\x31\x00\x25\x03\x32\x00\x33\x00\x39\x00\x43\x00\x1f\x03\x35\x00\x1e\x03\x36\x00\x44\x00\x13\x03\x45\x00\xd8\x01\x55\x03\xee\xfd\x36\x02\x99\x00\x14\x03\x39\x00\x3a\x00\x1d\x03\x3b\x00\xee\xfd\xf6\x00\xf7\x00\xf8\x00\xf9\x00\xfa\x00\xfb\x00\xfc\x00\xfd\x00\xfe\x00\xff\x00\x00\x01\x01\x01\x02\x01\x03\x01\x04\x01\x05\x01\x06\x01\x07\x01\x08\x01\x09\x01\x0a\x01\x0b\x01\x0c\x01\x0d\x01\x0e\x01\x0f\x01\x10\x01\x11\x01\x12\x01\x13\x01\x14\x01\x15\x01\x16\x01\x17\x01\x18\x01\x19\x01\x1a\x01\x1b\x01\x1c\x01\x1d\x01\x1e\x01\x1f\x01\x20\x01\x21\x01\x22\x01\x23\x01\x24\x01\x25\x01\x26\x01\x27\x01\x28\x01\x29\x01\x2a\x01\x2b\x01\x2c\x01\x2d\x01\x2e\x01\x2f\x01\x30\x01\x31\x01\x32\x01\x33\x01\x34\x01\x35\x01\x36\x01\x37\x01\x38\x01\x39\x01\x3a\x01\x3b\x01\x3c\x01\x3d\x01\x3e\x01\x3f\x01\x40\x01\x41\x01\x42\x01\x43\x01\x44\x01\x45\x01\x46\x01\x47\x01\x48\x01\x49\x01\x4a\x01\x4b\x01\x4c\x01\x4d\x01\x4e\x01\x4f\x01\x50\x01\x51\x01\x52\x01\x53\x01\x54\x01\x55\x01\x56\x01\x57\x01\x58\x01\x59\x01\x5a\x01\x5b\x01\x5c\x01\x85\x00\x1c\x03\x47\x03\x48\x03\x86\x00\x49\x03\x87\x00\x1f\x00\x88\x00\x15\x03\x4e\xfe\xc9\x00\x4a\x03\x89\x00\x8a\x00\x8b\x00\x4b\x03\x10\x03\x20\x00\x8d\x00\x8e\x00\x8f\x00\x4c\x03\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x21\x00\x0f\x03\x22\x00\x23\x00\x95\x00\xd8\x01\x54\x03\x26\x00\x96\x00\x27\x00\x0a\x03\x28\x00\x97\x00\x98\x00\xca\x00\xcb\x00\x29\x00\x52\x03\x53\x03\xcc\x00\x27\x03\x90\x02\x91\x02\x92\x02\x93\x02\xcd\x00\x3c\x03\x39\x03\x38\x03\x39\x03\xce\x00\x26\x02\xcf\x00\x4e\x03\x8f\x02\x90\x02\x91\x02\x92\x02\x93\x02\x39\x00\x39\x00\x2b\x00\x2c\x00\x34\x03\xa6\x02\x2d\x00\x41\x00\x42\x00\x6a\x03\x6b\x03\xff\x02\x30\x00\x31\x00\x04\x03\x32\x00\x33\x00\xbf\x00\x43\x00\xe1\x01\x35\x00\xe1\x01\x36\x00\x44\x00\x5c\x03\x45\x00\xde\x01\xec\x01\x5a\x03\xc0\x00\x99\x00\xbf\x00\x39\x00\x3a\x00\x85\x00\x3b\x00\x47\x03\x48\x03\x86\x00\x49\x03\x87\x00\x1f\x00\x88\x00\xc0\x00\xde\x01\x5c\x03\x4a\x03\x89\x00\x8a\x00\x8b\x00\x4b\x03\x39\x00\x20\x00\x8d\x00\x8e\x00\x8f\x00\x4c\x03\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x21\x00\x03\x02\x22\x00\x23\x00\x95\x00\x4d\x03\x26\x02\x26\x00\x96\x00\x27\x00\x3f\x03\x28\x00\x97\x00\x98\x00\x3e\x03\x03\x02\x29\x00\x11\x02\x05\x02\x38\x03\xe2\x00\x35\x03\x8f\x02\x90\x02\x91\x02\x92\x02\x93\x02\x3c\x03\x37\x03\x3b\x03\x7c\x03\x10\x02\x05\x02\x39\x00\xe2\x00\x65\x03\x8f\x02\x90\x02\x91\x02\x92\x02\x93\x02\x2b\x00\x2c\x00\x7b\x03\x77\x03\x2d\x00\x41\x00\x42\x00\x76\x03\x78\x03\x74\x03\x30\x00\x31\x00\x72\x03\x32\x00\x33\x00\xbf\x00\x43\x00\x26\x02\x35\x00\x6f\x03\x36\x00\x44\x00\x63\x03\x45\x00\x26\x02\x39\x00\x68\x03\xc0\x00\x99\x00\xbf\x00\x39\x00\x3a\x00\x88\xff\x3b\x00\x0a\x03\x61\x03\x88\xff\xe1\x01\x88\xff\x88\xff\x88\xff\xc0\x00\x88\xff\x86\x03\x85\x03\x88\xff\x88\xff\x88\xff\x88\xff\x39\x00\x88\xff\x88\xff\x88\xff\x88\xff\x32\x03\x88\xff\x88\xff\x88\xff\x88\xff\x88\xff\x88\xff\x03\x02\x88\xff\x88\xff\x88\xff\xef\x01\x39\x00\x88\xff\x88\xff\x88\xff\x48\x00\x88\xff\x88\xff\x88\xff\x08\x00\x03\x02\x88\xff\x04\x02\x05\x02\xf4\x00\xe2\x00\xdc\x00\xa7\x00\xa3\x00\xf9\x01\x4e\x00\xf6\x01\xbf\x01\xf4\x01\xf3\x01\xe5\x01\xe7\x02\x05\x02\xf0\x01\xe2\x00\xf1\x01\xef\x01\xed\x01\xbc\x01\xdc\x01\xb8\x01\x88\xff\x88\xff\xb1\x01\xb0\x01\x88\xff\x88\xff\x88\xff\xa9\x01\xa6\x01\x84\x01\x88\xff\x88\xff\x80\x01\x88\xff\x88\xff\xbf\x00\x88\xff\x81\x02\x88\xff\x76\x01\x88\xff\x88\xff\x85\x02\x88\xff\x76\x02\x73\x02\x75\x02\xc0\x00\x88\xff\xbf\x00\x88\xff\x88\xff\x85\x00\x88\xff\x71\x02\x6e\x02\x86\x00\x64\x02\x87\x00\x1f\x00\x88\x00\xc0\x00\x6a\x02\x67\x02\x61\x02\x89\x00\x8a\x00\x8b\x00\x8c\x00\x47\x02\x20\x00\x8d\x00\x8e\x00\x8f\x00\x76\x01\x90\x00\x91\x00\x92\x00\x93\x00\x94\x00\x21\x00\x03\x02\x22\x00\x23\x00\x95\x00\x42\x02\xd7\x02\x26\x00\x96\x00\x27\x00\x3e\x02\x28\x00\x97\x00\x98\x00\x3d\x02\x03\x02\x29\x00\xe4\x02\x05\x02\x3c\x02\xe2\x00\x3b\x02\x34\x02\x32\x02\x12\x02\x31\x02\xbd\x02\x2b\x02\xba\x02\xb8\x02\xb3\x02\xd1\x02\x05\x02\xb0\x02\xe2\x00\xae\x02\xad\x02\xac\x02\xa3\x02\xa1\x02\x8b\x02\x2b\x00\x2c\x00\x1f\x03\x1a\x03\x2d\x00\x41\x00\x42\x00\x19\x03\x18\x03\x15\x03\x30\x00\x31\x00\x08\x03\x32\x00\x33\x00\x1f\x00\x43\x00\x10\x03\x35\x00\x0c\x03\x36\x00\x44\x00\x09\x00\x45\x00\xf7\x02\xf4\x02\x20\x00\xf7\x02\x99\x00\xf4\x02\x39\x00\x3a\x00\x0c\x00\x3b\x00\x09\x00\x58\x03\x21\x00\x3f\x03\x22\x00\x23\x00\x24\x00\xa8\x00\x25\x00\x26\x00\xab\x00\x27\x00\x79\x03\x28\x00\xb7\x01\xad\x00\x78\x03\x74\x03\x29\x00\x2a\x00\x14\x00\x15\x00\x16\x00\xa1\x00\x72\x03\x69\x03\x61\x01\x11\x00\x70\x03\x12\x00\xf2\x00\x6f\x03\x14\x00\x15\x00\x16\x00\x17\x00\x09\x00\x6d\x03\x6c\x03\x68\x03\x66\x03\x83\x03\x61\x03\x2b\x00\x2c\x00\x5f\x03\x0c\x00\x2d\x00\x2e\x00\x2f\x00\x89\x03\x8f\x03\x09\x00\x30\x00\x31\x00\x92\x03\x32\x00\x33\x00\x91\x03\x34\x00\x90\x03\x35\x00\x0c\x00\x36\x00\x37\x00\x8e\x03\x38\x00\x1f\x00\x14\x00\x15\x00\x16\x00\x5c\x01\x96\x03\x39\x00\x3a\x00\x95\x03\x3b\x00\x94\x03\xbc\x00\x09\x00\x93\x03\x00\x00\xd7\x00\xbd\x00\x14\x00\x15\x00\x16\x00\xd8\x00\x21\x00\xab\x00\x22\x00\x23\x00\x24\x00\xac\x00\xad\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x61\x01\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x14\x00\x15\x00\x16\x00\x62\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x89\x01\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x34\x00\xa1\x00\x35\x00\x00\x00\x36\x00\x37\x00\x00\x00\x38\x00\x00\x00\x00\x00\x20\x00\x09\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x09\x00\x00\x00\x21\x00\xab\x00\x22\x00\x23\x00\x24\x00\xac\x00\xad\x00\x26\x00\x0c\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x61\x01\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x14\x00\x15\x00\x16\x00\x62\x01\x00\x00\xef\x00\x00\x00\x14\x00\x15\x00\x16\x00\xd8\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x01\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x37\x00\x9e\x00\x38\x00\x9f\x00\x00\x00\x20\x00\x09\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x09\x00\x00\x00\x21\x00\xab\x00\x22\x00\x23\x00\x24\x00\xac\x00\xad\x00\x26\x00\x0c\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x61\x01\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x14\x00\x15\x00\x16\x00\x62\x01\x00\x00\x00\x00\x00\x00\x14\x00\x15\x00\x16\x00\x54\x02\x00\x00\x00\x00\x00\x00\x00\x00\x86\x01\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x37\x00\x9e\x00\x38\x00\x9f\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\xbc\x00\x09\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x21\x00\xab\x00\x22\x00\x23\x00\x24\x00\xac\x00\xad\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x61\x01\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x14\x00\x15\x00\x16\x00\x62\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x01\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x43\x00\x96\x01\x35\x00\x00\x00\x36\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x20\x00\x09\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x21\x00\xab\x00\x22\x00\x23\x00\x24\x00\x63\x02\xad\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x61\x01\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x14\x00\x15\x00\x16\x00\x62\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x89\x01\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x44\x00\x9e\x00\x45\x00\x9f\x00\x00\x00\x20\x00\x09\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x21\x00\xab\x00\x22\x00\x23\x00\x24\x00\x62\x02\xad\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x61\x01\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x14\x00\x15\x00\x16\x00\x62\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\x01\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x44\x00\x00\x00\x45\x00\x93\x01\x00\x00\x20\x00\x09\x00\x94\x01\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x21\x00\xab\x00\x22\x00\x23\x00\x24\x00\x60\x02\xad\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x61\x01\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x14\x00\x15\x00\x16\x00\x62\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x86\x01\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x31\x00\x00\x00\x32\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x37\x00\x9e\x00\x38\x00\x9f\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\xbc\x00\x09\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x00\x00\x00\x00\x00\x00\x00\x00\x21\x00\xab\x00\x22\x00\x23\x00\x24\x00\x5f\x02\xad\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x61\x01\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x14\x00\x15\x00\x16\x00\x62\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x85\x01\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x43\x00\x58\x02\x35\x00\x00\x00\x36\x00\x44\x00\x00\x00\x45\x00\x09\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x0c\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\xd9\x00\x0f\x00\x10\x00\x11\x00\x29\x00\x12\x00\x3d\x00\x00\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x44\x00\x9e\x00\x45\x00\x9f\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x09\x00\x3b\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x0c\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x00\x00\xd5\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x3d\x00\x00\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\xa8\x02\x2e\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x37\x00\x9e\x00\x38\x00\x9f\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x09\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\xa8\x00\x00\x00\x26\x00\x0c\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\xae\x01\x00\x00\x29\x00\x00\x00\xca\x00\xcb\x00\x00\x00\x00\x00\x00\x00\xcc\x00\x64\x01\x11\x00\x00\x00\x12\x00\xf2\x00\xa1\x01\x14\x00\x15\x00\x16\x00\x17\x00\xa2\x01\x00\x00\xa3\x01\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x39\x00\x00\x00\x65\x03\x2e\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x37\x00\x9e\x00\x38\x00\x9f\x00\x00\x00\x20\x00\x09\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\xa8\x00\x00\x00\x21\x00\xab\x00\x22\x00\x23\x00\x24\x00\xb7\x01\xad\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x61\x01\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x14\x00\x15\x00\x16\x00\x62\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\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x39\xff\x32\x00\x1f\x00\x39\xff\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x44\x00\x00\x00\x45\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x09\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\xa8\x00\x00\x00\x00\x00\xab\x00\x29\x00\x00\x00\x00\x00\xb7\x01\x88\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x01\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x14\x00\x15\x00\x16\x00\x62\x01\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x37\x00\x00\x00\x38\x00\x9b\x00\x00\x00\x20\x00\x09\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\xa8\x00\x00\x00\x21\x00\xab\x00\x22\x00\x23\x00\x24\x00\x86\x02\xad\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x61\x01\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x14\x00\x15\x00\x16\x00\x62\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\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x34\x00\xa1\x00\x35\x00\x00\x00\x36\x00\x37\x00\x00\x00\x38\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x09\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\xa8\x00\x00\x00\x26\x00\xab\x00\x27\x00\x00\x00\x28\x00\x00\x00\x83\x02\xae\x01\x00\x00\x29\x00\x00\x00\xca\x00\xcb\x00\x00\x00\x00\x00\x00\x00\xcc\x00\x84\x02\x11\x00\x00\x00\x12\x00\x00\x00\xe4\x00\x14\x00\x15\x00\x16\x00\x62\x01\xe5\x00\x00\x00\xe6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x39\x00\x00\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x37\x00\x00\x00\x38\x00\x9b\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x09\x00\x3b\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x0c\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb4\x00\x10\x00\x11\x00\x00\x00\x12\x00\x3d\x00\x00\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x34\x00\xa1\x00\x35\x00\x00\x00\x36\x00\x37\x00\x00\x00\x38\x00\x09\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x0c\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\xb9\x01\x10\x00\x11\x00\x29\x00\x12\x00\x3d\x00\x00\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x37\x00\x09\x00\x38\x00\x9b\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x0c\x00\x3b\x00\x09\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\xa8\x00\x00\x00\x26\x00\x0c\x00\x27\x00\x00\x00\x28\x00\xee\x00\x11\x00\xae\x01\x12\x00\x29\x00\x6b\x02\x14\x00\x15\x00\x16\x00\x8d\x01\x00\x00\x00\x00\x64\x01\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x14\x00\x15\x00\x16\x00\x62\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x34\x00\xa1\x00\x35\x00\x00\x00\x36\x00\x37\x00\x00\x00\x38\x00\x09\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x0c\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\xee\x00\x11\x00\x29\x00\x12\x00\xef\x00\x00\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x31\x00\x00\x00\x32\x00\x33\x00\x00\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x37\x00\x00\x00\x38\x00\x9b\x00\x1f\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x09\x00\x3b\x00\x00\x00\x00\x00\xbc\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbd\x00\x0c\x00\x00\x00\x09\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x0c\x00\x27\x00\x00\x00\x28\x00\x65\x02\x11\x00\x00\x00\x12\x00\x29\x00\x66\x02\x14\x00\x15\x00\x16\x00\x8d\x01\x00\x00\x00\x00\xee\x00\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x14\x00\x15\x00\x16\x00\x62\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\xca\x00\xcb\x00\x00\x00\x00\x00\x29\x00\xcc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x01\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x01\x00\x00\xa3\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x44\x00\x00\x00\x45\x00\x56\x02\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\xca\x00\xcb\x00\x00\x00\x00\x00\x29\x00\xcc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe5\x00\x00\x00\x1e\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x37\x00\x00\x00\x38\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\xca\x00\xcb\x00\x00\x00\x00\x00\x29\x00\xcc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa1\x01\x00\x00\x00\x00\x00\x00\x00\x00\xa2\x01\x00\x00\xa3\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\xca\x00\xcb\x00\x00\x00\x00\x00\x29\x00\xcc\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe4\x00\x00\x00\x00\x00\x00\x00\x00\x00\xe5\x00\x00\x00\xe6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x37\x00\x00\x00\x38\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\xc2\x01\xc3\x01\xc4\x01\xc5\x01\xc6\x01\xc7\x01\xc8\x01\xc9\x01\xca\x01\xcb\x01\xcc\x01\xcd\x01\xce\x01\xcf\x01\xd0\x01\xd1\x01\xd2\x01\xd3\x01\xd4\x01\xd5\x01\xd6\x01\xd7\x01\xd8\x01\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x37\x00\x00\x00\x38\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x37\x00\x00\x00\x38\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x37\x00\x00\x00\x38\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x37\x00\x00\x00\x38\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x37\xff\x32\x00\x1f\x00\x00\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x44\x00\x00\x00\x45\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x1f\x00\x00\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x44\x00\x00\x00\x45\x00\x00\x00\x20\x00\x00\x00\x00\x00\x94\x01\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x37\x00\x00\x00\x38\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x44\x00\x00\x00\x45\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x37\x00\x00\x00\x38\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x1f\x00\x00\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x44\x00\x00\x00\x45\x00\x00\x00\x20\x00\x00\x00\x00\x00\x94\x01\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x33\x00\x88\xff\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x37\x00\x00\x00\x38\x00\x00\x00\x00\x00\x88\xff\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x88\xff\x00\x00\x88\xff\x88\xff\x88\xff\x00\x00\x00\x00\x88\xff\x00\x00\x88\xff\x00\x00\x88\xff\x00\x00\x00\x00\x00\x00\x00\x00\x88\xff\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x88\xff\x88\xff\x00\x00\x00\x00\x88\xff\x88\xff\x88\xff\x00\x00\x00\x00\x00\x00\x88\xff\x88\xff\x00\x00\x88\xff\x88\xff\x1f\x00\x88\xff\x00\x00\x88\xff\x00\x00\x88\xff\x88\xff\x00\x00\x88\xff\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x88\xff\x88\xff\x00\x00\x88\xff\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x37\x00\x00\x00\x38\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x1f\x00\x00\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x44\x00\x00\x00\x45\x00\x00\x00\x20\x00\x00\x00\x00\x00\x94\x01\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x37\x00\x00\x00\x38\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x1f\x00\x00\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x44\x00\x00\x00\x45\x00\x00\x00\x20\x00\x00\x00\x00\x00\x94\x01\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x2e\x00\x2f\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x33\x00\x1f\x00\x34\x00\x00\x00\x35\x00\x00\x00\x36\x00\x37\x00\x00\x00\x38\x00\x00\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x1f\x00\x00\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x44\x00\x00\x00\x45\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x31\x00\x00\x00\x32\x00\x1f\x00\x00\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x44\x00\x00\x00\x45\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x1f\x00\x00\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x44\x00\x00\x00\x45\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x31\x00\x00\x00\x32\x00\x1f\x00\x00\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x44\x00\x00\x00\x45\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x32\x00\x1f\x00\x00\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x44\x00\x00\x00\x45\x00\x00\x00\x20\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x00\x00\x27\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\x00\x00\x29\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\xb2\x00\x31\x00\x00\x00\x32\x00\x00\x00\x09\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x44\x00\x0a\x00\x45\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4a\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0d\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x00\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x00\x00\x00\x00\x26\x00\x4b\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\x1c\x00\x1d\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x00\x00\x33\x00\x00\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x44\x00\x00\x00\x45\x00\x09\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x39\x00\x3a\x00\x26\x00\x3b\x00\x0c\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x64\x01\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x14\x00\x15\x00\x16\x00\x62\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x8a\x01\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x44\x00\x00\x00\xdc\x00\x09\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x39\x00\x3a\x00\x26\x00\x3b\x00\x0c\x00\x00\x00\x28\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x64\x01\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x14\x00\x15\x00\x16\x00\x62\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x87\x01\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x44\x00\x00\x00\x45\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x39\x00\x3a\x00\x26\x00\x3b\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\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\x00\x00\x00\x35\x00\x00\x00\x36\x00\xd4\x00\x00\x00\xd5\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x39\x00\x3a\x00\x26\x00\x3b\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\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd0\x00\x00\x00\x35\x00\x00\x00\x36\x00\xd1\x00\x00\x00\xd2\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x39\x00\x3a\x00\x26\x00\x3b\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\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x44\x00\x00\x00\x45\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x39\x00\x3a\x00\x26\x00\x3b\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\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x44\x00\x00\x00\xdc\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x39\x00\x3a\x00\x26\x00\x3b\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\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x44\x00\x00\x00\x45\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x39\x00\x3a\x00\x26\x00\x3b\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\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x54\x02\x00\x00\x45\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x39\x00\x3a\x00\x26\x00\x3b\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\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x00\x00\x00\x00\x00\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x44\x00\x00\x00\x45\x00\x00\x00\x21\x00\x00\x00\x22\x00\x23\x00\x24\x00\x39\x00\x3a\x00\x26\x00\x3b\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\x2b\x00\x2c\x00\x00\x00\x00\x00\x2d\x00\x41\x00\x42\x00\x00\x00\x00\x00\x00\x00\x30\x00\x31\x00\x00\x00\x00\x00\x00\x00\x09\x00\x43\x00\x00\x00\x35\x00\x00\x00\x36\x00\x51\x03\x0a\x00\x45\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x39\x00\x3a\x00\x00\x00\x3b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x81\x01\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x00\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x82\x01\x83\x01\x00\x00\x00\x00\x81\x01\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x00\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x09\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xb6\x00\x00\x00\x00\x00\x9c\x02\x83\x01\x00\x00\x00\x00\x9f\x00\x0e\x00\x0f\x00\xb7\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\xb6\x00\x00\x00\x8a\x01\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0e\x00\x0f\x00\xb7\x00\x11\x00\x00\x00\x12\x00\x13\x00\x00\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x09\x00\x87\x01\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x00\x00\xaa\x00\xab\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x0e\x00\x0f\x00\xae\x00\x11\x00\x00\x00\x12\x00\x13\x00\x00\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x09\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\xb2\x00\xb3\x00\x0a\x00\x00\x00\xaa\x00\xab\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\x00\x0e\x00\x0f\x00\xae\x00\x11\x00\x00\x00\x12\x00\x13\x00\x00\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xca\x02\x18\x00\x19\x00\x1a\x00\x1b\x00\xaf\x00\xb0\x00\x0a\x00\x00\x00\x6b\x01\xab\x00\x00\x00\x00\x00\x00\x00\xac\x00\x6c\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x01\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x14\x00\x15\x00\x16\x00\x62\x01\x09\x00\x00\x00\x94\x01\x00\x00\x79\x02\x7a\x02\x7b\x02\x0a\x00\x00\x00\x6d\x01\xab\x00\xaf\x00\xb0\x00\x00\x00\x6e\x01\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x01\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x14\x00\x15\x00\x16\x00\x62\x01\x09\x00\x00\x00\x56\x02\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x6d\x01\xab\x00\xb2\x00\xb3\x00\x00\x00\x6e\x01\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x01\x11\x00\x00\x00\x12\x00\x09\x00\x00\x00\x14\x00\x15\x00\x16\x00\x62\x01\x00\x00\x0a\x00\x00\x00\x6d\x01\xab\x00\x00\x00\x00\x00\x00\x00\x6e\x01\xad\x00\x00\x00\xb2\x00\xb3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x01\x11\x00\x00\x00\x12\x00\x09\x00\x00\x00\x14\x00\x15\x00\x16\x00\x62\x01\x00\x00\x0a\x00\x00\x00\x6b\x01\xab\x00\x00\x00\x00\x00\x00\x00\xac\x00\x6c\x01\x00\x00\xb2\x00\xb3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x01\x11\x00\x00\x00\x12\x00\x09\x00\x00\x00\x14\x00\x15\x00\x16\x00\x62\x01\x00\x00\x0a\x00\x00\x00\x60\x01\xab\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\x00\x00\x00\xaf\x00\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x01\x11\x00\x00\x00\x12\x00\x09\x00\x00\x00\x14\x00\x15\x00\x16\x00\x62\x01\x00\x00\x0a\x00\x00\x00\x60\x01\xab\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\x00\x00\x00\xb2\x00\xb3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x01\x11\x00\x00\x00\x12\x00\x09\x00\x00\x00\x14\x00\x15\x00\x16\x00\x62\x01\x00\x00\x0a\x00\x00\x00\x6b\x01\xab\x00\x00\x00\x00\x00\x00\x00\xac\x00\x6c\x01\x00\x00\xaf\x00\xb0\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x61\x01\x11\x00\x00\x00\x12\x00\x00\x00\x00\x00\x14\x00\x15\x00\x16\x00\x62\x01\x09\x00\x00\x00\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\xab\x00\xaf\x00\xb0\x00\x00\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x0e\x00\x0f\x00\xae\x00\x11\x00\x00\x00\x12\x00\x13\x00\x00\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x89\x01\x09\x00\x00\x00\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\xab\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x0e\x00\x0f\x00\xae\x00\x11\x00\x00\x00\x12\x00\x13\x00\x00\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x09\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x86\x01\x0a\x00\x00\x00\x0b\x00\xab\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\x00\x0e\x00\x0f\x00\xae\x00\x11\x00\x00\x00\x12\x00\x13\x00\x00\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x09\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x88\x01\x0a\x00\x00\x00\x0b\x00\xab\x00\x00\x00\x00\x00\x00\x00\xac\x00\xad\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\x00\x0e\x00\x0f\x00\xae\x00\x11\x00\x00\x00\x12\x00\x13\x00\x00\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x85\x01\x09\x00\x00\x00\x9b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9c\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4c\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xed\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x99\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xbb\x01\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xba\x01\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9f\x00\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xa4\x01\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x73\x01\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5f\x01\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x5e\x01\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x89\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x80\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4f\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x4b\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x26\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc1\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xc0\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xab\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xaa\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x9d\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x8d\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x21\x03\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x07\x03\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x05\x03\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x04\x03\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xee\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xec\x02\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x09\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x0a\x00\x00\x00\x0b\x00\x0c\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x51\x03\x0e\x00\x0f\x00\x10\x00\x11\x00\x00\x00\x12\x00\x13\x00\x00\x00\x14\x00\x15\x00\x16\x00\x17\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x18\x00\x19\x00\x1a\x00\x1b\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\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 (7, 530) [ + (7 , happyReduce_7), + (8 , happyReduce_8), + (9 , happyReduce_9), + (10 , happyReduce_10), + (11 , happyReduce_11), + (12 , happyReduce_12), + (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) + ] + +happy_n_terms = 105 :: Int +happy_n_nonterms = 177 :: Int + +happyReduce_7 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_7 = happySpecReduce_1 0# happyReduction_7 +happyReduction_7 happy_x_1 + = case happyOut11 happy_x_1 of { (HappyWrap11 happy_var_1) -> + happyIn10 + (reverse happy_var_1 + )} + +happyReduce_8 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_8 = happySpecReduce_2 1# happyReduction_8 +happyReduction_8 happy_x_2 + happy_x_1 + = case happyOut11 happy_x_1 of { (HappyWrap11 happy_var_1) -> + case happyOut12 happy_x_2 of { (HappyWrap12 happy_var_2) -> + happyIn11 + (happy_var_2 : happy_var_1 + )}} + +happyReduce_9 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_9 = happySpecReduce_0 1# happyReduction_9 +happyReduction_9 = happyIn11 + ([] + ) + +happyReduce_10 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_10 = happySpecReduce_1 2# happyReduction_10 +happyReduction_10 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwAbstract happy_var_1) -> + happyIn12 + (TokKeyword KwAbstract happy_var_1 + )} + +happyReduce_11 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_11 = happySpecReduce_1 2# happyReduction_11 +happyReduction_11 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwCoData happy_var_1) -> + happyIn12 + (TokKeyword KwCoData happy_var_1 + )} + +happyReduce_12 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_12 = happySpecReduce_1 2# happyReduction_12 +happyReduction_12 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwCoInductive happy_var_1) -> + happyIn12 + (TokKeyword KwCoInductive happy_var_1 + )} + +happyReduce_13 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_13 = happySpecReduce_1 2# happyReduction_13 +happyReduction_13 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwConstructor happy_var_1) -> + happyIn12 + (TokKeyword KwConstructor happy_var_1 + )} + +happyReduce_14 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_14 = happySpecReduce_1 2# happyReduction_14 +happyReduction_14 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwData happy_var_1) -> + happyIn12 + (TokKeyword KwData happy_var_1 + )} + +happyReduce_15 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_15 = happySpecReduce_1 2# happyReduction_15 +happyReduction_15 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwDo happy_var_1) -> + happyIn12 + (TokKeyword KwDo happy_var_1 + )} + +happyReduce_16 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_16 = happySpecReduce_1 2# happyReduction_16 +happyReduction_16 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwEta happy_var_1) -> + happyIn12 + (TokKeyword KwEta happy_var_1 + )} + +happyReduce_17 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_17 = happySpecReduce_1 2# happyReduction_17 +happyReduction_17 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwField happy_var_1) -> + happyIn12 + (TokKeyword KwField happy_var_1 + )} + +happyReduce_18 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_18 = happySpecReduce_1 2# happyReduction_18 +happyReduction_18 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwForall happy_var_1) -> + happyIn12 + (TokKeyword KwForall happy_var_1 + )} + +happyReduce_19 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_19 = happySpecReduce_1 2# happyReduction_19 +happyReduction_19 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwHiding happy_var_1) -> + happyIn12 + (TokKeyword KwHiding happy_var_1 + )} + +happyReduce_20 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_20 = happySpecReduce_1 2# happyReduction_20 +happyReduction_20 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwImport happy_var_1) -> + happyIn12 + (TokKeyword KwImport happy_var_1 + )} + +happyReduce_21 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_21 = happySpecReduce_1 2# happyReduction_21 +happyReduction_21 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwIn happy_var_1) -> + happyIn12 + (TokKeyword KwIn happy_var_1 + )} + +happyReduce_22 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_22 = happySpecReduce_1 2# happyReduction_22 +happyReduction_22 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwInductive happy_var_1) -> + happyIn12 + (TokKeyword KwInductive happy_var_1 + )} + +happyReduce_23 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_23 = happySpecReduce_1 2# happyReduction_23 +happyReduction_23 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwInfix happy_var_1) -> + happyIn12 + (TokKeyword KwInfix happy_var_1 + )} + +happyReduce_24 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_24 = happySpecReduce_1 2# happyReduction_24 +happyReduction_24 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwInfixL happy_var_1) -> + happyIn12 + (TokKeyword KwInfixL happy_var_1 + )} + +happyReduce_25 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_25 = happySpecReduce_1 2# happyReduction_25 +happyReduction_25 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwInfixR happy_var_1) -> + happyIn12 + (TokKeyword KwInfixR happy_var_1 + )} + +happyReduce_26 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_26 = happySpecReduce_1 2# happyReduction_26 +happyReduction_26 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwInstance happy_var_1) -> + happyIn12 + (TokKeyword KwInstance happy_var_1 + )} + +happyReduce_27 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_27 = happySpecReduce_1 2# happyReduction_27 +happyReduction_27 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwLet happy_var_1) -> + happyIn12 + (TokKeyword KwLet happy_var_1 + )} + +happyReduce_28 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_28 = happySpecReduce_1 2# happyReduction_28 +happyReduction_28 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwMacro happy_var_1) -> + happyIn12 + (TokKeyword KwMacro happy_var_1 + )} + +happyReduce_29 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_29 = happySpecReduce_1 2# happyReduction_29 +happyReduction_29 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwModule happy_var_1) -> + happyIn12 + (TokKeyword KwModule happy_var_1 + )} + +happyReduce_30 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_30 = happySpecReduce_1 2# happyReduction_30 +happyReduction_30 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwMutual happy_var_1) -> + happyIn12 + (TokKeyword KwMutual happy_var_1 + )} + +happyReduce_31 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_31 = happySpecReduce_1 2# happyReduction_31 +happyReduction_31 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwNoEta happy_var_1) -> + happyIn12 + (TokKeyword KwNoEta happy_var_1 + )} + +happyReduce_32 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_32 = happySpecReduce_1 2# happyReduction_32 +happyReduction_32 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwOpen happy_var_1) -> + happyIn12 + (TokKeyword KwOpen happy_var_1 + )} + +happyReduce_33 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_33 = happySpecReduce_1 2# happyReduction_33 +happyReduction_33 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwOverlap happy_var_1) -> + happyIn12 + (TokKeyword KwOverlap happy_var_1 + )} + +happyReduce_34 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_34 = happySpecReduce_1 2# happyReduction_34 +happyReduction_34 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwPatternSyn happy_var_1) -> + happyIn12 + (TokKeyword KwPatternSyn happy_var_1 + )} + +happyReduce_35 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_35 = happySpecReduce_1 2# happyReduction_35 +happyReduction_35 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwPostulate happy_var_1) -> + happyIn12 + (TokKeyword KwPostulate happy_var_1 + )} + +happyReduce_36 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_36 = happySpecReduce_1 2# happyReduction_36 +happyReduction_36 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwPrimitive happy_var_1) -> + happyIn12 + (TokKeyword KwPrimitive happy_var_1 + )} + +happyReduce_37 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_37 = happySpecReduce_1 2# happyReduction_37 +happyReduction_37 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwPrivate happy_var_1) -> + happyIn12 + (TokKeyword KwPrivate happy_var_1 + )} + +happyReduce_38 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_38 = happySpecReduce_1 2# happyReduction_38 +happyReduction_38 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwProp happy_var_1) -> + happyIn12 + (TokKeyword KwProp happy_var_1 + )} + +happyReduce_39 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_39 = happySpecReduce_1 2# happyReduction_39 +happyReduction_39 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwPublic happy_var_1) -> + happyIn12 + (TokKeyword KwPublic happy_var_1 + )} + +happyReduce_40 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_40 = happySpecReduce_1 2# happyReduction_40 +happyReduction_40 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwQuote happy_var_1) -> + happyIn12 + (TokKeyword KwQuote happy_var_1 + )} + +happyReduce_41 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_41 = happySpecReduce_1 2# happyReduction_41 +happyReduction_41 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwQuoteTerm happy_var_1) -> + happyIn12 + (TokKeyword KwQuoteTerm happy_var_1 + )} + +happyReduce_42 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_42 = happySpecReduce_1 2# happyReduction_42 +happyReduction_42 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwRecord happy_var_1) -> + happyIn12 + (TokKeyword KwRecord happy_var_1 + )} + +happyReduce_43 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_43 = happySpecReduce_1 2# happyReduction_43 +happyReduction_43 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwRenaming happy_var_1) -> + happyIn12 + (TokKeyword KwRenaming happy_var_1 + )} + +happyReduce_44 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_44 = happySpecReduce_1 2# happyReduction_44 +happyReduction_44 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwRewrite happy_var_1) -> + happyIn12 + (TokKeyword KwRewrite happy_var_1 + )} + +happyReduce_45 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_45 = happySpecReduce_1 2# happyReduction_45 +happyReduction_45 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwSet happy_var_1) -> + happyIn12 + (TokKeyword KwSet happy_var_1 + )} + +happyReduce_46 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_46 = happySpecReduce_1 2# happyReduction_46 +happyReduction_46 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwSyntax happy_var_1) -> + happyIn12 + (TokKeyword KwSyntax happy_var_1 + )} + +happyReduce_47 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_47 = happySpecReduce_1 2# happyReduction_47 +happyReduction_47 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwTactic happy_var_1) -> + happyIn12 + (TokKeyword KwTactic happy_var_1 + )} + +happyReduce_48 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_48 = happySpecReduce_1 2# happyReduction_48 +happyReduction_48 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwTo happy_var_1) -> + happyIn12 + (TokKeyword KwTo happy_var_1 + )} + +happyReduce_49 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_49 = happySpecReduce_1 2# happyReduction_49 +happyReduction_49 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwUnquote happy_var_1) -> + happyIn12 + (TokKeyword KwUnquote happy_var_1 + )} + +happyReduce_50 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_50 = happySpecReduce_1 2# happyReduction_50 +happyReduction_50 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwUnquoteDecl happy_var_1) -> + happyIn12 + (TokKeyword KwUnquoteDecl happy_var_1 + )} + +happyReduce_51 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_51 = happySpecReduce_1 2# happyReduction_51 +happyReduction_51 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwUnquoteDef happy_var_1) -> + happyIn12 + (TokKeyword KwUnquoteDef happy_var_1 + )} + +happyReduce_52 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_52 = happySpecReduce_1 2# happyReduction_52 +happyReduction_52 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwUsing happy_var_1) -> + happyIn12 + (TokKeyword KwUsing happy_var_1 + )} + +happyReduce_53 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_53 = happySpecReduce_1 2# happyReduction_53 +happyReduction_53 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwVariable happy_var_1) -> + happyIn12 + (TokKeyword KwVariable happy_var_1 + )} + +happyReduce_54 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_54 = happySpecReduce_1 2# happyReduction_54 +happyReduction_54 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwWhere happy_var_1) -> + happyIn12 + (TokKeyword KwWhere happy_var_1 + )} + +happyReduce_55 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_55 = happySpecReduce_1 2# happyReduction_55 +happyReduction_55 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwWith happy_var_1) -> + happyIn12 + (TokKeyword KwWith happy_var_1 + )} + +happyReduce_56 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_56 = happySpecReduce_1 2# happyReduction_56 +happyReduction_56 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwBUILTIN happy_var_1) -> + happyIn12 + (TokKeyword KwBUILTIN happy_var_1 + )} + +happyReduce_57 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_57 = happySpecReduce_1 2# happyReduction_57 +happyReduction_57 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwCATCHALL happy_var_1) -> + happyIn12 + (TokKeyword KwCATCHALL happy_var_1 + )} + +happyReduce_58 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_58 = happySpecReduce_1 2# happyReduction_58 +happyReduction_58 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwCOMPILE happy_var_1) -> + happyIn12 + (TokKeyword KwCOMPILE happy_var_1 + )} + +happyReduce_59 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_59 = happySpecReduce_1 2# happyReduction_59 +happyReduction_59 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwDISPLAY happy_var_1) -> + happyIn12 + (TokKeyword KwDISPLAY happy_var_1 + )} + +happyReduce_60 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_60 = happySpecReduce_1 2# happyReduction_60 +happyReduction_60 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwETA happy_var_1) -> + happyIn12 + (TokKeyword KwETA happy_var_1 + )} + +happyReduce_61 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_61 = happySpecReduce_1 2# happyReduction_61 +happyReduction_61 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwFOREIGN happy_var_1) -> + happyIn12 + (TokKeyword KwFOREIGN happy_var_1 + )} + +happyReduce_62 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_62 = happySpecReduce_1 2# happyReduction_62 +happyReduction_62 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwIMPOSSIBLE happy_var_1) -> + happyIn12 + (TokKeyword KwIMPOSSIBLE happy_var_1 + )} + +happyReduce_63 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_63 = happySpecReduce_1 2# happyReduction_63 +happyReduction_63 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwINJECTIVE happy_var_1) -> + happyIn12 + (TokKeyword KwINJECTIVE happy_var_1 + )} + +happyReduce_64 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_64 = happySpecReduce_1 2# happyReduction_64 +happyReduction_64 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwINLINE happy_var_1) -> + happyIn12 + (TokKeyword KwINLINE happy_var_1 + )} + +happyReduce_65 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_65 = happySpecReduce_1 2# happyReduction_65 +happyReduction_65 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwMEASURE happy_var_1) -> + happyIn12 + (TokKeyword KwMEASURE happy_var_1 + )} + +happyReduce_66 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_66 = happySpecReduce_1 2# happyReduction_66 +happyReduction_66 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwNOINLINE happy_var_1) -> + happyIn12 + (TokKeyword KwNOINLINE happy_var_1 + )} + +happyReduce_67 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_67 = happySpecReduce_1 2# happyReduction_67 +happyReduction_67 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwNO_POSITIVITY_CHECK happy_var_1) -> + happyIn12 + (TokKeyword KwNO_POSITIVITY_CHECK happy_var_1 + )} + +happyReduce_68 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_68 = happySpecReduce_1 2# happyReduction_68 +happyReduction_68 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwNO_TERMINATION_CHECK happy_var_1) -> + happyIn12 + (TokKeyword KwNO_TERMINATION_CHECK happy_var_1 + )} + +happyReduce_69 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_69 = happySpecReduce_1 2# happyReduction_69 +happyReduction_69 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwNO_UNIVERSE_CHECK happy_var_1) -> + happyIn12 + (TokKeyword KwNO_UNIVERSE_CHECK happy_var_1 + )} + +happyReduce_70 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_70 = happySpecReduce_1 2# happyReduction_70 +happyReduction_70 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwNON_TERMINATING happy_var_1) -> + happyIn12 + (TokKeyword KwNON_TERMINATING happy_var_1 + )} + +happyReduce_71 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_71 = happySpecReduce_1 2# happyReduction_71 +happyReduction_71 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwNON_COVERING happy_var_1) -> + happyIn12 + (TokKeyword KwNON_COVERING happy_var_1 + )} + +happyReduce_72 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_72 = happySpecReduce_1 2# happyReduction_72 +happyReduction_72 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwOPTIONS happy_var_1) -> + happyIn12 + (TokKeyword KwOPTIONS happy_var_1 + )} + +happyReduce_73 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_73 = happySpecReduce_1 2# happyReduction_73 +happyReduction_73 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwPOLARITY happy_var_1) -> + happyIn12 + (TokKeyword KwPOLARITY happy_var_1 + )} + +happyReduce_74 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_74 = happySpecReduce_1 2# happyReduction_74 +happyReduction_74 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwREWRITE happy_var_1) -> + happyIn12 + (TokKeyword KwREWRITE happy_var_1 + )} + +happyReduce_75 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_75 = happySpecReduce_1 2# happyReduction_75 +happyReduction_75 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwSTATIC happy_var_1) -> + happyIn12 + (TokKeyword KwSTATIC happy_var_1 + )} + +happyReduce_76 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_76 = happySpecReduce_1 2# happyReduction_76 +happyReduction_76 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwTERMINATING happy_var_1) -> + happyIn12 + (TokKeyword KwTERMINATING happy_var_1 + )} + +happyReduce_77 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_77 = happySpecReduce_1 2# happyReduction_77 +happyReduction_77 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwWARNING_ON_IMPORT happy_var_1) -> + happyIn12 + (TokKeyword KwWARNING_ON_IMPORT happy_var_1 + )} + +happyReduce_78 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_78 = happySpecReduce_1 2# happyReduction_78 +happyReduction_78 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwWARNING_ON_USAGE happy_var_1) -> + happyIn12 + (TokKeyword KwWARNING_ON_USAGE happy_var_1 + )} + +happyReduce_79 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_79 = happySpecReduce_1 2# happyReduction_79 +happyReduction_79 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSetN happy_var_1) -> + happyIn12 + (TokSetN happy_var_1 + )} + +happyReduce_80 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_80 = happySpecReduce_1 2# happyReduction_80 +happyReduction_80 happy_x_1 + = case happyOutTok happy_x_1 of { (TokPropN happy_var_1) -> + happyIn12 + (TokPropN happy_var_1 + )} + +happyReduce_81 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_81 = happySpecReduce_1 2# happyReduction_81 +happyReduction_81 happy_x_1 + = case happyOutTok happy_x_1 of { (TokTeX happy_var_1) -> + happyIn12 + (TokTeX happy_var_1 + )} + +happyReduce_82 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_82 = happySpecReduce_1 2# happyReduction_82 +happyReduction_82 happy_x_1 + = case happyOutTok happy_x_1 of { (TokComment happy_var_1) -> + happyIn12 + (TokComment happy_var_1 + )} + +happyReduce_83 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_83 = happySpecReduce_1 2# happyReduction_83 +happyReduction_83 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymEllipsis happy_var_1) -> + happyIn12 + (TokSymbol SymEllipsis happy_var_1 + )} + +happyReduce_84 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_84 = happySpecReduce_1 2# happyReduction_84 +happyReduction_84 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymDotDot happy_var_1) -> + happyIn12 + (TokSymbol SymDotDot happy_var_1 + )} + +happyReduce_85 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_85 = happySpecReduce_1 2# happyReduction_85 +happyReduction_85 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymDot happy_var_1) -> + happyIn12 + (TokSymbol SymDot happy_var_1 + )} + +happyReduce_86 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_86 = happySpecReduce_1 2# happyReduction_86 +happyReduction_86 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymSemi happy_var_1) -> + happyIn12 + (TokSymbol SymSemi happy_var_1 + )} + +happyReduce_87 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_87 = happySpecReduce_1 2# happyReduction_87 +happyReduction_87 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymColon happy_var_1) -> + happyIn12 + (TokSymbol SymColon happy_var_1 + )} + +happyReduce_88 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_88 = happySpecReduce_1 2# happyReduction_88 +happyReduction_88 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymEqual happy_var_1) -> + happyIn12 + (TokSymbol SymEqual happy_var_1 + )} + +happyReduce_89 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_89 = happySpecReduce_1 2# happyReduction_89 +happyReduction_89 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymUnderscore happy_var_1) -> + happyIn12 + (TokSymbol SymUnderscore happy_var_1 + )} + +happyReduce_90 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_90 = happySpecReduce_1 2# happyReduction_90 +happyReduction_90 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymQuestionMark happy_var_1) -> + happyIn12 + (TokSymbol SymQuestionMark happy_var_1 + )} + +happyReduce_91 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_91 = happySpecReduce_1 2# happyReduction_91 +happyReduction_91 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymArrow happy_var_1) -> + happyIn12 + (TokSymbol SymArrow happy_var_1 + )} + +happyReduce_92 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_92 = happySpecReduce_1 2# happyReduction_92 +happyReduction_92 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymLambda happy_var_1) -> + happyIn12 + (TokSymbol SymLambda happy_var_1 + )} + +happyReduce_93 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_93 = happySpecReduce_1 2# happyReduction_93 +happyReduction_93 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymAs happy_var_1) -> + happyIn12 + (TokSymbol SymAs happy_var_1 + )} + +happyReduce_94 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_94 = happySpecReduce_1 2# happyReduction_94 +happyReduction_94 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymBar happy_var_1) -> + happyIn12 + (TokSymbol SymBar happy_var_1 + )} + +happyReduce_95 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_95 = happySpecReduce_1 2# happyReduction_95 +happyReduction_95 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymOpenParen happy_var_1) -> + happyIn12 + (TokSymbol SymOpenParen happy_var_1 + )} + +happyReduce_96 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_96 = happySpecReduce_1 2# happyReduction_96 +happyReduction_96 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymCloseParen happy_var_1) -> + happyIn12 + (TokSymbol SymCloseParen happy_var_1 + )} + +happyReduce_97 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_97 = happySpecReduce_1 2# happyReduction_97 +happyReduction_97 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymOpenIdiomBracket happy_var_1) -> + happyIn12 + (TokSymbol SymOpenIdiomBracket happy_var_1 + )} + +happyReduce_98 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_98 = happySpecReduce_1 2# happyReduction_98 +happyReduction_98 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymCloseIdiomBracket happy_var_1) -> + happyIn12 + (TokSymbol SymCloseIdiomBracket happy_var_1 + )} + +happyReduce_99 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_99 = happySpecReduce_1 2# happyReduction_99 +happyReduction_99 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymEmptyIdiomBracket happy_var_1) -> + happyIn12 + (TokSymbol SymEmptyIdiomBracket happy_var_1 + )} + +happyReduce_100 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_100 = happySpecReduce_1 2# happyReduction_100 +happyReduction_100 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymDoubleOpenBrace happy_var_1) -> + happyIn12 + (TokSymbol SymDoubleOpenBrace happy_var_1 + )} + +happyReduce_101 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_101 = happySpecReduce_1 2# happyReduction_101 +happyReduction_101 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymDoubleCloseBrace happy_var_1) -> + happyIn12 + (TokSymbol SymDoubleCloseBrace happy_var_1 + )} + +happyReduce_102 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_102 = happySpecReduce_1 2# happyReduction_102 +happyReduction_102 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymOpenBrace happy_var_1) -> + happyIn12 + (TokSymbol SymOpenBrace happy_var_1 + )} + +happyReduce_103 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_103 = happySpecReduce_1 2# happyReduction_103 +happyReduction_103 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymCloseBrace happy_var_1) -> + happyIn12 + (TokSymbol SymCloseBrace happy_var_1 + )} + +happyReduce_104 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_104 = happySpecReduce_1 2# happyReduction_104 +happyReduction_104 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymOpenVirtualBrace happy_var_1) -> + happyIn12 + (TokSymbol SymOpenVirtualBrace happy_var_1 + )} + +happyReduce_105 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_105 = happySpecReduce_1 2# happyReduction_105 +happyReduction_105 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymCloseVirtualBrace happy_var_1) -> + happyIn12 + (TokSymbol SymCloseVirtualBrace happy_var_1 + )} + +happyReduce_106 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_106 = happySpecReduce_1 2# happyReduction_106 +happyReduction_106 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymVirtualSemi happy_var_1) -> + happyIn12 + (TokSymbol SymVirtualSemi happy_var_1 + )} + +happyReduce_107 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_107 = happySpecReduce_1 2# happyReduction_107 +happyReduction_107 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> + happyIn12 + (TokSymbol SymOpenPragma happy_var_1 + )} + +happyReduce_108 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_108 = happySpecReduce_1 2# happyReduction_108 +happyReduction_108 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymClosePragma happy_var_1) -> + happyIn12 + (TokSymbol SymClosePragma happy_var_1 + )} + +happyReduce_109 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_109 = happySpecReduce_1 2# happyReduction_109 +happyReduction_109 happy_x_1 + = case happyOutTok happy_x_1 of { (TokId happy_var_1) -> + happyIn12 + (TokId happy_var_1 + )} + +happyReduce_110 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_110 = happySpecReduce_1 2# happyReduction_110 +happyReduction_110 happy_x_1 + = case happyOutTok happy_x_1 of { (TokQId happy_var_1) -> + happyIn12 + (TokQId happy_var_1 + )} + +happyReduce_111 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_111 = happySpecReduce_1 2# happyReduction_111 +happyReduction_111 happy_x_1 + = case happyOutTok happy_x_1 of { (TokString happy_var_1) -> + happyIn12 + (TokString happy_var_1 + )} + +happyReduce_112 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_112 = happySpecReduce_1 2# happyReduction_112 +happyReduction_112 happy_x_1 + = case happyOutTok happy_x_1 of { (TokLiteral happy_var_1) -> + happyIn12 + (TokLiteral happy_var_1 + )} + +happyReduce_113 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_113 = happySpecReduce_3 3# happyReduction_113 +happyReduction_113 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut143 happy_x_2 of { (HappyWrap143 happy_var_2) -> + happyIn13 + (takeOptionsPragmas happy_var_2 + )} + +happyReduce_114 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_114 = happySpecReduce_0 4# happyReduction_114 +happyReduction_114 = happyIn14 + (() + ) + +happyReduce_115 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_115 = happySpecReduce_1 4# happyReduction_115 +happyReduction_115 happy_x_1 + = happyIn14 + (() + ) + +happyReduce_116 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_116 = happySpecReduce_1 5# happyReduction_116 +happyReduction_116 happy_x_1 + = happyIn15 + (() + ) + +happyReduce_117 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_117 = happyMonadReduce 1# 5# happyReduction_117 +happyReduction_117 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((( popContext)) + ) (\r -> happyReturn (happyIn15 r)) + +happyReduce_118 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_118 = happySpecReduce_1 6# happyReduction_118 +happyReduction_118 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymSemi happy_var_1) -> + happyIn16 + (happy_var_1 + )} + +happyReduce_119 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_119 = happySpecReduce_1 6# happyReduction_119 +happyReduction_119 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymVirtualSemi happy_var_1) -> + happyIn16 + (happy_var_1 + )} + +happyReduce_120 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_120 = happyMonadReduce 0# 7# happyReduction_120 +happyReduction_120 (happyRest) tk + = happyThen ((( pushLexState imp_dir)) + ) (\r -> happyReturn (happyIn17 r)) + +happyReduce_121 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_121 = happyMonadReduce 1# 8# happyReduction_121 +happyReduction_121 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOutTok happy_x_1 of { (TokLiteral happy_var_1) -> + ( case happy_var_1 of + { LitNat r i -> return $ Ranged r $ fromInteger i + ; LitFloat r i -> return $ Ranged r i + ; _ -> parseError $ "Expected floating point number" + })}) + ) (\r -> happyReturn (happyIn18 r)) + +happyReduce_122 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_122 = happyMonadReduce 1# 9# happyReduction_122 +happyReduction_122 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOutTok happy_x_1 of { (TokId happy_var_1) -> + ( mkName happy_var_1)}) + ) (\r -> happyReturn (happyIn19 r)) + +happyReduce_123 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_123 = happySpecReduce_2 10# happyReduction_123 +happyReduction_123 happy_x_2 + happy_x_1 + = case happyOut19 happy_x_1 of { (HappyWrap19 happy_var_1) -> + case happyOut20 happy_x_2 of { (HappyWrap20 happy_var_2) -> + happyIn20 + (happy_var_1 : happy_var_2 + )}} + +happyReduce_124 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_124 = happySpecReduce_1 10# happyReduction_124 +happyReduction_124 happy_x_1 + = case happyOut19 happy_x_1 of { (HappyWrap19 happy_var_1) -> + happyIn20 + ([happy_var_1] + )} + +happyReduce_125 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_125 = happySpecReduce_1 11# happyReduction_125 +happyReduction_125 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymDoubleCloseBrace happy_var_1) -> + happyIn21 + (getRange happy_var_1 + )} + +happyReduce_126 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_126 = happyMonadReduce 2# 11# happyReduction_126 +happyReduction_126 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOutTok happy_x_1 of { (TokSymbol SymCloseBrace happy_var_1) -> + case happyOutTok happy_x_2 of { (TokSymbol SymCloseBrace happy_var_2) -> + ( + if posPos (fromJust (rEnd' (getRange happy_var_2))) - + posPos (fromJust (rStart' (getRange happy_var_1))) > 2 + then parseErrorRange happy_var_2 "Expecting '}}', found separated '}'s." + else return $ getRange (happy_var_1, happy_var_2))}}) + ) (\r -> happyReturn (happyIn21 r)) + +happyReduce_127 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_127 = happySpecReduce_2 12# happyReduction_127 +happyReduction_127 happy_x_2 + happy_x_1 + = case happyOut19 happy_x_2 of { (HappyWrap19 happy_var_2) -> + happyIn22 + (setRelevance NonStrict $ defaultArg happy_var_2 + )} + +happyReduce_128 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_128 = happySpecReduce_2 12# happyReduction_128 +happyReduction_128 happy_x_2 + happy_x_1 + = case happyOut19 happy_x_2 of { (HappyWrap19 happy_var_2) -> + happyIn22 + (setRelevance Irrelevant $ defaultArg happy_var_2 + )} + +happyReduce_129 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_129 = happySpecReduce_1 12# happyReduction_129 +happyReduction_129 happy_x_1 + = case happyOut19 happy_x_1 of { (HappyWrap19 happy_var_1) -> + happyIn22 + (defaultArg happy_var_1 + )} + +happyReduce_130 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_130 = happySpecReduce_2 13# happyReduction_130 +happyReduction_130 happy_x_2 + happy_x_1 + = case happyOut22 happy_x_1 of { (HappyWrap22 happy_var_1) -> + case happyOut23 happy_x_2 of { (HappyWrap23 happy_var_2) -> + happyIn23 + (happy_var_1 : happy_var_2 + )}} + +happyReduce_131 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_131 = happySpecReduce_1 13# happyReduction_131 +happyReduction_131 happy_x_1 + = case happyOut22 happy_x_1 of { (HappyWrap22 happy_var_1) -> + happyIn23 + ([happy_var_1] + )} + +happyReduce_132 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_132 = happySpecReduce_2 14# happyReduction_132 +happyReduction_132 happy_x_2 + happy_x_1 + = case happyOut22 happy_x_1 of { (HappyWrap22 happy_var_1) -> + case happyOut24 happy_x_2 of { (HappyWrap24 happy_var_2) -> + happyIn24 + (happy_var_1 : happy_var_2 + )}} + +happyReduce_133 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_133 = happySpecReduce_1 14# happyReduction_133 +happyReduction_133 happy_x_1 + = case happyOut22 happy_x_1 of { (HappyWrap22 happy_var_1) -> + happyIn24 + ([happy_var_1] + )} + +happyReduce_134 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_134 = happyReduce 4# 14# happyReduction_134 +happyReduction_134 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut23 happy_x_2 of { (HappyWrap23 happy_var_2) -> + case happyOut24 happy_x_4 of { (HappyWrap24 happy_var_4) -> + happyIn24 + (map makeInstance happy_var_2 ++ happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_135 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_135 = happySpecReduce_3 14# happyReduction_135 +happyReduction_135 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut23 happy_x_2 of { (HappyWrap23 happy_var_2) -> + happyIn24 + (map makeInstance happy_var_2 + )} + +happyReduce_136 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_136 = happyReduce 4# 14# happyReduction_136 +happyReduction_136 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut23 happy_x_2 of { (HappyWrap23 happy_var_2) -> + case happyOut24 happy_x_4 of { (HappyWrap24 happy_var_4) -> + happyIn24 + (map hide happy_var_2 ++ happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_137 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_137 = happySpecReduce_3 14# happyReduction_137 +happyReduction_137 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut23 happy_x_2 of { (HappyWrap23 happy_var_2) -> + happyIn24 + (map hide happy_var_2 + )} + +happyReduce_138 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_138 = happyReduce 5# 14# happyReduction_138 +happyReduction_138 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut20 happy_x_3 of { (HappyWrap20 happy_var_3) -> + case happyOut24 happy_x_5 of { (HappyWrap24 happy_var_5) -> + happyIn24 + (map (hide . setRelevance Irrelevant . defaultArg) happy_var_3 ++ happy_var_5 + ) `HappyStk` happyRest}} + +happyReduce_139 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_139 = happyReduce 4# 14# happyReduction_139 +happyReduction_139 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut20 happy_x_3 of { (HappyWrap20 happy_var_3) -> + happyIn24 + (map (hide . setRelevance Irrelevant . defaultArg) happy_var_3 + ) `HappyStk` happyRest} + +happyReduce_140 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_140 = happyReduce 5# 14# happyReduction_140 +happyReduction_140 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut20 happy_x_3 of { (HappyWrap20 happy_var_3) -> + case happyOut24 happy_x_5 of { (HappyWrap24 happy_var_5) -> + happyIn24 + (map (makeInstance . setRelevance Irrelevant . defaultArg) happy_var_3 ++ happy_var_5 + ) `HappyStk` happyRest}} + +happyReduce_141 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_141 = happyReduce 4# 14# happyReduction_141 +happyReduction_141 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut20 happy_x_3 of { (HappyWrap20 happy_var_3) -> + happyIn24 + (map (makeInstance . setRelevance Irrelevant . defaultArg) happy_var_3 + ) `HappyStk` happyRest} + +happyReduce_142 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_142 = happyReduce 5# 14# happyReduction_142 +happyReduction_142 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut20 happy_x_3 of { (HappyWrap20 happy_var_3) -> + case happyOut24 happy_x_5 of { (HappyWrap24 happy_var_5) -> + happyIn24 + (map (hide . setRelevance NonStrict . defaultArg) happy_var_3 ++ happy_var_5 + ) `HappyStk` happyRest}} + +happyReduce_143 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_143 = happyReduce 4# 14# happyReduction_143 +happyReduction_143 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut20 happy_x_3 of { (HappyWrap20 happy_var_3) -> + happyIn24 + (map (hide . setRelevance NonStrict . defaultArg) happy_var_3 + ) `HappyStk` happyRest} + +happyReduce_144 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_144 = happyReduce 5# 14# happyReduction_144 +happyReduction_144 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut20 happy_x_3 of { (HappyWrap20 happy_var_3) -> + case happyOut24 happy_x_5 of { (HappyWrap24 happy_var_5) -> + happyIn24 + (map (makeInstance . setRelevance NonStrict . defaultArg) happy_var_3 ++ happy_var_5 + ) `HappyStk` happyRest}} + +happyReduce_145 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_145 = happyReduce 4# 14# happyReduction_145 +happyReduction_145 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut20 happy_x_3 of { (HappyWrap20 happy_var_3) -> + happyIn24 + (map (makeInstance . setRelevance NonStrict . defaultArg) happy_var_3 + ) `HappyStk` happyRest} + +happyReduce_146 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_146 = happyMonadReduce 2# 15# happyReduction_146 +happyReduction_146 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut27 happy_x_1 of { (HappyWrap27 happy_var_1) -> + case happyOut24 happy_x_2 of { (HappyWrap24 happy_var_2) -> + ( (happy_var_1,) `fmap` mapM (applyAttrs happy_var_1) happy_var_2)}}) + ) (\r -> happyReturn (happyIn25 r)) + +happyReduce_147 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_147 = happyMonadReduce 2# 16# happyReduction_147 +happyReduction_147 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOutTok happy_x_1 of { (TokSymbol SymAs happy_var_1) -> + case happyOut53 happy_x_2 of { (HappyWrap53 happy_var_2) -> + ( setRange (getRange (happy_var_1,happy_var_2)) `fmap` toAttribute happy_var_2)}}) + ) (\r -> happyReturn (happyIn26 r)) + +happyReduce_148 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_148 = happySpecReduce_0 17# happyReduction_148 +happyReduction_148 = happyIn27 + ([] + ) + +happyReduce_149 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_149 = happySpecReduce_2 17# happyReduction_149 +happyReduction_149 happy_x_2 + happy_x_1 + = case happyOut27 happy_x_1 of { (HappyWrap27 happy_var_1) -> + case happyOut26 happy_x_2 of { (HappyWrap26 happy_var_2) -> + happyIn27 + (happy_var_2 : happy_var_1 + )}} + +happyReduce_150 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_150 = happySpecReduce_1 18# happyReduction_150 +happyReduction_150 happy_x_1 + = case happyOut26 happy_x_1 of { (HappyWrap26 happy_var_1) -> + happyIn28 + ([happy_var_1] + )} + +happyReduce_151 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_151 = happySpecReduce_2 18# happyReduction_151 +happyReduction_151 happy_x_2 + happy_x_1 + = case happyOut28 happy_x_1 of { (HappyWrap28 happy_var_1) -> + case happyOut26 happy_x_2 of { (HappyWrap26 happy_var_2) -> + happyIn28 + (happy_var_2 : happy_var_1 + )}} + +happyReduce_152 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_152 = happyMonadReduce 1# 19# happyReduction_152 +happyReduction_152 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOutTok happy_x_1 of { (TokQId happy_var_1) -> + ( mkQName happy_var_1)}) + ) (\r -> happyReturn (happyIn29 r)) + +happyReduce_153 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_153 = happySpecReduce_1 19# happyReduction_153 +happyReduction_153 happy_x_1 + = case happyOut19 happy_x_1 of { (HappyWrap19 happy_var_1) -> + happyIn29 + (QName happy_var_1 + )} + +happyReduce_154 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_154 = happySpecReduce_1 20# happyReduction_154 +happyReduction_154 happy_x_1 + = case happyOut29 happy_x_1 of { (HappyWrap29 happy_var_1) -> + happyIn30 + (happy_var_1 + )} + +happyReduce_155 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_155 = happySpecReduce_1 21# happyReduction_155 +happyReduction_155 happy_x_1 + = case happyOut19 happy_x_1 of { (HappyWrap19 happy_var_1) -> + happyIn31 + (happy_var_1 + )} + +happyReduce_156 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_156 = happySpecReduce_1 21# happyReduction_156 +happyReduction_156 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymUnderscore happy_var_1) -> + happyIn31 + (Name (getRange happy_var_1) InScope [Hole] + )} + +happyReduce_157 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_157 = happySpecReduce_2 22# happyReduction_157 +happyReduction_157 happy_x_2 + happy_x_1 + = case happyOut31 happy_x_1 of { (HappyWrap31 happy_var_1) -> + case happyOut32 happy_x_2 of { (HappyWrap32 happy_var_2) -> + happyIn32 + (happy_var_1 : happy_var_2 + )}} + +happyReduce_158 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_158 = happySpecReduce_1 22# happyReduction_158 +happyReduction_158 happy_x_1 + = case happyOut31 happy_x_1 of { (HappyWrap31 happy_var_1) -> + happyIn32 + ([happy_var_1] + )} + +happyReduce_159 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_159 = happyMonadReduce 1# 23# happyReduction_159 +happyReduction_159 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut34 happy_x_1 of { (HappyWrap34 happy_var_1) -> + ( + case happy_var_1 of + Left ns -> return ns + Right _ -> parseError $ "expected sequence of bound identifiers, not absurd pattern")}) + ) (\r -> happyReturn (happyIn33 r)) + +happyReduce_160 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_160 = happyMonadReduce 1# 24# happyReduction_160 +happyReduction_160 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut45 happy_x_1 of { (HappyWrap45 happy_var_1) -> + ( boundNamesOrAbsurd happy_var_1)}) + ) (\r -> happyReturn (happyIn34 r)) + +happyReduce_161 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_161 = happyMonadReduce 3# 24# happyReduction_161 +happyReduction_161 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut29 happy_x_1 of { (HappyWrap29 happy_var_1) -> + case happyOut29 happy_x_3 of { (HappyWrap29 happy_var_3) -> + ( (Left . pure . updateNamedArg mkBinder) `fmap` mkNamedArg (Just happy_var_1) (Left happy_var_3))}}) + ) (\r -> happyReturn (happyIn34 r)) + +happyReduce_162 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_162 = happyMonadReduce 3# 24# happyReduction_162 +happyReduction_162 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut29 happy_x_3 of { (HappyWrap29 happy_var_3) -> + ( (Left . pure . updateNamedArg mkBinder) `fmap` mkNamedArg Nothing (Left happy_var_3))}) + ) (\r -> happyReturn (happyIn34 r)) + +happyReduce_163 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_163 = happyMonadReduce 3# 24# happyReduction_163 +happyReduction_163 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut29 happy_x_1 of { (HappyWrap29 happy_var_1) -> + case happyOutTok happy_x_3 of { (TokSymbol SymUnderscore happy_var_3) -> + ( (Left . pure . updateNamedArg mkBinder) `fmap` mkNamedArg (Just happy_var_1) (Right $ getRange happy_var_3))}}) + ) (\r -> happyReturn (happyIn34 r)) + +happyReduce_164 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_164 = happyMonadReduce 3# 24# happyReduction_164 +happyReduction_164 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOutTok happy_x_3 of { (TokSymbol SymUnderscore happy_var_3) -> + ( (Left . pure . updateNamedArg mkBinder) `fmap` mkNamedArg Nothing (Right $ getRange happy_var_3))}) + ) (\r -> happyReturn (happyIn34 r)) + +happyReduce_165 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_165 = happyMonadReduce 1# 25# happyReduction_165 +happyReduction_165 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut45 happy_x_1 of { (HappyWrap45 happy_var_1) -> + ( + -- interpret an expression as a name and maybe a pattern + case mapM exprAsNameOrHiddenNames happy_var_1 of + Nothing -> parseError "Expected sequence of possibly hidden bound identifiers" + Just good -> forM (concat good) $ updateNamedArgA $ \ (n, me) -> do + p <- traverse exprToPattern me + pure $ Binder p (mkBoundName_ n))}) + ) (\r -> happyReturn (happyIn35 r)) + +happyReduce_166 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_166 = happySpecReduce_0 26# happyReduction_166 +happyReduction_166 = happyIn36 + ([] + ) + +happyReduce_167 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_167 = happySpecReduce_2 26# happyReduction_167 +happyReduction_167 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokString happy_var_1) -> + case happyOut36 happy_x_2 of { (HappyWrap36 happy_var_2) -> + happyIn36 + (snd happy_var_1 : happy_var_2 + )}} + +happyReduce_168 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_168 = happySpecReduce_0 27# happyReduction_168 +happyReduction_168 = happyIn37 + ([] + ) + +happyReduce_169 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_169 = happySpecReduce_2 27# happyReduction_169 +happyReduction_169 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokString happy_var_1) -> + case happyOut37 happy_x_2 of { (HappyWrap37 happy_var_2) -> + happyIn37 + (happy_var_1 : happy_var_2 + )}} + +happyReduce_170 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_170 = happySpecReduce_0 28# happyReduction_170 +happyReduction_170 = happyIn38 + ([] + ) + +happyReduce_171 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_171 = happySpecReduce_2 28# happyReduction_171 +happyReduction_171 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokString happy_var_1) -> + case happyOut38 happy_x_2 of { (HappyWrap38 happy_var_2) -> + happyIn38 + (happy_var_1 : happy_var_2 + )}} + +happyReduce_172 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_172 = happyReduce 4# 28# happyReduction_172 +happyReduction_172 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> + case happyOut38 happy_x_2 of { (HappyWrap38 happy_var_2) -> + case happyOutTok happy_x_3 of { (TokSymbol SymClosePragma happy_var_3) -> + case happyOut38 happy_x_4 of { (HappyWrap38 happy_var_4) -> + happyIn38 + ([(happy_var_1, "{-#")] ++ happy_var_2 ++ [(happy_var_3, "#-}")] ++ happy_var_4 + ) `HappyStk` happyRest}}}} + +happyReduce_173 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_173 = happyMonadReduce 1# 29# happyReduction_173 +happyReduction_173 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOutTok happy_x_1 of { (TokString happy_var_1) -> + ( mkName happy_var_1)}) + ) (\r -> happyReturn (happyIn39 r)) + +happyReduce_174 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_174 = happyMonadReduce 1# 30# happyReduction_174 +happyReduction_174 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOutTok happy_x_1 of { (TokString happy_var_1) -> + ( pragmaQName happy_var_1)}) + ) (\r -> happyReturn (happyIn40 r)) + +happyReduce_175 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_175 = happyMonadReduce 1# 31# happyReduction_175 +happyReduction_175 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut37 happy_x_1 of { (HappyWrap37 happy_var_1) -> + ( mapM pragmaQName happy_var_1)}) + ) (\r -> happyReturn (happyIn41 r)) + +happyReduce_176 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_176 = happySpecReduce_2 32# happyReduction_176 +happyReduction_176 happy_x_2 + happy_x_1 + = case happyOut62 happy_x_1 of { (HappyWrap62 happy_var_1) -> + case happyOut42 happy_x_2 of { (HappyWrap42 happy_var_2) -> + happyIn42 + (Pi happy_var_1 happy_var_2 + )}} + +happyReduce_177 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_177 = happySpecReduce_3 32# happyReduction_177 +happyReduction_177 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut49 happy_x_1 of { (HappyWrap49 happy_var_1) -> + case happyOutTok happy_x_2 of { (TokSymbol SymArrow happy_var_2) -> + case happyOut42 happy_x_3 of { (HappyWrap42 happy_var_3) -> + happyIn42 + (Fun (getRange (happy_var_1,happy_var_2,happy_var_3)) + (defaultArg $ rawAppUnlessSingleton (getRange happy_var_1) happy_var_1) + happy_var_3 + )}}} + +happyReduce_178 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_178 = happyMonadReduce 4# 32# happyReduction_178 +happyReduction_178 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut28 happy_x_1 of { (HappyWrap28 happy_var_1) -> + case happyOut49 happy_x_2 of { (HappyWrap49 happy_var_2) -> + case happyOutTok happy_x_3 of { (TokSymbol SymArrow happy_var_3) -> + case happyOut42 happy_x_4 of { (HappyWrap42 happy_var_4) -> + ( applyAttrs happy_var_1 (defaultArg $ rawAppUnlessSingleton (getRange (happy_var_1,happy_var_2)) happy_var_2) <&> \ dom -> + Fun (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4)) dom happy_var_4)}}}}) + ) (\r -> happyReturn (happyIn42 r)) + +happyReduce_179 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_179 = happySpecReduce_3 32# happyReduction_179 +happyReduction_179 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut43 happy_x_1 of { (HappyWrap43 happy_var_1) -> + case happyOutTok happy_x_2 of { (TokSymbol SymEqual happy_var_2) -> + case happyOut42 happy_x_3 of { (HappyWrap42 happy_var_3) -> + happyIn42 + (Equal (getRange (happy_var_1, happy_var_2, happy_var_3)) happy_var_1 happy_var_3 + )}}} + +happyReduce_180 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_180 = happySpecReduce_1 32# happyReduction_180 +happyReduction_180 happy_x_1 + = case happyOut43 happy_x_1 of { (HappyWrap43 happy_var_1) -> + happyIn42 + (happy_var_1 + )} + +happyReduce_181 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_181 = happyMonadReduce 1# 33# happyReduction_181 +happyReduction_181 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut44 happy_x_1 of { (HappyWrap44 happy_var_1) -> + ( case happy_var_1 of + { [e] -> return e + ; e : es -> return $ WithApp (fuseRange e es) e es + ; [] -> parseError "impossible: empty with expressions" + })}) + ) (\r -> happyReturn (happyIn43 r)) + +happyReduce_182 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_182 = happySpecReduce_3 34# happyReduction_182 +happyReduction_182 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut49 happy_x_1 of { (HappyWrap49 happy_var_1) -> + case happyOut44 happy_x_3 of { (HappyWrap44 happy_var_3) -> + happyIn44 + (RawApp (getRange happy_var_1) happy_var_1 : happy_var_3 + )}} + +happyReduce_183 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_183 = happySpecReduce_1 34# happyReduction_183 +happyReduction_183 happy_x_1 + = case happyOut45 happy_x_1 of { (HappyWrap45 happy_var_1) -> + happyIn44 + ([RawApp (getRange happy_var_1) happy_var_1] + )} + +happyReduce_184 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_184 = happySpecReduce_1 35# happyReduction_184 +happyReduction_184 happy_x_1 + = case happyOut46 happy_x_1 of { (HappyWrap46 happy_var_1) -> + happyIn45 + ([happy_var_1] + )} + +happyReduce_185 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_185 = happySpecReduce_2 35# happyReduction_185 +happyReduction_185 happy_x_2 + happy_x_1 + = case happyOut54 happy_x_1 of { (HappyWrap54 happy_var_1) -> + case happyOut45 happy_x_2 of { (HappyWrap45 happy_var_2) -> + happyIn45 + (happy_var_1 : happy_var_2 + )}} + +happyReduce_186 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_186 = happySpecReduce_3 36# happyReduction_186 +happyReduction_186 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymLambda happy_var_1) -> + case happyOut70 happy_x_2 of { (HappyWrap70 happy_var_2) -> + case happyOut42 happy_x_3 of { (HappyWrap42 happy_var_3) -> + happyIn46 + (Lam (getRange (happy_var_1,happy_var_2,happy_var_3)) happy_var_2 happy_var_3 + )}}} + +happyReduce_187 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_187 = happySpecReduce_1 36# happyReduction_187 +happyReduction_187 happy_x_1 + = case happyOut48 happy_x_1 of { (HappyWrap48 happy_var_1) -> + happyIn46 + (happy_var_1 + )} + +happyReduce_188 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_188 = happySpecReduce_3 36# happyReduction_188 +happyReduction_188 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut79 happy_x_2 of { (HappyWrap79 happy_var_2) -> + case happyOut42 happy_x_3 of { (HappyWrap42 happy_var_3) -> + happyIn46 + (forallPi happy_var_2 happy_var_3 + )}} + +happyReduce_189 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_189 = happySpecReduce_3 36# happyReduction_189 +happyReduction_189 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwLet happy_var_1) -> + case happyOut183 happy_x_2 of { (HappyWrap183 happy_var_2) -> + case happyOut47 happy_x_3 of { (HappyWrap47 happy_var_3) -> + happyIn46 + (Let (getRange (happy_var_1,happy_var_2,happy_var_3)) happy_var_2 happy_var_3 + )}}} + +happyReduce_190 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_190 = happyReduce 4# 36# happyReduction_190 +happyReduction_190 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOutTok happy_x_1 of { (TokKeyword KwDo happy_var_1) -> + case happyOut85 happy_x_3 of { (HappyWrap85 happy_var_3) -> + happyIn46 + (DoBlock (getRange (happy_var_1, happy_var_3)) happy_var_3 + ) `HappyStk` happyRest}} + +happyReduce_191 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_191 = happySpecReduce_1 36# happyReduction_191 +happyReduction_191 happy_x_1 + = case happyOut54 happy_x_1 of { (HappyWrap54 happy_var_1) -> + happyIn46 + (happy_var_1 + )} + +happyReduce_192 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_192 = happySpecReduce_2 36# happyReduction_192 +happyReduction_192 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwTactic happy_var_1) -> + case happyOut49 happy_x_2 of { (HappyWrap49 happy_var_2) -> + happyIn46 + (Tactic (getRange (happy_var_1, happy_var_2)) (RawApp (getRange happy_var_2) happy_var_2) + )}} + +happyReduce_193 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_193 = happySpecReduce_2 37# happyReduction_193 +happyReduction_193 happy_x_2 + happy_x_1 + = case happyOut42 happy_x_2 of { (HappyWrap42 happy_var_2) -> + happyIn47 + (Just happy_var_2 + )} + +happyReduce_194 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_194 = happySpecReduce_0 37# happyReduction_194 +happyReduction_194 = happyIn47 + (Nothing + ) + +happyReduce_195 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_195 = happyReduce 4# 38# happyReduction_195 +happyReduction_195 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOutTok happy_x_1 of { (TokSymbol SymLambda happy_var_1) -> + case happyOutTok happy_x_2 of { (TokSymbol SymOpenBrace happy_var_2) -> + case happyOut77 happy_x_3 of { (HappyWrap77 happy_var_3) -> + case happyOutTok happy_x_4 of { (TokSymbol SymCloseBrace happy_var_4) -> + happyIn48 + (ExtendedLam (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4)) (reverse happy_var_3) + ) `HappyStk` happyRest}}}} + +happyReduce_196 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_196 = happyReduce 5# 38# happyReduction_196 +happyReduction_196 (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 { (TokSymbol SymLambda happy_var_1) -> + case happyOutTok happy_x_2 of { (TokKeyword KwWhere happy_var_2) -> + case happyOut78 happy_x_4 of { (HappyWrap78 happy_var_4) -> + happyIn48 + (ExtendedLam (getRange (happy_var_1, happy_var_2, happy_var_4)) (reverse happy_var_4) + ) `HappyStk` happyRest}}} + +happyReduce_197 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_197 = happyMonadReduce 2# 38# happyReduction_197 +happyReduction_197 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOutTok happy_x_1 of { (TokSymbol SymLambda happy_var_1) -> + case happyOut71 happy_x_2 of { (HappyWrap71 happy_var_2) -> + ( case happy_var_2 of + Left (bs, h) -> if null bs then return $ AbsurdLam r h else + return $ Lam r bs (AbsurdLam r h) + where r = fuseRange happy_var_1 bs + Right es -> do -- it is of the form @\ { p1 ... () }@ + p <- exprToLHS (RawApp (getRange es) es); + return $ ExtendedLam (fuseRange happy_var_1 es) + [LamClause (p [] []) AbsurdRHS NoWhere False])}}) + ) (\r -> happyReturn (happyIn48 r)) + +happyReduce_198 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_198 = happySpecReduce_1 39# happyReduction_198 +happyReduction_198 happy_x_1 + = case happyOut54 happy_x_1 of { (HappyWrap54 happy_var_1) -> + happyIn49 + ([happy_var_1] + )} + +happyReduce_199 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_199 = happySpecReduce_2 39# happyReduction_199 +happyReduction_199 happy_x_2 + happy_x_1 + = case happyOut54 happy_x_1 of { (HappyWrap54 happy_var_1) -> + case happyOut49 happy_x_2 of { (HappyWrap49 happy_var_2) -> + happyIn49 + (happy_var_1 : happy_var_2 + )}} + +happyReduce_200 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_200 = happySpecReduce_0 40# happyReduction_200 +happyReduction_200 = happyIn50 + ([] + ) + +happyReduce_201 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_201 = happySpecReduce_2 40# happyReduction_201 +happyReduction_201 happy_x_2 + happy_x_1 + = case happyOut54 happy_x_1 of { (HappyWrap54 happy_var_1) -> + case happyOut50 happy_x_2 of { (HappyWrap50 happy_var_2) -> + happyIn50 + (happy_var_1 : happy_var_2 + )}} + +happyReduce_202 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_202 = happyMonadReduce 3# 41# happyReduction_202 +happyReduction_202 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOutTok happy_x_1 of { (TokSymbol SymOpenBrace happy_var_1) -> + case happyOut42 happy_x_2 of { (HappyWrap42 happy_var_2) -> + case happyOutTok happy_x_3 of { (TokSymbol SymCloseBrace happy_var_3) -> + ( HiddenArg (getRange (happy_var_1,happy_var_2,happy_var_3)) `fmap` maybeNamed happy_var_2)}}}) + ) (\r -> happyReturn (happyIn51 r)) + +happyReduce_203 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_203 = happySpecReduce_2 41# happyReduction_203 +happyReduction_203 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymOpenBrace happy_var_1) -> + case happyOutTok happy_x_2 of { (TokSymbol SymCloseBrace happy_var_2) -> + happyIn51 + (let r = fuseRange happy_var_1 happy_var_2 in HiddenArg r $ unnamed $ Absurd r + )}} + +happyReduce_204 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_204 = happySpecReduce_1 42# happyReduction_204 +happyReduction_204 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymQuestionMark happy_var_1) -> + happyIn52 + (QuestionMark (getRange happy_var_1) Nothing + )} + +happyReduce_205 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_205 = happySpecReduce_1 42# happyReduction_205 +happyReduction_205 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymUnderscore happy_var_1) -> + happyIn52 + (Underscore (getRange happy_var_1) Nothing + )} + +happyReduce_206 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_206 = happySpecReduce_1 42# happyReduction_206 +happyReduction_206 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwProp happy_var_1) -> + happyIn52 + (Prop (getRange happy_var_1) + )} + +happyReduce_207 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_207 = happySpecReduce_1 42# happyReduction_207 +happyReduction_207 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwSet happy_var_1) -> + happyIn52 + (Set (getRange happy_var_1) + )} + +happyReduce_208 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_208 = happySpecReduce_1 42# happyReduction_208 +happyReduction_208 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwQuote happy_var_1) -> + happyIn52 + (Quote (getRange happy_var_1) + )} + +happyReduce_209 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_209 = happySpecReduce_1 42# happyReduction_209 +happyReduction_209 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwQuoteTerm happy_var_1) -> + happyIn52 + (QuoteTerm (getRange happy_var_1) + )} + +happyReduce_210 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_210 = happySpecReduce_1 42# happyReduction_210 +happyReduction_210 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwUnquote happy_var_1) -> + happyIn52 + (Unquote (getRange happy_var_1) + )} + +happyReduce_211 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_211 = happySpecReduce_1 42# happyReduction_211 +happyReduction_211 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSetN happy_var_1) -> + happyIn52 + (SetN (getRange (fst happy_var_1)) (snd happy_var_1) + )} + +happyReduce_212 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_212 = happySpecReduce_1 42# happyReduction_212 +happyReduction_212 happy_x_1 + = case happyOutTok happy_x_1 of { (TokPropN happy_var_1) -> + happyIn52 + (PropN (getRange (fst happy_var_1)) (snd happy_var_1) + )} + +happyReduce_213 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_213 = happyMonadReduce 3# 42# happyReduction_213 +happyReduction_213 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOutTok happy_x_1 of { (TokSymbol SymDoubleOpenBrace happy_var_1) -> + case happyOut42 happy_x_2 of { (HappyWrap42 happy_var_2) -> + case happyOut21 happy_x_3 of { (HappyWrap21 happy_var_3) -> + ( InstanceArg (getRange (happy_var_1,happy_var_2,happy_var_3)) `fmap` maybeNamed happy_var_2)}}}) + ) (\r -> happyReturn (happyIn52 r)) + +happyReduce_214 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_214 = happySpecReduce_3 42# happyReduction_214 +happyReduction_214 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymOpenIdiomBracket happy_var_1) -> + case happyOut44 happy_x_2 of { (HappyWrap44 happy_var_2) -> + case happyOutTok happy_x_3 of { (TokSymbol SymCloseIdiomBracket happy_var_3) -> + happyIn52 + (IdiomBrackets (getRange (happy_var_1,happy_var_2,happy_var_3)) happy_var_2 + )}}} + +happyReduce_215 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_215 = happySpecReduce_1 42# happyReduction_215 +happyReduction_215 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymEmptyIdiomBracket happy_var_1) -> + happyIn52 + (IdiomBrackets (getRange happy_var_1) [] + )} + +happyReduce_216 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_216 = happySpecReduce_2 42# happyReduction_216 +happyReduction_216 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymOpenParen happy_var_1) -> + case happyOutTok happy_x_2 of { (TokSymbol SymCloseParen happy_var_2) -> + happyIn52 + (Absurd (fuseRange happy_var_1 happy_var_2) + )}} + +happyReduce_217 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_217 = happySpecReduce_2 42# happyReduction_217 +happyReduction_217 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymDoubleOpenBrace happy_var_1) -> + case happyOut21 happy_x_2 of { (HappyWrap21 happy_var_2) -> + happyIn52 + (let r = fuseRange happy_var_1 happy_var_2 in InstanceArg r $ unnamed $ Absurd r + )}} + +happyReduce_218 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_218 = happySpecReduce_3 42# happyReduction_218 +happyReduction_218 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut19 happy_x_1 of { (HappyWrap19 happy_var_1) -> + case happyOutTok happy_x_2 of { (TokSymbol SymAs happy_var_2) -> + case happyOut54 happy_x_3 of { (HappyWrap54 happy_var_3) -> + happyIn52 + (As (getRange (happy_var_1,happy_var_2,happy_var_3)) happy_var_1 happy_var_3 + )}}} + +happyReduce_219 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_219 = happySpecReduce_2 42# happyReduction_219 +happyReduction_219 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymDot happy_var_1) -> + case happyOut54 happy_x_2 of { (HappyWrap54 happy_var_2) -> + happyIn52 + (Dot (fuseRange happy_var_1 happy_var_2) happy_var_2 + )}} + +happyReduce_220 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_220 = happySpecReduce_2 42# happyReduction_220 +happyReduction_220 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymDotDot happy_var_1) -> + case happyOut54 happy_x_2 of { (HappyWrap54 happy_var_2) -> + happyIn52 + (DoubleDot (fuseRange happy_var_1 happy_var_2) happy_var_2 + )}} + +happyReduce_221 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_221 = happyReduce 4# 42# happyReduction_221 +happyReduction_221 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOutTok happy_x_1 of { (TokKeyword KwRecord happy_var_1) -> + case happyOutTok happy_x_2 of { (TokSymbol SymOpenBrace happy_var_2) -> + case happyOut55 happy_x_3 of { (HappyWrap55 happy_var_3) -> + case happyOutTok happy_x_4 of { (TokSymbol SymCloseBrace happy_var_4) -> + happyIn52 + (Rec (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4)) happy_var_3 + ) `HappyStk` happyRest}}}} + +happyReduce_222 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_222 = happyReduce 5# 42# happyReduction_222 +happyReduction_222 (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 { (TokKeyword KwRecord happy_var_1) -> + case happyOut52 happy_x_2 of { (HappyWrap52 happy_var_2) -> + case happyOutTok happy_x_3 of { (TokSymbol SymOpenBrace happy_var_3) -> + case happyOut59 happy_x_4 of { (HappyWrap59 happy_var_4) -> + case happyOutTok happy_x_5 of { (TokSymbol SymCloseBrace happy_var_5) -> + happyIn52 + (RecUpdate (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4,happy_var_5)) happy_var_2 happy_var_4 + ) `HappyStk` happyRest}}}}} + +happyReduce_223 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_223 = happySpecReduce_1 42# happyReduction_223 +happyReduction_223 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymEllipsis happy_var_1) -> + happyIn52 + (Ellipsis (getRange happy_var_1) + )} + +happyReduce_224 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_224 = happySpecReduce_1 42# happyReduction_224 +happyReduction_224 happy_x_1 + = case happyOut53 happy_x_1 of { (HappyWrap53 happy_var_1) -> + happyIn52 + (happy_var_1 + )} + +happyReduce_225 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_225 = happySpecReduce_1 43# happyReduction_225 +happyReduction_225 happy_x_1 + = case happyOut29 happy_x_1 of { (HappyWrap29 happy_var_1) -> + happyIn53 + (Ident happy_var_1 + )} + +happyReduce_226 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_226 = happySpecReduce_1 43# happyReduction_226 +happyReduction_226 happy_x_1 + = case happyOutTok happy_x_1 of { (TokLiteral happy_var_1) -> + happyIn53 + (Lit happy_var_1 + )} + +happyReduce_227 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_227 = happySpecReduce_3 43# happyReduction_227 +happyReduction_227 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymOpenParen happy_var_1) -> + case happyOut42 happy_x_2 of { (HappyWrap42 happy_var_2) -> + case happyOutTok happy_x_3 of { (TokSymbol SymCloseParen happy_var_3) -> + happyIn53 + (Paren (getRange (happy_var_1,happy_var_2,happy_var_3)) happy_var_2 + )}}} + +happyReduce_228 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_228 = happySpecReduce_1 44# happyReduction_228 +happyReduction_228 happy_x_1 + = case happyOut51 happy_x_1 of { (HappyWrap51 happy_var_1) -> + happyIn54 + (happy_var_1 + )} + +happyReduce_229 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_229 = happySpecReduce_1 44# happyReduction_229 +happyReduction_229 happy_x_1 + = case happyOut52 happy_x_1 of { (HappyWrap52 happy_var_1) -> + happyIn54 + (happy_var_1 + )} + +happyReduce_230 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_230 = happySpecReduce_0 45# happyReduction_230 +happyReduction_230 = happyIn55 + ([] + ) + +happyReduce_231 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_231 = happySpecReduce_1 45# happyReduction_231 +happyReduction_231 happy_x_1 + = case happyOut56 happy_x_1 of { (HappyWrap56 happy_var_1) -> + happyIn55 + (happy_var_1 + )} + +happyReduce_232 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_232 = happySpecReduce_1 46# happyReduction_232 +happyReduction_232 happy_x_1 + = case happyOut57 happy_x_1 of { (HappyWrap57 happy_var_1) -> + happyIn56 + ([happy_var_1] + )} + +happyReduce_233 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_233 = happySpecReduce_3 46# happyReduction_233 +happyReduction_233 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut57 happy_x_1 of { (HappyWrap57 happy_var_1) -> + case happyOut56 happy_x_3 of { (HappyWrap56 happy_var_3) -> + happyIn56 + (happy_var_1 : happy_var_3 + )}} + +happyReduce_234 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_234 = happySpecReduce_1 47# happyReduction_234 +happyReduction_234 happy_x_1 + = case happyOut61 happy_x_1 of { (HappyWrap61 happy_var_1) -> + happyIn57 + (Left happy_var_1 + )} + +happyReduce_235 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_235 = happySpecReduce_1 47# happyReduction_235 +happyReduction_235 happy_x_1 + = case happyOut58 happy_x_1 of { (HappyWrap58 happy_var_1) -> + happyIn57 + (Right happy_var_1 + )} + +happyReduce_236 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_236 = happySpecReduce_3 48# happyReduction_236 +happyReduction_236 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut30 happy_x_1 of { (HappyWrap30 happy_var_1) -> + case happyOut138 happy_x_2 of { (HappyWrap138 happy_var_2) -> + case happyOut88 happy_x_3 of { (HappyWrap88 happy_var_3) -> + happyIn58 + (ModuleAssignment happy_var_1 happy_var_2 happy_var_3 + )}}} + +happyReduce_237 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_237 = happySpecReduce_0 49# happyReduction_237 +happyReduction_237 = happyIn59 + ([] + ) + +happyReduce_238 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_238 = happySpecReduce_1 49# happyReduction_238 +happyReduction_238 happy_x_1 + = case happyOut60 happy_x_1 of { (HappyWrap60 happy_var_1) -> + happyIn59 + (happy_var_1 + )} + +happyReduce_239 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_239 = happySpecReduce_1 50# happyReduction_239 +happyReduction_239 happy_x_1 + = case happyOut61 happy_x_1 of { (HappyWrap61 happy_var_1) -> + happyIn60 + ([happy_var_1] + )} + +happyReduce_240 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_240 = happySpecReduce_3 50# happyReduction_240 +happyReduction_240 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut61 happy_x_1 of { (HappyWrap61 happy_var_1) -> + case happyOut60 happy_x_3 of { (HappyWrap60 happy_var_3) -> + happyIn60 + (happy_var_1 : happy_var_3 + )}} + +happyReduce_241 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_241 = happySpecReduce_3 51# happyReduction_241 +happyReduction_241 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut19 happy_x_1 of { (HappyWrap19 happy_var_1) -> + case happyOut42 happy_x_3 of { (HappyWrap42 happy_var_3) -> + happyIn61 + (FieldAssignment happy_var_1 happy_var_3 + )}} + +happyReduce_242 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_242 = happySpecReduce_2 52# happyReduction_242 +happyReduction_242 happy_x_2 + happy_x_1 + = case happyOut63 happy_x_1 of { (HappyWrap63 happy_var_1) -> + happyIn62 + (happy_var_1 + )} + +happyReduce_243 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_243 = happySpecReduce_1 53# happyReduction_243 +happyReduction_243 happy_x_1 + = case happyOut64 happy_x_1 of { (HappyWrap64 happy_var_1) -> + happyIn63 + (happy_var_1 + )} + +happyReduce_244 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_244 = happySpecReduce_2 54# happyReduction_244 +happyReduction_244 happy_x_2 + happy_x_1 + = case happyOut65 happy_x_1 of { (HappyWrap65 happy_var_1) -> + case happyOut64 happy_x_2 of { (HappyWrap64 happy_var_2) -> + happyIn64 + (happy_var_1 : happy_var_2 + )}} + +happyReduce_245 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_245 = happySpecReduce_1 54# happyReduction_245 +happyReduction_245 happy_x_1 + = case happyOut65 happy_x_1 of { (HappyWrap65 happy_var_1) -> + happyIn64 + ([happy_var_1] + )} + +happyReduce_246 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_246 = happyReduce 4# 55# happyReduction_246 +happyReduction_246 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOutTok happy_x_2 of { (TokSymbol SymOpenParen happy_var_2) -> + case happyOut68 happy_x_3 of { (HappyWrap68 happy_var_3) -> + case happyOutTok happy_x_4 of { (TokSymbol SymCloseParen happy_var_4) -> + happyIn65 + (setRange (getRange (happy_var_2,happy_var_3,happy_var_4)) $ + setRelevance Irrelevant happy_var_3 + ) `HappyStk` happyRest}}} + +happyReduce_247 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_247 = happyReduce 4# 55# happyReduction_247 +happyReduction_247 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOutTok happy_x_2 of { (TokSymbol SymOpenBrace happy_var_2) -> + case happyOut66 happy_x_3 of { (HappyWrap66 happy_var_3) -> + case happyOutTok happy_x_4 of { (TokSymbol SymCloseBrace happy_var_4) -> + happyIn65 + (setRange (getRange (happy_var_2,happy_var_3,happy_var_4)) $ + setHiding Hidden $ + setRelevance Irrelevant happy_var_3 + ) `HappyStk` happyRest}}} + +happyReduce_248 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_248 = happyReduce 4# 55# happyReduction_248 +happyReduction_248 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOutTok happy_x_2 of { (TokSymbol SymDoubleOpenBrace happy_var_2) -> + case happyOut66 happy_x_3 of { (HappyWrap66 happy_var_3) -> + case happyOut21 happy_x_4 of { (HappyWrap21 happy_var_4) -> + happyIn65 + (setRange (getRange (happy_var_2,happy_var_3,happy_var_4)) $ + makeInstance $ + setRelevance Irrelevant happy_var_3 + ) `HappyStk` happyRest}}} + +happyReduce_249 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_249 = happyReduce 4# 55# happyReduction_249 +happyReduction_249 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOutTok happy_x_2 of { (TokSymbol SymOpenParen happy_var_2) -> + case happyOut68 happy_x_3 of { (HappyWrap68 happy_var_3) -> + case happyOutTok happy_x_4 of { (TokSymbol SymCloseParen happy_var_4) -> + happyIn65 + (setRange (getRange (happy_var_2,happy_var_3,happy_var_4)) $ + setRelevance NonStrict happy_var_3 + ) `HappyStk` happyRest}}} + +happyReduce_250 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_250 = happyReduce 4# 55# happyReduction_250 +happyReduction_250 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOutTok happy_x_2 of { (TokSymbol SymOpenBrace happy_var_2) -> + case happyOut66 happy_x_3 of { (HappyWrap66 happy_var_3) -> + case happyOutTok happy_x_4 of { (TokSymbol SymCloseBrace happy_var_4) -> + happyIn65 + (setRange (getRange (happy_var_2,happy_var_3,happy_var_4)) $ + setHiding Hidden $ + setRelevance NonStrict happy_var_3 + ) `HappyStk` happyRest}}} + +happyReduce_251 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_251 = happyReduce 4# 55# happyReduction_251 +happyReduction_251 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOutTok happy_x_2 of { (TokSymbol SymDoubleOpenBrace happy_var_2) -> + case happyOut66 happy_x_3 of { (HappyWrap66 happy_var_3) -> + case happyOut21 happy_x_4 of { (HappyWrap21 happy_var_4) -> + happyIn65 + (setRange (getRange (happy_var_2,happy_var_3,happy_var_4)) $ + makeInstance $ + setRelevance NonStrict happy_var_3 + ) `HappyStk` happyRest}}} + +happyReduce_252 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_252 = happySpecReduce_3 55# happyReduction_252 +happyReduction_252 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymOpenParen happy_var_1) -> + case happyOut68 happy_x_2 of { (HappyWrap68 happy_var_2) -> + case happyOutTok happy_x_3 of { (TokSymbol SymCloseParen happy_var_3) -> + happyIn65 + (setRange (getRange (happy_var_1,happy_var_2,happy_var_3)) happy_var_2 + )}}} + +happyReduce_253 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_253 = happySpecReduce_3 55# happyReduction_253 +happyReduction_253 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymOpenParen happy_var_1) -> + case happyOut69 happy_x_2 of { (HappyWrap69 happy_var_2) -> + case happyOutTok happy_x_3 of { (TokSymbol SymCloseParen happy_var_3) -> + happyIn65 + (setRange (getRange (happy_var_1,happy_var_2,happy_var_3)) happy_var_2 + )}}} + +happyReduce_254 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_254 = happySpecReduce_3 55# happyReduction_254 +happyReduction_254 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymDoubleOpenBrace happy_var_1) -> + case happyOut66 happy_x_2 of { (HappyWrap66 happy_var_2) -> + case happyOut21 happy_x_3 of { (HappyWrap21 happy_var_3) -> + happyIn65 + (setRange (getRange (happy_var_1,happy_var_2,happy_var_3)) $ + makeInstance happy_var_2 + )}}} + +happyReduce_255 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_255 = happySpecReduce_3 55# happyReduction_255 +happyReduction_255 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymDoubleOpenBrace happy_var_1) -> + case happyOut67 happy_x_2 of { (HappyWrap67 happy_var_2) -> + case happyOut21 happy_x_3 of { (HappyWrap21 happy_var_3) -> + happyIn65 + (setRange (getRange (happy_var_1,happy_var_2,happy_var_3)) $ + makeInstance happy_var_2 + )}}} + +happyReduce_256 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_256 = happySpecReduce_3 55# happyReduction_256 +happyReduction_256 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymOpenBrace happy_var_1) -> + case happyOut66 happy_x_2 of { (HappyWrap66 happy_var_2) -> + case happyOutTok happy_x_3 of { (TokSymbol SymCloseBrace happy_var_3) -> + happyIn65 + (setRange (getRange (happy_var_1,happy_var_2,happy_var_3)) $ + setHiding Hidden happy_var_2 + )}}} + +happyReduce_257 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_257 = happySpecReduce_3 55# happyReduction_257 +happyReduction_257 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymOpenBrace happy_var_1) -> + case happyOut67 happy_x_2 of { (HappyWrap67 happy_var_2) -> + case happyOutTok happy_x_3 of { (TokSymbol SymCloseBrace happy_var_3) -> + happyIn65 + (setRange (getRange (happy_var_1,happy_var_2,happy_var_3)) $ + setHiding Hidden happy_var_2 + )}}} + +happyReduce_258 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_258 = happySpecReduce_3 55# happyReduction_258 +happyReduction_258 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymOpenParen happy_var_1) -> + case happyOut137 happy_x_2 of { (HappyWrap137 happy_var_2) -> + case happyOutTok happy_x_3 of { (TokSymbol SymCloseParen happy_var_3) -> + happyIn65 + (TLet (getRange (happy_var_1,happy_var_3)) happy_var_2 + )}}} + +happyReduce_259 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_259 = happyReduce 4# 55# happyReduction_259 +happyReduction_259 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOutTok happy_x_1 of { (TokSymbol SymOpenParen happy_var_1) -> + case happyOut183 happy_x_3 of { (HappyWrap183 happy_var_3) -> + case happyOutTok happy_x_4 of { (TokSymbol SymCloseParen happy_var_4) -> + happyIn65 + (TLet (getRange (happy_var_1,happy_var_4)) happy_var_3 + ) `HappyStk` happyRest}}} + +happyReduce_260 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_260 = happySpecReduce_3 56# happyReduction_260 +happyReduction_260 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut33 happy_x_1 of { (HappyWrap33 happy_var_1) -> + case happyOutTok happy_x_2 of { (TokSymbol SymColon happy_var_2) -> + case happyOut42 happy_x_3 of { (HappyWrap42 happy_var_3) -> + happyIn66 + (let r = getRange (happy_var_1,happy_var_2,happy_var_3) -- the range is approximate only for TypedBindings + in TBind r happy_var_1 happy_var_3 + )}}} + +happyReduce_261 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_261 = happyMonadReduce 4# 57# happyReduction_261 +happyReduction_261 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut28 happy_x_1 of { (HappyWrap28 happy_var_1) -> + case happyOut33 happy_x_2 of { (HappyWrap33 happy_var_2) -> + case happyOutTok happy_x_3 of { (TokSymbol SymColon happy_var_3) -> + case happyOut42 happy_x_4 of { (HappyWrap42 happy_var_4) -> + ( do + let r = getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4) -- the range is approximate only for TypedBindings + xs <- mapM (applyAttrs happy_var_1 . setTacticAttr happy_var_1) happy_var_2 + return $ TBind r xs happy_var_4)}}}}) + ) (\r -> happyReturn (happyIn67 r)) + +happyReduce_262 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_262 = happySpecReduce_3 58# happyReduction_262 +happyReduction_262 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut35 happy_x_1 of { (HappyWrap35 happy_var_1) -> + case happyOutTok happy_x_2 of { (TokSymbol SymColon happy_var_2) -> + case happyOut42 happy_x_3 of { (HappyWrap42 happy_var_3) -> + happyIn68 + (let r = getRange (happy_var_1,happy_var_2,happy_var_3) -- the range is approximate only for TypedBindings + in TBind r happy_var_1 happy_var_3 + )}}} + +happyReduce_263 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_263 = happyMonadReduce 4# 59# happyReduction_263 +happyReduction_263 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut28 happy_x_1 of { (HappyWrap28 happy_var_1) -> + case happyOut35 happy_x_2 of { (HappyWrap35 happy_var_2) -> + case happyOutTok happy_x_3 of { (TokSymbol SymColon happy_var_3) -> + case happyOut42 happy_x_4 of { (HappyWrap42 happy_var_4) -> + ( do + let r = getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4) -- the range is approximate only for TypedBindings + xs <- mapM (applyAttrs happy_var_1 . setTacticAttr happy_var_1) happy_var_2 + return $ TBind r xs happy_var_4)}}}}) + ) (\r -> happyReturn (happyIn69 r)) + +happyReduce_264 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_264 = happyMonadReduce 2# 60# happyReduction_264 +happyReduction_264 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut72 happy_x_1 of { (HappyWrap72 happy_var_1) -> + ( + case reverse happy_var_1 of + Left _ : _ -> parseError "Absurd lambda cannot have a body." + _ : _ -> return [ b | Right b <- happy_var_1 ] + [] -> parsePanic "Empty LamBinds")}) + ) (\r -> happyReturn (happyIn70 r)) + +happyReduce_265 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_265 = happyMonadReduce 1# 61# happyReduction_265 +happyReduction_265 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut73 happy_x_1 of { (HappyWrap73 happy_var_1) -> + ( + case happy_var_1 of + Left lb -> case reverse lb of + Right _ : _ -> parseError "Missing body for lambda" + Left h : _ -> return $ Left ([ b | Right b <- init lb], h) + _ -> parseError "Unsupported variant of lambda" + Right es -> return $ Right es)}) + ) (\r -> happyReturn (happyIn71 r)) + +happyReduce_266 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_266 = happySpecReduce_2 62# happyReduction_266 +happyReduction_266 happy_x_2 + happy_x_1 + = case happyOut82 happy_x_1 of { (HappyWrap82 happy_var_1) -> + case happyOut72 happy_x_2 of { (HappyWrap72 happy_var_2) -> + happyIn72 + (map Right happy_var_1 ++ happy_var_2 + )}} + +happyReduce_267 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_267 = happySpecReduce_2 62# happyReduction_267 +happyReduction_267 happy_x_2 + happy_x_1 + = case happyOut65 happy_x_1 of { (HappyWrap65 happy_var_1) -> + case happyOut72 happy_x_2 of { (HappyWrap72 happy_var_2) -> + happyIn72 + (Right (DomainFull happy_var_1) : happy_var_2 + )}} + +happyReduce_268 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_268 = happySpecReduce_1 62# happyReduction_268 +happyReduction_268 happy_x_1 + = case happyOut82 happy_x_1 of { (HappyWrap82 happy_var_1) -> + happyIn72 + (map Right happy_var_1 + )} + +happyReduce_269 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_269 = happySpecReduce_1 62# happyReduction_269 +happyReduction_269 happy_x_1 + = case happyOut65 happy_x_1 of { (HappyWrap65 happy_var_1) -> + happyIn72 + ([Right $ DomainFull happy_var_1] + )} + +happyReduce_270 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_270 = happySpecReduce_2 62# happyReduction_270 +happyReduction_270 happy_x_2 + happy_x_1 + = happyIn72 + ([Left NotHidden] + ) + +happyReduce_271 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_271 = happySpecReduce_2 62# happyReduction_271 +happyReduction_271 happy_x_2 + happy_x_1 + = happyIn72 + ([Left Hidden] + ) + +happyReduce_272 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_272 = happySpecReduce_2 62# happyReduction_272 +happyReduction_272 happy_x_2 + happy_x_1 + = happyIn72 + ([Left (Instance NoOverlap)] + ) + +happyReduce_273 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_273 = happySpecReduce_2 63# happyReduction_273 +happyReduction_273 happy_x_2 + happy_x_1 + = case happyOut82 happy_x_1 of { (HappyWrap82 happy_var_1) -> + case happyOut72 happy_x_2 of { (HappyWrap72 happy_var_2) -> + happyIn73 + (Left $ map Right happy_var_1 ++ happy_var_2 + )}} + +happyReduce_274 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_274 = happySpecReduce_2 63# happyReduction_274 +happyReduction_274 happy_x_2 + happy_x_1 + = case happyOut65 happy_x_1 of { (HappyWrap65 happy_var_1) -> + case happyOut72 happy_x_2 of { (HappyWrap72 happy_var_2) -> + happyIn73 + (Left $ Right (DomainFull happy_var_1) : happy_var_2 + )}} + +happyReduce_275 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_275 = happySpecReduce_1 63# happyReduction_275 +happyReduction_275 happy_x_1 + = case happyOut84 happy_x_1 of { (HappyWrap84 happy_var_1) -> + happyIn73 + (case happy_var_1 of + Left lb -> Left $ map Right lb + Right es -> Right es + )} + +happyReduce_276 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_276 = happySpecReduce_1 63# happyReduction_276 +happyReduction_276 happy_x_1 + = case happyOut65 happy_x_1 of { (HappyWrap65 happy_var_1) -> + happyIn73 + (Left [Right $ DomainFull happy_var_1] + )} + +happyReduce_277 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_277 = happySpecReduce_2 63# happyReduction_277 +happyReduction_277 happy_x_2 + happy_x_1 + = happyIn73 + (Left [Left NotHidden] + ) + +happyReduce_278 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_278 = happySpecReduce_2 63# happyReduction_278 +happyReduction_278 happy_x_2 + happy_x_1 + = happyIn73 + (Left [Left Hidden] + ) + +happyReduce_279 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_279 = happySpecReduce_2 63# happyReduction_279 +happyReduction_279 happy_x_2 + happy_x_1 + = happyIn73 + (Left [Left (Instance NoOverlap)] + ) + +happyReduce_280 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_280 = happyMonadReduce 3# 64# happyReduction_280 +happyReduction_280 (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 happyOut42 happy_x_3 of { (HappyWrap42 happy_var_3) -> + ( do + p <- exprToLHS (RawApp (getRange happy_var_1) happy_var_1) ; + return LamClause{ lamLHS = p [] [] + , lamRHS = RHS happy_var_3 + , lamWhere = NoWhere + , lamCatchAll = False })}}) + ) (\r -> happyReturn (happyIn74 r)) + +happyReduce_281 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_281 = happyMonadReduce 4# 64# happyReduction_281 +happyReduction_281 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut50 happy_x_2 of { (HappyWrap50 happy_var_2) -> + case happyOut42 happy_x_4 of { (HappyWrap42 happy_var_4) -> + ( do + p <- exprToLHS (RawApp (getRange happy_var_2) happy_var_2) ; + return LamClause{ lamLHS = p [] [] + , lamRHS = RHS happy_var_4 + , lamWhere = NoWhere + , lamCatchAll = True })}}) + ) (\r -> happyReturn (happyIn74 r)) + +happyReduce_282 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_282 = happyMonadReduce 1# 65# happyReduction_282 +happyReduction_282 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut45 happy_x_1 of { (HappyWrap45 happy_var_1) -> + ( do + p <- exprToLHS (RawApp (getRange happy_var_1) happy_var_1); + return LamClause{ lamLHS = p [] [] + , lamRHS = AbsurdRHS + , lamWhere = NoWhere + , lamCatchAll = False })}) + ) (\r -> happyReturn (happyIn75 r)) + +happyReduce_283 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_283 = happyMonadReduce 2# 65# happyReduction_283 +happyReduction_283 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut45 happy_x_2 of { (HappyWrap45 happy_var_2) -> + ( do + p <- exprToLHS (RawApp (getRange happy_var_2) happy_var_2); + return LamClause{ lamLHS = p [] [] + , lamRHS = AbsurdRHS + , lamWhere = NoWhere + , lamCatchAll = True })}) + ) (\r -> happyReturn (happyIn75 r)) + +happyReduce_284 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_284 = happySpecReduce_1 66# happyReduction_284 +happyReduction_284 happy_x_1 + = case happyOut74 happy_x_1 of { (HappyWrap74 happy_var_1) -> + happyIn76 + (happy_var_1 + )} + +happyReduce_285 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_285 = happySpecReduce_1 66# happyReduction_285 +happyReduction_285 happy_x_1 + = case happyOut75 happy_x_1 of { (HappyWrap75 happy_var_1) -> + happyIn76 + (happy_var_1 + )} + +happyReduce_286 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_286 = happySpecReduce_3 67# happyReduction_286 +happyReduction_286 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut77 happy_x_1 of { (HappyWrap77 happy_var_1) -> + case happyOut76 happy_x_3 of { (HappyWrap76 happy_var_3) -> + happyIn77 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_287 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_287 = happySpecReduce_3 67# happyReduction_287 +happyReduction_287 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut75 happy_x_1 of { (HappyWrap75 happy_var_1) -> + case happyOut76 happy_x_3 of { (HappyWrap76 happy_var_3) -> + happyIn77 + ([happy_var_3, happy_var_1] + )}} + +happyReduce_288 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_288 = happySpecReduce_1 67# happyReduction_288 +happyReduction_288 happy_x_1 + = case happyOut74 happy_x_1 of { (HappyWrap74 happy_var_1) -> + happyIn77 + ([happy_var_1] + )} + +happyReduce_289 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_289 = happySpecReduce_3 68# happyReduction_289 +happyReduction_289 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut78 happy_x_1 of { (HappyWrap78 happy_var_1) -> + case happyOut76 happy_x_3 of { (HappyWrap76 happy_var_3) -> + happyIn78 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_290 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_290 = happySpecReduce_1 68# happyReduction_290 +happyReduction_290 happy_x_1 + = case happyOut76 happy_x_1 of { (HappyWrap76 happy_var_1) -> + happyIn78 + ([happy_var_1] + )} + +happyReduce_291 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_291 = happySpecReduce_2 69# happyReduction_291 +happyReduction_291 happy_x_2 + happy_x_1 + = case happyOut80 happy_x_1 of { (HappyWrap80 happy_var_1) -> + happyIn79 + (happy_var_1 + )} + +happyReduce_292 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_292 = happySpecReduce_2 70# happyReduction_292 +happyReduction_292 happy_x_2 + happy_x_1 + = case happyOut82 happy_x_1 of { (HappyWrap82 happy_var_1) -> + case happyOut80 happy_x_2 of { (HappyWrap80 happy_var_2) -> + happyIn80 + (happy_var_1 ++ happy_var_2 + )}} + +happyReduce_293 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_293 = happySpecReduce_2 70# happyReduction_293 +happyReduction_293 happy_x_2 + happy_x_1 + = case happyOut65 happy_x_1 of { (HappyWrap65 happy_var_1) -> + case happyOut80 happy_x_2 of { (HappyWrap80 happy_var_2) -> + happyIn80 + (DomainFull happy_var_1 : happy_var_2 + )}} + +happyReduce_294 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_294 = happySpecReduce_1 70# happyReduction_294 +happyReduction_294 happy_x_1 + = case happyOut82 happy_x_1 of { (HappyWrap82 happy_var_1) -> + happyIn80 + (happy_var_1 + )} + +happyReduce_295 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_295 = happySpecReduce_1 70# happyReduction_295 +happyReduction_295 happy_x_1 + = case happyOut65 happy_x_1 of { (HappyWrap65 happy_var_1) -> + happyIn80 + ([DomainFull happy_var_1] + )} + +happyReduce_296 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_296 = happySpecReduce_2 71# happyReduction_296 +happyReduction_296 happy_x_2 + happy_x_1 + = case happyOut82 happy_x_1 of { (HappyWrap82 happy_var_1) -> + case happyOut81 happy_x_2 of { (HappyWrap81 happy_var_2) -> + happyIn81 + (happy_var_1 ++ happy_var_2 + )}} + +happyReduce_297 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_297 = happySpecReduce_2 71# happyReduction_297 +happyReduction_297 happy_x_2 + happy_x_1 + = case happyOut65 happy_x_1 of { (HappyWrap65 happy_var_1) -> + case happyOut81 happy_x_2 of { (HappyWrap81 happy_var_2) -> + happyIn81 + (DomainFull happy_var_1 : happy_var_2 + )}} + +happyReduce_298 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_298 = happySpecReduce_0 71# happyReduction_298 +happyReduction_298 = happyIn81 + ([] + ) + +happyReduce_299 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_299 = happyMonadReduce 1# 72# happyReduction_299 +happyReduction_299 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut84 happy_x_1 of { (HappyWrap84 happy_var_1) -> + ( case happy_var_1 of + Left lbs -> return lbs + Right _ -> parseError "expected sequence of bound identifiers, not absurd pattern")}) + ) (\r -> happyReturn (happyIn82 r)) + +happyReduce_300 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_300 = happyMonadReduce 2# 73# happyReduction_300 +happyReduction_300 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut54 happy_x_2 of { (HappyWrap54 happy_var_2) -> + ( fmap Just (exprToPattern happy_var_2))}) + ) (\r -> happyReturn (happyIn83 r)) + +happyReduce_301 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_301 = happySpecReduce_0 73# happyReduction_301 +happyReduction_301 = happyIn83 + (Nothing + ) + +happyReduce_302 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_302 = happySpecReduce_2 74# happyReduction_302 +happyReduction_302 happy_x_2 + happy_x_1 + = case happyOut31 happy_x_1 of { (HappyWrap31 happy_var_1) -> + case happyOut83 happy_x_2 of { (HappyWrap83 happy_var_2) -> + happyIn84 + (Left [mkDomainFree_ id happy_var_2 happy_var_1] + )}} + +happyReduce_303 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_303 = happySpecReduce_3 74# happyReduction_303 +happyReduction_303 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut31 happy_x_2 of { (HappyWrap31 happy_var_2) -> + case happyOut83 happy_x_3 of { (HappyWrap83 happy_var_3) -> + happyIn84 + (Left [mkDomainFree_ (setRelevance Irrelevant) happy_var_3 happy_var_2] + )}} + +happyReduce_304 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_304 = happySpecReduce_3 74# happyReduction_304 +happyReduction_304 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut31 happy_x_2 of { (HappyWrap31 happy_var_2) -> + case happyOut83 happy_x_3 of { (HappyWrap83 happy_var_3) -> + happyIn84 + (Left [mkDomainFree_ (setRelevance NonStrict) happy_var_3 happy_var_2] + )}} + +happyReduce_305 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_305 = happyMonadReduce 3# 74# happyReduction_305 +happyReduction_305 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut45 happy_x_2 of { (HappyWrap45 happy_var_2) -> + ( exprToPattern (RawApp (getRange happy_var_2) happy_var_2) >>= \ p -> + pure $ Left [mkDomainFree_ id (Just p) (Name noRange InScope [Hole])])}) + ) (\r -> happyReturn (happyIn84 r)) + +happyReduce_306 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_306 = happyMonadReduce 4# 74# happyReduction_306 +happyReduction_306 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut28 happy_x_2 of { (HappyWrap28 happy_var_2) -> + case happyOut34 happy_x_3 of { (HappyWrap34 happy_var_3) -> + ( applyAttrs happy_var_2 defaultArgInfo <&> \ ai -> + mapLeft (map (DomainFree . setTacticAttr happy_var_2 . setArgInfo ai)) happy_var_3)}}) + ) (\r -> happyReturn (happyIn84 r)) + +happyReduce_307 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_307 = happySpecReduce_3 74# happyReduction_307 +happyReduction_307 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut34 happy_x_2 of { (HappyWrap34 happy_var_2) -> + happyIn84 + (mapLeft (map (DomainFree . hide)) happy_var_2 + )} + +happyReduce_308 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_308 = happyMonadReduce 4# 74# happyReduction_308 +happyReduction_308 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut28 happy_x_2 of { (HappyWrap28 happy_var_2) -> + case happyOut34 happy_x_3 of { (HappyWrap34 happy_var_3) -> + ( applyAttrs happy_var_2 defaultArgInfo <&> \ ai -> + mapLeft (map (DomainFree . hide . setTacticAttr happy_var_2 . setArgInfo ai)) happy_var_3)}}) + ) (\r -> happyReturn (happyIn84 r)) + +happyReduce_309 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_309 = happySpecReduce_3 74# happyReduction_309 +happyReduction_309 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut33 happy_x_2 of { (HappyWrap33 happy_var_2) -> + happyIn84 + (Left $ map (DomainFree . makeInstance) happy_var_2 + )} + +happyReduce_310 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_310 = happyMonadReduce 4# 74# happyReduction_310 +happyReduction_310 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut28 happy_x_2 of { (HappyWrap28 happy_var_2) -> + case happyOut33 happy_x_3 of { (HappyWrap33 happy_var_3) -> + ( applyAttrs happy_var_2 defaultArgInfo <&> \ ai -> + Left $ map (DomainFree . makeInstance . setTacticAttr happy_var_2 . setArgInfo ai) happy_var_3)}}) + ) (\r -> happyReturn (happyIn84 r)) + +happyReduce_311 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_311 = happyReduce 4# 74# happyReduction_311 +happyReduction_311 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut33 happy_x_3 of { (HappyWrap33 happy_var_3) -> + happyIn84 + (Left $ map (DomainFree . hide . setRelevance Irrelevant) happy_var_3 + ) `HappyStk` happyRest} + +happyReduce_312 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_312 = happyReduce 4# 74# happyReduction_312 +happyReduction_312 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut33 happy_x_3 of { (HappyWrap33 happy_var_3) -> + happyIn84 + (Left $ map (DomainFree . makeInstance . setRelevance Irrelevant) happy_var_3 + ) `HappyStk` happyRest} + +happyReduce_313 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_313 = happyReduce 4# 74# happyReduction_313 +happyReduction_313 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut33 happy_x_3 of { (HappyWrap33 happy_var_3) -> + happyIn84 + (Left $ map (DomainFree . hide . setRelevance NonStrict) happy_var_3 + ) `HappyStk` happyRest} + +happyReduce_314 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_314 = happyReduce 4# 74# happyReduction_314 +happyReduction_314 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut33 happy_x_3 of { (HappyWrap33 happy_var_3) -> + happyIn84 + (Left $ map (DomainFree . makeInstance . setRelevance NonStrict) happy_var_3 + ) `HappyStk` happyRest} + +happyReduce_315 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_315 = happySpecReduce_1 75# happyReduction_315 +happyReduction_315 happy_x_1 + = case happyOut86 happy_x_1 of { (HappyWrap86 happy_var_1) -> + happyIn85 + ([happy_var_1] + )} + +happyReduce_316 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_316 = happySpecReduce_2 75# happyReduction_316 +happyReduction_316 happy_x_2 + happy_x_1 + = case happyOut86 happy_x_1 of { (HappyWrap86 happy_var_1) -> + happyIn85 + ([happy_var_1] + )} + +happyReduce_317 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_317 = happySpecReduce_3 75# happyReduction_317 +happyReduction_317 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut86 happy_x_1 of { (HappyWrap86 happy_var_1) -> + case happyOut85 happy_x_3 of { (HappyWrap85 happy_var_3) -> + happyIn85 + (happy_var_1 : happy_var_3 + )}} + +happyReduce_318 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_318 = happyMonadReduce 2# 76# happyReduction_318 +happyReduction_318 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut42 happy_x_1 of { (HappyWrap42 happy_var_1) -> + case happyOut87 happy_x_2 of { (HappyWrap87 happy_var_2) -> + ( buildDoStmt happy_var_1 happy_var_2)}}) + ) (\r -> happyReturn (happyIn86 r)) + +happyReduce_319 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_319 = happySpecReduce_0 77# happyReduction_319 +happyReduction_319 = happyIn87 + ([] + ) + +happyReduce_320 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_320 = happyReduce 4# 77# happyReduction_320 +happyReduction_320 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut78 happy_x_3 of { (HappyWrap78 happy_var_3) -> + happyIn87 + (reverse happy_var_3 + ) `HappyStk` happyRest} + +happyReduce_321 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_321 = happyMonadReduce 1# 78# happyReduction_321 +happyReduction_321 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut89 happy_x_1 of { (HappyWrap89 happy_var_1) -> + ( mergeImportDirectives happy_var_1)}) + ) (\r -> happyReturn (happyIn88 r)) + +happyReduce_322 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_322 = happySpecReduce_2 79# happyReduction_322 +happyReduction_322 happy_x_2 + happy_x_1 + = case happyOut90 happy_x_1 of { (HappyWrap90 happy_var_1) -> + case happyOut89 happy_x_2 of { (HappyWrap89 happy_var_2) -> + happyIn89 + (happy_var_1 : happy_var_2 + )}} + +happyReduce_323 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_323 = happySpecReduce_0 79# happyReduction_323 +happyReduction_323 = happyIn89 + ([] + ) + +happyReduce_324 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_324 = happySpecReduce_1 80# happyReduction_324 +happyReduction_324 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwPublic happy_var_1) -> + happyIn90 + (defaultImportDir { importDirRange = getRange happy_var_1, publicOpen = Just (getRange happy_var_1) } + )} + +happyReduce_325 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_325 = happySpecReduce_1 80# happyReduction_325 +happyReduction_325 happy_x_1 + = case happyOut91 happy_x_1 of { (HappyWrap91 happy_var_1) -> + happyIn90 + (defaultImportDir { importDirRange = snd happy_var_1, using = fst happy_var_1 } + )} + +happyReduce_326 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_326 = happySpecReduce_1 80# happyReduction_326 +happyReduction_326 happy_x_1 + = case happyOut92 happy_x_1 of { (HappyWrap92 happy_var_1) -> + happyIn90 + (defaultImportDir { importDirRange = snd happy_var_1, hiding = fst happy_var_1 } + )} + +happyReduce_327 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_327 = happySpecReduce_1 80# happyReduction_327 +happyReduction_327 happy_x_1 + = case happyOut93 happy_x_1 of { (HappyWrap93 happy_var_1) -> + happyIn90 + (defaultImportDir { importDirRange = snd happy_var_1, impRenaming = fst happy_var_1 } + )} + +happyReduce_328 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_328 = happyReduce 4# 81# happyReduction_328 +happyReduction_328 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOutTok happy_x_1 of { (TokKeyword KwUsing happy_var_1) -> + case happyOutTok happy_x_2 of { (TokSymbol SymOpenParen happy_var_2) -> + case happyOut99 happy_x_3 of { (HappyWrap99 happy_var_3) -> + case happyOutTok happy_x_4 of { (TokSymbol SymCloseParen happy_var_4) -> + happyIn91 + ((Using happy_var_3 , getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4)) + ) `HappyStk` happyRest}}}} + +happyReduce_329 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_329 = happyReduce 4# 82# happyReduction_329 +happyReduction_329 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOutTok happy_x_1 of { (TokKeyword KwHiding happy_var_1) -> + case happyOutTok happy_x_2 of { (TokSymbol SymOpenParen happy_var_2) -> + case happyOut99 happy_x_3 of { (HappyWrap99 happy_var_3) -> + case happyOutTok happy_x_4 of { (TokSymbol SymCloseParen happy_var_4) -> + happyIn92 + ((happy_var_3 , getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4)) + ) `HappyStk` happyRest}}}} + +happyReduce_330 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_330 = happyReduce 4# 83# happyReduction_330 +happyReduction_330 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOutTok happy_x_1 of { (TokKeyword KwRenaming happy_var_1) -> + case happyOutTok happy_x_2 of { (TokSymbol SymOpenParen happy_var_2) -> + case happyOut94 happy_x_3 of { (HappyWrap94 happy_var_3) -> + case happyOutTok happy_x_4 of { (TokSymbol SymCloseParen happy_var_4) -> + happyIn93 + ((happy_var_3 , getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4)) + ) `HappyStk` happyRest}}}} + +happyReduce_331 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_331 = happySpecReduce_3 83# happyReduction_331 +happyReduction_331 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwRenaming happy_var_1) -> + case happyOutTok happy_x_2 of { (TokSymbol SymOpenParen happy_var_2) -> + case happyOutTok happy_x_3 of { (TokSymbol SymCloseParen happy_var_3) -> + happyIn93 + (([] , getRange (happy_var_1,happy_var_2,happy_var_3)) + )}}} + +happyReduce_332 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_332 = happySpecReduce_3 84# happyReduction_332 +happyReduction_332 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut95 happy_x_1 of { (HappyWrap95 happy_var_1) -> + case happyOut94 happy_x_3 of { (HappyWrap94 happy_var_3) -> + happyIn94 + (happy_var_1 : happy_var_3 + )}} + +happyReduce_333 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_333 = happySpecReduce_1 84# happyReduction_333 +happyReduction_333 happy_x_1 + = case happyOut95 happy_x_1 of { (HappyWrap95 happy_var_1) -> + happyIn94 + ([happy_var_1] + )} + +happyReduce_334 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_334 = happySpecReduce_3 85# happyReduction_334 +happyReduction_334 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut97 happy_x_1 of { (HappyWrap97 happy_var_1) -> + case happyOutTok happy_x_2 of { (TokKeyword KwTo happy_var_2) -> + case happyOut96 happy_x_3 of { (HappyWrap96 happy_var_3) -> + happyIn95 + (Renaming happy_var_1 (setImportedName happy_var_1 (snd happy_var_3)) (fst happy_var_3) (getRange happy_var_2) + )}}} + +happyReduce_335 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_335 = happySpecReduce_1 86# happyReduction_335 +happyReduction_335 happy_x_1 + = case happyOut19 happy_x_1 of { (HappyWrap19 happy_var_1) -> + happyIn96 + ((Nothing, happy_var_1) + )} + +happyReduce_336 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_336 = happySpecReduce_3 86# happyReduction_336 +happyReduction_336 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwInfix happy_var_1) -> + case happyOut18 happy_x_2 of { (HappyWrap18 happy_var_2) -> + case happyOut19 happy_x_3 of { (HappyWrap19 happy_var_3) -> + happyIn96 + ((Just (Fixity (getRange (happy_var_1,happy_var_2)) (Related $ rangedThing happy_var_2) NonAssoc) , happy_var_3) + )}}} + +happyReduce_337 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_337 = happySpecReduce_3 86# happyReduction_337 +happyReduction_337 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwInfixL happy_var_1) -> + case happyOut18 happy_x_2 of { (HappyWrap18 happy_var_2) -> + case happyOut19 happy_x_3 of { (HappyWrap19 happy_var_3) -> + happyIn96 + ((Just (Fixity (getRange (happy_var_1,happy_var_2)) (Related $ rangedThing happy_var_2) LeftAssoc) , happy_var_3) + )}}} + +happyReduce_338 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_338 = happySpecReduce_3 86# happyReduction_338 +happyReduction_338 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwInfixR happy_var_1) -> + case happyOut18 happy_x_2 of { (HappyWrap18 happy_var_2) -> + case happyOut19 happy_x_3 of { (HappyWrap19 happy_var_3) -> + happyIn96 + ((Just (Fixity (getRange (happy_var_1,happy_var_2)) (Related $ rangedThing happy_var_2) RightAssoc), happy_var_3) + )}}} + +happyReduce_339 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_339 = happySpecReduce_2 87# happyReduction_339 +happyReduction_339 happy_x_2 + happy_x_1 + = case happyOut19 happy_x_2 of { (HappyWrap19 happy_var_2) -> + happyIn97 + (ImportedName happy_var_2 + )} + +happyReduce_340 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_340 = happySpecReduce_3 87# happyReduction_340 +happyReduction_340 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut19 happy_x_3 of { (HappyWrap19 happy_var_3) -> + happyIn97 + (ImportedModule happy_var_3 + )} + +happyReduce_341 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_341 = happySpecReduce_1 88# happyReduction_341 +happyReduction_341 happy_x_1 + = case happyOut19 happy_x_1 of { (HappyWrap19 happy_var_1) -> + happyIn98 + (ImportedName happy_var_1 + )} + +happyReduce_342 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_342 = happySpecReduce_2 88# happyReduction_342 +happyReduction_342 happy_x_2 + happy_x_1 + = case happyOut19 happy_x_2 of { (HappyWrap19 happy_var_2) -> + happyIn98 + (ImportedModule happy_var_2 + )} + +happyReduce_343 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_343 = happySpecReduce_0 89# happyReduction_343 +happyReduction_343 = happyIn99 + ([] + ) + +happyReduce_344 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_344 = happySpecReduce_1 89# happyReduction_344 +happyReduction_344 happy_x_1 + = case happyOut100 happy_x_1 of { (HappyWrap100 happy_var_1) -> + happyIn99 + (happy_var_1 + )} + +happyReduce_345 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_345 = happySpecReduce_1 90# happyReduction_345 +happyReduction_345 happy_x_1 + = case happyOut98 happy_x_1 of { (HappyWrap98 happy_var_1) -> + happyIn100 + ([happy_var_1] + )} + +happyReduce_346 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_346 = happySpecReduce_3 90# happyReduction_346 +happyReduction_346 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut98 happy_x_1 of { (HappyWrap98 happy_var_1) -> + case happyOut100 happy_x_3 of { (HappyWrap100 happy_var_3) -> + happyIn100 + (happy_var_1 : happy_var_3 + )}} + +happyReduce_347 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_347 = happyMonadReduce 2# 91# happyReduction_347 +happyReduction_347 (happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut43 happy_x_1 of { (HappyWrap43 happy_var_1) -> + case happyOut102 happy_x_2 of { (HappyWrap102 happy_var_2) -> + ( exprToLHS happy_var_1 >>= \p -> + buildWithBlock happy_var_2 >>= \ (rs, es) -> + return (p rs $ map observeHiding es))}}) + ) (\r -> happyReturn (happyIn101 r)) + +happyReduce_348 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_348 = happySpecReduce_0 92# happyReduction_348 +happyReduction_348 = happyIn102 + ([] + ) + +happyReduce_349 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_349 = happyMonadReduce 3# 92# happyReduction_349 +happyReduction_349 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut43 happy_x_2 of { (HappyWrap43 happy_var_2) -> + case happyOut102 happy_x_3 of { (HappyWrap102 happy_var_3) -> + ( fmap (++ happy_var_3) (buildWithStmt happy_var_2))}}) + ) (\r -> happyReturn (happyIn102 r)) + +happyReduce_350 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_350 = happySpecReduce_3 92# happyReduction_350 +happyReduction_350 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut43 happy_x_2 of { (HappyWrap43 happy_var_2) -> + case happyOut102 happy_x_3 of { (HappyWrap102 happy_var_3) -> + happyIn102 + (Left (Rewrite $ fmap ((),) (fromWithApp happy_var_2)) : happy_var_3 + )}} + +happyReduce_351 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_351 = happySpecReduce_1 93# happyReduction_351 +happyReduction_351 happy_x_1 + = case happyOut42 happy_x_1 of { (HappyWrap42 happy_var_1) -> + happyIn103 + (HoleContentExpr happy_var_1 + )} + +happyReduce_352 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_352 = happyMonadReduce 1# 93# happyReduction_352 +happyReduction_352 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut102 happy_x_1 of { (HappyWrap102 happy_var_1) -> + ( fmap HoleContentRewrite $ forM happy_var_1 $ \case + Left r -> pure r + Right{} -> parseError "Cannot declare a 'with' abstraction from inside a hole.")}) + ) (\r -> happyReturn (happyIn103 r)) + +happyReduce_353 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_353 = happySpecReduce_0 94# happyReduction_353 +happyReduction_353 = happyIn104 + (NoWhere + ) + +happyReduce_354 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_354 = happySpecReduce_2 94# happyReduction_354 +happyReduction_354 happy_x_2 + happy_x_1 + = case happyOut184 happy_x_2 of { (HappyWrap184 happy_var_2) -> + happyIn104 + (AnyWhere happy_var_2 + )} + +happyReduce_355 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_355 = happyReduce 4# 94# happyReduction_355 +happyReduction_355 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut19 happy_x_2 of { (HappyWrap19 happy_var_2) -> + case happyOut184 happy_x_4 of { (HappyWrap184 happy_var_4) -> + happyIn104 + (SomeWhere happy_var_2 PublicAccess happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_356 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_356 = happyReduce 4# 94# happyReduction_356 +happyReduction_356 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut142 happy_x_2 of { (HappyWrap142 happy_var_2) -> + case happyOut184 happy_x_4 of { (HappyWrap184 happy_var_4) -> + happyIn104 + (SomeWhere happy_var_2 PublicAccess happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_357 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_357 = happySpecReduce_2 95# happyReduction_357 +happyReduction_357 happy_x_2 + happy_x_1 + = case happyOut42 happy_x_1 of { (HappyWrap42 happy_var_1) -> + case happyOut104 happy_x_2 of { (HappyWrap104 happy_var_2) -> + happyIn105 + (ExprWhere happy_var_1 happy_var_2 + )}} + +happyReduce_358 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_358 = happySpecReduce_1 96# happyReduction_358 +happyReduction_358 happy_x_1 + = case happyOut117 happy_x_1 of { (HappyWrap117 happy_var_1) -> + happyIn106 + ([happy_var_1] + )} + +happyReduce_359 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_359 = happySpecReduce_1 96# happyReduction_359 +happyReduction_359 happy_x_1 + = case happyOut109 happy_x_1 of { (HappyWrap109 happy_var_1) -> + happyIn106 + (happy_var_1 + )} + +happyReduce_360 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_360 = happySpecReduce_1 96# happyReduction_360 +happyReduction_360 happy_x_1 + = case happyOut111 happy_x_1 of { (HappyWrap111 happy_var_1) -> + happyIn106 + ([happy_var_1] + )} + +happyReduce_361 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_361 = happySpecReduce_1 96# happyReduction_361 +happyReduction_361 happy_x_1 + = case happyOut112 happy_x_1 of { (HappyWrap112 happy_var_1) -> + happyIn106 + ([happy_var_1] + )} + +happyReduce_362 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_362 = happySpecReduce_1 96# happyReduction_362 +happyReduction_362 happy_x_1 + = case happyOut113 happy_x_1 of { (HappyWrap113 happy_var_1) -> + happyIn106 + ([happy_var_1] + )} + +happyReduce_363 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_363 = happySpecReduce_1 96# happyReduction_363 +happyReduction_363 happy_x_1 + = case happyOut114 happy_x_1 of { (HappyWrap114 happy_var_1) -> + happyIn106 + ([happy_var_1] + )} + +happyReduce_364 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_364 = happySpecReduce_1 96# happyReduction_364 +happyReduction_364 happy_x_1 + = case happyOut116 happy_x_1 of { (HappyWrap116 happy_var_1) -> + happyIn106 + ([happy_var_1] + )} + +happyReduce_365 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_365 = happySpecReduce_1 96# happyReduction_365 +happyReduction_365 happy_x_1 + = case happyOut118 happy_x_1 of { (HappyWrap118 happy_var_1) -> + happyIn106 + (happy_var_1 + )} + +happyReduce_366 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_366 = happySpecReduce_1 96# happyReduction_366 +happyReduction_366 happy_x_1 + = case happyOut119 happy_x_1 of { (HappyWrap119 happy_var_1) -> + happyIn106 + ([happy_var_1] + )} + +happyReduce_367 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_367 = happySpecReduce_1 96# happyReduction_367 +happyReduction_367 happy_x_1 + = case happyOut120 happy_x_1 of { (HappyWrap120 happy_var_1) -> + happyIn106 + ([happy_var_1] + )} + +happyReduce_368 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_368 = happySpecReduce_1 96# happyReduction_368 +happyReduction_368 happy_x_1 + = case happyOut121 happy_x_1 of { (HappyWrap121 happy_var_1) -> + happyIn106 + ([happy_var_1] + )} + +happyReduce_369 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_369 = happySpecReduce_1 96# happyReduction_369 +happyReduction_369 happy_x_1 + = case happyOut122 happy_x_1 of { (HappyWrap122 happy_var_1) -> + happyIn106 + ([happy_var_1] + )} + +happyReduce_370 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_370 = happySpecReduce_1 96# happyReduction_370 +happyReduction_370 happy_x_1 + = case happyOut123 happy_x_1 of { (HappyWrap123 happy_var_1) -> + happyIn106 + ([happy_var_1] + )} + +happyReduce_371 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_371 = happySpecReduce_1 96# happyReduction_371 +happyReduction_371 happy_x_1 + = case happyOut124 happy_x_1 of { (HappyWrap124 happy_var_1) -> + happyIn106 + ([happy_var_1] + )} + +happyReduce_372 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_372 = happySpecReduce_1 96# happyReduction_372 +happyReduction_372 happy_x_1 + = case happyOut125 happy_x_1 of { (HappyWrap125 happy_var_1) -> + happyIn106 + ([happy_var_1] + )} + +happyReduce_373 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_373 = happySpecReduce_1 96# happyReduction_373 +happyReduction_373 happy_x_1 + = case happyOut137 happy_x_1 of { (HappyWrap137 happy_var_1) -> + happyIn106 + (happy_var_1 + )} + +happyReduce_374 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_374 = happySpecReduce_1 96# happyReduction_374 +happyReduction_374 happy_x_1 + = case happyOut140 happy_x_1 of { (HappyWrap140 happy_var_1) -> + happyIn106 + ([happy_var_1] + )} + +happyReduce_375 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_375 = happySpecReduce_1 96# happyReduction_375 +happyReduction_375 happy_x_1 + = case happyOut141 happy_x_1 of { (HappyWrap141 happy_var_1) -> + happyIn106 + ([happy_var_1] + )} + +happyReduce_376 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_376 = happySpecReduce_1 96# happyReduction_376 +happyReduction_376 happy_x_1 + = case happyOut144 happy_x_1 of { (HappyWrap144 happy_var_1) -> + happyIn106 + ([happy_var_1] + )} + +happyReduce_377 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_377 = happySpecReduce_1 96# happyReduction_377 +happyReduction_377 happy_x_1 + = case happyOut127 happy_x_1 of { (HappyWrap127 happy_var_1) -> + happyIn106 + ([happy_var_1] + )} + +happyReduce_378 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_378 = happySpecReduce_1 96# happyReduction_378 +happyReduction_378 happy_x_1 + = case happyOut128 happy_x_1 of { (HappyWrap128 happy_var_1) -> + happyIn106 + ([happy_var_1] + )} + +happyReduce_379 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_379 = happySpecReduce_1 96# happyReduction_379 +happyReduction_379 happy_x_1 + = case happyOut126 happy_x_1 of { (HappyWrap126 happy_var_1) -> + happyIn106 + ([happy_var_1] + )} + +happyReduce_380 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_380 = happySpecReduce_3 97# happyReduction_380 +happyReduction_380 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut20 happy_x_1 of { (HappyWrap20 happy_var_1) -> + case happyOut42 happy_x_3 of { (HappyWrap42 happy_var_3) -> + happyIn107 + (map (\ x -> typeSig defaultArgInfo Nothing x happy_var_3) happy_var_1 + )}} + +happyReduce_381 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_381 = happySpecReduce_3 98# happyReduction_381 +happyReduction_381 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut25 happy_x_1 of { (HappyWrap25 happy_var_1) -> + case happyOut42 happy_x_3 of { (HappyWrap42 happy_var_3) -> + happyIn108 + (let (attrs, xs) = happy_var_1 in + map (fmap (\ x -> typeSig defaultArgInfo (getTacticAttr attrs) x happy_var_3)) xs + )}} + +happyReduce_382 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_382 = happyMonadReduce 4# 98# happyReduction_382 +happyReduction_382 (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 { (TokKeyword KwOverlap happy_var_1) -> + case happyOut25 happy_x_2 of { (HappyWrap25 happy_var_2) -> + case happyOut42 happy_x_4 of { (HappyWrap42 happy_var_4) -> + ( + let (attrs, xs) = happy_var_2 + setOverlap x = + case getHiding x of + Instance _ -> return $ makeInstance' YesOverlap x + _ -> parseErrorRange happy_var_1 + "The 'overlap' keyword only applies to instance fields (fields marked with {{ }})" + in T.traverse (setOverlap . fmap (\ x -> typeSig defaultArgInfo (getTacticAttr attrs) x happy_var_4)) xs)}}}) + ) (\r -> happyReturn (happyIn108 r)) + +happyReduce_383 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_383 = happySpecReduce_2 98# happyReduction_383 +happyReduction_383 happy_x_2 + happy_x_1 + = case happyOut174 happy_x_2 of { (HappyWrap174 happy_var_2) -> + happyIn108 + (let + setInstance (TypeSig info tac x t) = TypeSig (makeInstance info) tac x t + setInstance _ = __IMPOSSIBLE__ in + map (fmap setInstance) happy_var_2 + )} + +happyReduce_384 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_384 = happyMonadReduce 3# 99# happyReduction_384 +happyReduction_384 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut101 happy_x_1 of { (HappyWrap101 happy_var_1) -> + case happyOut110 happy_x_2 of { (HappyWrap110 happy_var_2) -> + case happyOut104 happy_x_3 of { (HappyWrap104 happy_var_3) -> + ( funClauseOrTypeSigs [] happy_var_1 happy_var_2 happy_var_3)}}}) + ) (\r -> happyReturn (happyIn109 r)) + +happyReduce_385 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_385 = happyMonadReduce 4# 99# happyReduction_385 +happyReduction_385 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut28 happy_x_1 of { (HappyWrap28 happy_var_1) -> + case happyOut101 happy_x_2 of { (HappyWrap101 happy_var_2) -> + case happyOut110 happy_x_3 of { (HappyWrap110 happy_var_3) -> + case happyOut104 happy_x_4 of { (HappyWrap104 happy_var_4) -> + ( funClauseOrTypeSigs happy_var_1 happy_var_2 happy_var_3 happy_var_4)}}}}) + ) (\r -> happyReturn (happyIn109 r)) + +happyReduce_386 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_386 = happySpecReduce_2 100# happyReduction_386 +happyReduction_386 happy_x_2 + happy_x_1 + = case happyOut42 happy_x_2 of { (HappyWrap42 happy_var_2) -> + happyIn110 + (JustRHS (RHS happy_var_2) + )} + +happyReduce_387 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_387 = happySpecReduce_2 100# happyReduction_387 +happyReduction_387 happy_x_2 + happy_x_1 + = case happyOut42 happy_x_2 of { (HappyWrap42 happy_var_2) -> + happyIn110 + (TypeSigsRHS happy_var_2 + )} + +happyReduce_388 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_388 = happySpecReduce_0 100# happyReduction_388 +happyReduction_388 = happyIn110 + (JustRHS AbsurdRHS + ) + +happyReduce_389 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_389 = happyReduce 7# 101# happyReduction_389 +happyReduction_389 (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 { (TokKeyword KwData happy_var_1) -> + case happyOut19 happy_x_2 of { (HappyWrap19 happy_var_2) -> + case happyOut81 happy_x_3 of { (HappyWrap81 happy_var_3) -> + case happyOutTok happy_x_4 of { (TokSymbol SymColon happy_var_4) -> + case happyOut42 happy_x_5 of { (HappyWrap42 happy_var_5) -> + case happyOutTok happy_x_6 of { (TokKeyword KwWhere happy_var_6) -> + case happyOut184 happy_x_7 of { (HappyWrap184 happy_var_7) -> + happyIn111 + (Data (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4,happy_var_5,happy_var_6,happy_var_7)) happy_var_2 happy_var_3 happy_var_5 happy_var_7 + ) `HappyStk` happyRest}}}}}}} + +happyReduce_390 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_390 = happyReduce 5# 101# happyReduction_390 +happyReduction_390 (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 { (TokKeyword KwData happy_var_1) -> + case happyOut19 happy_x_2 of { (HappyWrap19 happy_var_2) -> + case happyOut81 happy_x_3 of { (HappyWrap81 happy_var_3) -> + case happyOutTok happy_x_4 of { (TokKeyword KwWhere happy_var_4) -> + case happyOut184 happy_x_5 of { (HappyWrap184 happy_var_5) -> + happyIn111 + (DataDef (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4,happy_var_5)) happy_var_2 happy_var_3 happy_var_5 + ) `HappyStk` happyRest}}}}} + +happyReduce_391 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_391 = happyReduce 5# 102# 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) + = case happyOutTok happy_x_1 of { (TokKeyword KwData happy_var_1) -> + case happyOut19 happy_x_2 of { (HappyWrap19 happy_var_2) -> + case happyOut81 happy_x_3 of { (HappyWrap81 happy_var_3) -> + case happyOutTok happy_x_4 of { (TokSymbol SymColon happy_var_4) -> + case happyOut42 happy_x_5 of { (HappyWrap42 happy_var_5) -> + happyIn112 + (DataSig (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4,happy_var_5)) happy_var_2 happy_var_3 happy_var_5 + ) `HappyStk` happyRest}}}}} + +happyReduce_392 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_392 = happyMonadReduce 7# 103# happyReduction_392 +happyReduction_392 (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 { (TokKeyword KwRecord happy_var_1) -> + case happyOut52 happy_x_2 of { (HappyWrap52 happy_var_2) -> + case happyOut81 happy_x_3 of { (HappyWrap81 happy_var_3) -> + case happyOutTok happy_x_4 of { (TokSymbol SymColon happy_var_4) -> + case happyOut42 happy_x_5 of { (HappyWrap42 happy_var_5) -> + case happyOutTok happy_x_6 of { (TokKeyword KwWhere happy_var_6) -> + case happyOut178 happy_x_7 of { (HappyWrap178 happy_var_7) -> + ( exprToName happy_var_2 >>= \ n -> let ((x,y,z),ds) = happy_var_7 in return $ Record (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4,happy_var_5,happy_var_6,happy_var_7)) n x y z happy_var_3 happy_var_5 ds)}}}}}}}) + ) (\r -> happyReturn (happyIn113 r)) + +happyReduce_393 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_393 = happyMonadReduce 5# 103# happyReduction_393 +happyReduction_393 (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 { (TokKeyword KwRecord happy_var_1) -> + case happyOut52 happy_x_2 of { (HappyWrap52 happy_var_2) -> + case happyOut81 happy_x_3 of { (HappyWrap81 happy_var_3) -> + case happyOutTok happy_x_4 of { (TokKeyword KwWhere happy_var_4) -> + case happyOut178 happy_x_5 of { (HappyWrap178 happy_var_5) -> + ( exprToName happy_var_2 >>= \ n -> let ((x,y,z),ds) = happy_var_5 in return $ RecordDef (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4,happy_var_5)) n x y z happy_var_3 ds)}}}}}) + ) (\r -> happyReturn (happyIn113 r)) + +happyReduce_394 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_394 = happyMonadReduce 5# 104# happyReduction_394 +happyReduction_394 (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 { (TokKeyword KwRecord happy_var_1) -> + case happyOut52 happy_x_2 of { (HappyWrap52 happy_var_2) -> + case happyOut81 happy_x_3 of { (HappyWrap81 happy_var_3) -> + case happyOutTok happy_x_4 of { (TokSymbol SymColon happy_var_4) -> + case happyOut42 happy_x_5 of { (HappyWrap42 happy_var_5) -> + ( exprToName happy_var_2 >>= \ n -> return $ RecordSig (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4,happy_var_5)) n happy_var_3 happy_var_5)}}}}}) + ) (\r -> happyReturn (happyIn114 r)) + +happyReduce_395 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_395 = happySpecReduce_2 105# happyReduction_395 +happyReduction_395 happy_x_2 + happy_x_1 + = case happyOut19 happy_x_2 of { (HappyWrap19 happy_var_2) -> + happyIn115 + ((happy_var_2, NotInstanceDef) + )} + +happyReduce_396 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_396 = happyReduce 5# 105# happyReduction_396 +happyReduction_396 (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 { (TokKeyword KwInstance happy_var_1) -> + case happyOut19 happy_x_4 of { (HappyWrap19 happy_var_4) -> + happyIn115 + ((happy_var_4, InstanceDef (getRange happy_var_1)) + ) `HappyStk` happyRest}} + +happyReduce_397 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_397 = happySpecReduce_3 106# happyReduction_397 +happyReduction_397 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwInfix happy_var_1) -> + case happyOut18 happy_x_2 of { (HappyWrap18 happy_var_2) -> + case happyOut32 happy_x_3 of { (HappyWrap32 happy_var_3) -> + happyIn116 + (Infix (Fixity (getRange (happy_var_1,happy_var_2,happy_var_3)) (Related $ rangedThing happy_var_2) NonAssoc) happy_var_3 + )}}} + +happyReduce_398 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_398 = happySpecReduce_3 106# happyReduction_398 +happyReduction_398 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwInfixL happy_var_1) -> + case happyOut18 happy_x_2 of { (HappyWrap18 happy_var_2) -> + case happyOut32 happy_x_3 of { (HappyWrap32 happy_var_3) -> + happyIn116 + (Infix (Fixity (getRange (happy_var_1,happy_var_2,happy_var_3)) (Related $ rangedThing happy_var_2) LeftAssoc) happy_var_3 + )}}} + +happyReduce_399 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_399 = happySpecReduce_3 106# happyReduction_399 +happyReduction_399 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwInfixR happy_var_1) -> + case happyOut18 happy_x_2 of { (HappyWrap18 happy_var_2) -> + case happyOut32 happy_x_3 of { (HappyWrap32 happy_var_3) -> + happyIn116 + (Infix (Fixity (getRange (happy_var_1,happy_var_2,happy_var_3)) (Related $ rangedThing happy_var_2) RightAssoc) happy_var_3 + )}}} + +happyReduce_400 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_400 = happySpecReduce_2 107# happyReduction_400 +happyReduction_400 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwField happy_var_1) -> + case happyOut176 happy_x_2 of { (HappyWrap176 happy_var_2) -> + happyIn117 + (let + inst i = case getHiding i of + Instance _ -> InstanceDef noRange -- no @instance@ keyword here + _ -> NotInstanceDef + toField (Arg info (TypeSig info' tac x t)) = FieldSig (inst info') tac x (Arg info t) + in Field (fuseRange happy_var_1 happy_var_2) $ map toField happy_var_2 + )}} + +happyReduce_401 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_401 = happySpecReduce_2 108# happyReduction_401 +happyReduction_401 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwVariable happy_var_1) -> + case happyOut176 happy_x_2 of { (HappyWrap176 happy_var_2) -> + happyIn118 + (let + toGeneralize (Arg info (TypeSig _ tac x t)) = TypeSig info tac x t + in [ Generalize (fuseRange happy_var_1 happy_var_2) (map toGeneralize happy_var_2) ] + )}} + +happyReduce_402 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_402 = happySpecReduce_2 109# happyReduction_402 +happyReduction_402 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwMutual happy_var_1) -> + case happyOut184 happy_x_2 of { (HappyWrap184 happy_var_2) -> + happyIn119 + (Mutual (fuseRange happy_var_1 happy_var_2) happy_var_2 + )}} + +happyReduce_403 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_403 = happySpecReduce_2 110# happyReduction_403 +happyReduction_403 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwAbstract happy_var_1) -> + case happyOut184 happy_x_2 of { (HappyWrap184 happy_var_2) -> + happyIn120 + (Abstract (fuseRange happy_var_1 happy_var_2) happy_var_2 + )}} + +happyReduce_404 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_404 = happySpecReduce_2 111# happyReduction_404 +happyReduction_404 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwPrivate happy_var_1) -> + case happyOut184 happy_x_2 of { (HappyWrap184 happy_var_2) -> + happyIn121 + (Private (fuseRange happy_var_1 happy_var_2) UserWritten happy_var_2 + )}} + +happyReduce_405 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_405 = happySpecReduce_2 112# happyReduction_405 +happyReduction_405 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwInstance happy_var_1) -> + case happyOut184 happy_x_2 of { (HappyWrap184 happy_var_2) -> + happyIn122 + (InstanceB (getRange happy_var_1) happy_var_2 + )}} + +happyReduce_406 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_406 = happySpecReduce_2 113# happyReduction_406 +happyReduction_406 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwMacro happy_var_1) -> + case happyOut184 happy_x_2 of { (HappyWrap184 happy_var_2) -> + happyIn123 + (Macro (fuseRange happy_var_1 happy_var_2) happy_var_2 + )}} + +happyReduce_407 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_407 = happySpecReduce_2 114# happyReduction_407 +happyReduction_407 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwPostulate happy_var_1) -> + case happyOut184 happy_x_2 of { (HappyWrap184 happy_var_2) -> + happyIn124 + (Postulate (fuseRange happy_var_1 happy_var_2) happy_var_2 + )}} + +happyReduce_408 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_408 = happySpecReduce_2 115# happyReduction_408 +happyReduction_408 happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwPrimitive happy_var_1) -> + case happyOut171 happy_x_2 of { (HappyWrap171 happy_var_2) -> + happyIn125 + (Primitive (fuseRange happy_var_1 happy_var_2) happy_var_2 + )}} + +happyReduce_409 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_409 = happySpecReduce_3 116# happyReduction_409 +happyReduction_409 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwUnquoteDecl happy_var_1) -> + case happyOut42 happy_x_3 of { (HappyWrap42 happy_var_3) -> + happyIn126 + (UnquoteDecl (fuseRange happy_var_1 happy_var_3) [] happy_var_3 + )}} + +happyReduce_410 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_410 = happyReduce 4# 116# happyReduction_410 +happyReduction_410 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOutTok happy_x_1 of { (TokKeyword KwUnquoteDecl happy_var_1) -> + case happyOut20 happy_x_2 of { (HappyWrap20 happy_var_2) -> + case happyOut42 happy_x_4 of { (HappyWrap42 happy_var_4) -> + happyIn126 + (UnquoteDecl (fuseRange happy_var_1 happy_var_4) happy_var_2 happy_var_4 + ) `HappyStk` happyRest}}} + +happyReduce_411 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_411 = happyReduce 4# 116# happyReduction_411 +happyReduction_411 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOutTok happy_x_1 of { (TokKeyword KwUnquoteDef happy_var_1) -> + case happyOut20 happy_x_2 of { (HappyWrap20 happy_var_2) -> + case happyOut42 happy_x_4 of { (HappyWrap42 happy_var_4) -> + happyIn126 + (UnquoteDef (fuseRange happy_var_1 happy_var_4) happy_var_2 happy_var_4 + ) `HappyStk` happyRest}}} + +happyReduce_412 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_412 = happyMonadReduce 5# 117# happyReduction_412 +happyReduction_412 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut19 happy_x_2 of { (HappyWrap19 happy_var_2) -> + case happyOut131 happy_x_3 of { (HappyWrap131 happy_var_3) -> + case happyOut130 happy_x_5 of { (HappyWrap130 happy_var_5) -> + ( + case happy_var_2 of + Name _ _ [_] -> case mkNotation happy_var_3 happy_var_5 of + Left err -> parseError $ "Malformed syntax declaration: " ++ err + Right n -> return $ Syntax happy_var_2 n + _ -> parseError "Syntax declarations are allowed only for simple names (without holes)")}}}) + ) (\r -> happyReturn (happyIn127 r)) + +happyReduce_413 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_413 = happyMonadReduce 5# 118# happyReduction_413 +happyReduction_413 (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 { (TokKeyword KwPatternSyn happy_var_1) -> + case happyOut19 happy_x_2 of { (HappyWrap19 happy_var_2) -> + case happyOut129 happy_x_3 of { (HappyWrap129 happy_var_3) -> + case happyOutTok happy_x_4 of { (TokSymbol SymEqual happy_var_4) -> + case happyOut42 happy_x_5 of { (HappyWrap42 happy_var_5) -> + ( do + p <- exprToPattern happy_var_5 + return (PatternSyn (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4,happy_var_5)) happy_var_2 happy_var_3 p))}}}}}) + ) (\r -> happyReturn (happyIn128 r)) + +happyReduce_414 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_414 = happySpecReduce_0 119# happyReduction_414 +happyReduction_414 = happyIn129 + ([] + ) + +happyReduce_415 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_415 = happyMonadReduce 1# 119# happyReduction_415 +happyReduction_415 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut72 happy_x_1 of { (HappyWrap72 happy_var_1) -> + ( patternSynArgs happy_var_1)}) + ) (\r -> happyReturn (happyIn129 r)) + +happyReduce_416 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_416 = happySpecReduce_1 120# happyReduction_416 +happyReduction_416 happy_x_1 + = case happyOut135 happy_x_1 of { (HappyWrap135 happy_var_1) -> + happyIn130 + ([happy_var_1] + )} + +happyReduce_417 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_417 = happySpecReduce_2 120# happyReduction_417 +happyReduction_417 happy_x_2 + happy_x_1 + = case happyOut130 happy_x_1 of { (HappyWrap130 happy_var_1) -> + case happyOut135 happy_x_2 of { (HappyWrap135 happy_var_2) -> + happyIn130 + (happy_var_1 ++ [happy_var_2] + )}} + +happyReduce_418 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_418 = happySpecReduce_1 121# happyReduction_418 +happyReduction_418 happy_x_1 + = case happyOut132 happy_x_1 of { (HappyWrap132 happy_var_1) -> + happyIn131 + ([happy_var_1] + )} + +happyReduce_419 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_419 = happySpecReduce_2 121# happyReduction_419 +happyReduction_419 happy_x_2 + happy_x_1 + = case happyOut131 happy_x_1 of { (HappyWrap131 happy_var_1) -> + case happyOut132 happy_x_2 of { (HappyWrap132 happy_var_2) -> + happyIn131 + (happy_var_1 ++ [happy_var_2] + )}} + +happyReduce_420 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_420 = happySpecReduce_1 122# happyReduction_420 +happyReduction_420 happy_x_1 + = case happyOut133 happy_x_1 of { (HappyWrap133 happy_var_1) -> + happyIn132 + (defaultNamedArg happy_var_1 + )} + +happyReduce_421 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_421 = happySpecReduce_3 122# happyReduction_421 +happyReduction_421 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut134 happy_x_2 of { (HappyWrap134 happy_var_2) -> + happyIn132 + (hide $ defaultNamedArg happy_var_2 + )} + +happyReduce_422 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_422 = happySpecReduce_3 122# happyReduction_422 +happyReduction_422 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut134 happy_x_2 of { (HappyWrap134 happy_var_2) -> + happyIn132 + (makeInstance $ defaultNamedArg happy_var_2 + )} + +happyReduce_423 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_423 = happyReduce 5# 122# 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) + = case happyOut135 happy_x_2 of { (HappyWrap135 happy_var_2) -> + case happyOut134 happy_x_4 of { (HappyWrap134 happy_var_4) -> + happyIn132 + (hide $ defaultArg $ userNamed happy_var_2 happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_424 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_424 = happyReduce 5# 122# happyReduction_424 +happyReduction_424 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut135 happy_x_2 of { (HappyWrap135 happy_var_2) -> + case happyOut134 happy_x_4 of { (HappyWrap134 happy_var_4) -> + happyIn132 + (makeInstance $ defaultArg $ userNamed happy_var_2 happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_425 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_425 = happySpecReduce_1 123# happyReduction_425 +happyReduction_425 happy_x_1 + = case happyOut135 happy_x_1 of { (HappyWrap135 happy_var_1) -> + happyIn133 + (ExprHole happy_var_1 + )} + +happyReduce_426 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_426 = happyReduce 6# 123# happyReduction_426 +happyReduction_426 (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 happyOut135 happy_x_3 of { (HappyWrap135 happy_var_3) -> + case happyOut135 happy_x_5 of { (HappyWrap135 happy_var_5) -> + happyIn133 + (LambdaHole happy_var_3 happy_var_5 + ) `HappyStk` happyRest}} + +happyReduce_427 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_427 = happyReduce 6# 123# happyReduction_427 +happyReduction_427 (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_3 of { (TokSymbol SymUnderscore happy_var_3) -> + case happyOut135 happy_x_5 of { (HappyWrap135 happy_var_5) -> + happyIn133 + (LambdaHole (Ranged (getRange happy_var_3) "_") happy_var_5 + ) `HappyStk` happyRest}} + +happyReduce_428 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_428 = happySpecReduce_1 124# happyReduction_428 +happyReduction_428 happy_x_1 + = case happyOut135 happy_x_1 of { (HappyWrap135 happy_var_1) -> + happyIn134 + (ExprHole happy_var_1 + )} + +happyReduce_429 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_429 = happyReduce 4# 124# happyReduction_429 +happyReduction_429 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut135 happy_x_2 of { (HappyWrap135 happy_var_2) -> + case happyOut135 happy_x_4 of { (HappyWrap135 happy_var_4) -> + happyIn134 + (LambdaHole happy_var_2 happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_430 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_430 = happyReduce 4# 124# happyReduction_430 +happyReduction_430 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOutTok happy_x_3 of { (TokSymbol SymArrow happy_var_3) -> + case happyOut135 happy_x_4 of { (HappyWrap135 happy_var_4) -> + happyIn134 + (LambdaHole (Ranged (getRange happy_var_3) "_") happy_var_4 + ) `HappyStk` happyRest}} + +happyReduce_431 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_431 = happySpecReduce_1 125# happyReduction_431 +happyReduction_431 happy_x_1 + = case happyOutTok happy_x_1 of { (TokId happy_var_1) -> + happyIn135 + (Ranged (getRange $ fst happy_var_1) (stringToRawName $ snd happy_var_1) + )} + +happyReduce_432 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_432 = happySpecReduce_1 126# happyReduction_432 +happyReduction_432 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwOpen happy_var_1) -> + happyIn136 + (Just (getRange happy_var_1) + )} + +happyReduce_433 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_433 = happySpecReduce_0 126# happyReduction_433 +happyReduction_433 = happyIn136 + (Nothing + ) + +happyReduce_434 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_434 = happyMonadReduce 5# 127# happyReduction_434 +happyReduction_434 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut136 happy_x_1 of { (HappyWrap136 happy_var_1) -> + case happyOutTok happy_x_2 of { (TokKeyword KwImport happy_var_2) -> + case happyOut30 happy_x_3 of { (HappyWrap30 happy_var_3) -> + case happyOut138 happy_x_4 of { (HappyWrap138 happy_var_4) -> + case happyOut88 happy_x_5 of { (HappyWrap88 happy_var_5) -> + ( + let + { doOpen = maybe DontOpen (const DoOpen) happy_var_1 + ; m = happy_var_3 + ; es = happy_var_4 + ; dir = happy_var_5 + ; r = getRange (happy_var_1, happy_var_2, m, es, dir) + ; mr = getRange m + ; unique = hashString $ prettyShow $ (Strict.Nothing :: Strict.Maybe ()) <$ r + -- turn range into unique id, but delete file path + -- which is absolute and messes up suite of failing tests + -- (different hashs on different installations) + -- TODO: Don't use (insecure) hashes in this way. + ; fresh = Name mr NotInScope [ Id $ stringToRawName $ ".#" ++ prettyShow m ++ "-" ++ show unique ] + ; fresh' = Name mr NotInScope [ Id $ stringToRawName $ ".#" ++ prettyShow m ++ "-" ++ show (unique + 1) ] + ; impStm asR = Import r m (Just (AsName (Right fresh) asR)) DontOpen defaultImportDir + ; appStm m' es = + Private r Inserted + [ ModuleMacro r m' + (SectionApp (getRange es) [] + (RawApp (getRange es) (Ident (QName fresh) : es))) + doOpen dir + ] + ; (initArgs, last2Args) = splitAt (length es - 2) es + ; parseAsClause = case last2Args of + { [ Ident (QName (Name asR InScope [Id x])) + , e + -- Andreas, 2018-11-03, issue #3364, accept anything after 'as' + -- but require it to be a 'Name' in the scope checker. + ] | rawNameToString x == "as" -> Just . (asR,) $ + if | Ident (QName m') <- e -> Right m' + | otherwise -> Left e + ; _ -> Nothing + } + } in + case es of + { [] -> return [Import r m Nothing doOpen dir] + ; _ | Just (asR, m') <- parseAsClause -> + if null initArgs then return + [ Import (getRange (m, asR, m', dir)) m + (Just (AsName m' asR)) doOpen dir + ] + else return [ impStm asR, appStm (fromRight (const fresh') m') initArgs ] + -- Andreas, 2017-05-13, issue #2579 + -- Nisse reports that importing with instantation but without open + -- could be usefule for bringing instances into scope. + -- Ulf, 2018-12-6: Not since fixes of #1913 and #2489 which require + -- instances to be in scope. + | DontOpen <- doOpen -> parseErrorRange happy_var_2 "An import statement with module instantiation is useless without either an `open' keyword or an `as` binding giving a name to the instantiated module." + | otherwise -> return + [ impStm noRange + , appStm (noName $ beginningOf $ getRange m) es + ] + })}}}}}) + ) (\r -> happyReturn (happyIn137 r)) + +happyReduce_435 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_435 = happyReduce 4# 127# happyReduction_435 +happyReduction_435 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOutTok happy_x_1 of { (TokKeyword KwOpen happy_var_1) -> + case happyOut30 happy_x_2 of { (HappyWrap30 happy_var_2) -> + case happyOut138 happy_x_3 of { (HappyWrap138 happy_var_3) -> + case happyOut88 happy_x_4 of { (HappyWrap88 happy_var_4) -> + happyIn137 + (let + { m = happy_var_2 + ; es = happy_var_3 + ; dir = happy_var_4 + ; r = getRange (happy_var_1, m, es, dir) + } in + [ case es of + { [] -> Open r m dir + ; _ -> Private r Inserted + [ ModuleMacro r (noName $ beginningOf $ getRange m) + (SectionApp (getRange (m , es)) [] (RawApp (fuseRange m es) (Ident m : es))) + DoOpen dir + ] + } + ] + ) `HappyStk` happyRest}}}} + +happyReduce_436 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_436 = happyReduce 6# 127# happyReduction_436 +happyReduction_436 (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 happyOut30 happy_x_2 of { (HappyWrap30 happy_var_2) -> + case happyOut88 happy_x_6 of { (HappyWrap88 happy_var_6) -> + happyIn137 + (let r = getRange happy_var_2 in + [ Private r Inserted + [ ModuleMacro r (noName $ beginningOf $ getRange happy_var_2) (RecordModuleInstance r happy_var_2) DoOpen happy_var_6 + ] + ] + ) `HappyStk` happyRest}} + +happyReduce_437 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_437 = happySpecReduce_0 128# happyReduction_437 +happyReduction_437 = happyIn138 + ([] + ) + +happyReduce_438 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_438 = happySpecReduce_2 128# happyReduction_438 +happyReduction_438 happy_x_2 + happy_x_1 + = case happyOut54 happy_x_1 of { (HappyWrap54 happy_var_1) -> + case happyOut138 happy_x_2 of { (HappyWrap138 happy_var_2) -> + happyIn138 + (happy_var_1 : happy_var_2 + )}} + +happyReduce_439 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_439 = happyReduce 4# 129# happyReduction_439 +happyReduction_439 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOut30 happy_x_1 of { (HappyWrap30 happy_var_1) -> + case happyOutTok happy_x_2 of { (TokSymbol SymDoubleOpenBrace happy_var_2) -> + case happyOutTok happy_x_3 of { (TokSymbol SymEllipsis happy_var_3) -> + case happyOut21 happy_x_4 of { (HappyWrap21 happy_var_4) -> + happyIn139 + ((\ts -> + if null ts then return $ RecordModuleInstance (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4)) happy_var_1 + else parseError "No bindings allowed for record module with non-canonical implicits" ) + ) `HappyStk` happyRest}}}} + +happyReduce_440 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_440 = happySpecReduce_2 129# happyReduction_440 +happyReduction_440 happy_x_2 + happy_x_1 + = case happyOut30 happy_x_1 of { (HappyWrap30 happy_var_1) -> + case happyOut138 happy_x_2 of { (HappyWrap138 happy_var_2) -> + happyIn139 + ((\ts -> return $ SectionApp (getRange (happy_var_1, happy_var_2)) ts (RawApp (fuseRange happy_var_1 happy_var_2) (Ident happy_var_1 : happy_var_2)) ) + )}} + +happyReduce_441 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_441 = happyMonadReduce 6# 130# happyReduction_441 +happyReduction_441 (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 { (TokKeyword KwModule happy_var_1) -> + case happyOut30 happy_x_2 of { (HappyWrap30 happy_var_2) -> + case happyOut81 happy_x_3 of { (HappyWrap81 happy_var_3) -> + case happyOut139 happy_x_5 of { (HappyWrap139 happy_var_5) -> + case happyOut88 happy_x_6 of { (HappyWrap88 happy_var_6) -> + ( do { ma <- happy_var_5 (map addType happy_var_3) + ; name <- ensureUnqual happy_var_2 + ; return $ ModuleMacro (getRange (happy_var_1, happy_var_2, ma, happy_var_6)) name ma DontOpen happy_var_6 })}}}}}) + ) (\r -> happyReturn (happyIn140 r)) + +happyReduce_442 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_442 = happyMonadReduce 7# 130# happyReduction_442 +happyReduction_442 (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 { (TokKeyword KwOpen happy_var_1) -> + case happyOutTok happy_x_2 of { (TokKeyword KwModule happy_var_2) -> + case happyOut19 happy_x_3 of { (HappyWrap19 happy_var_3) -> + case happyOut81 happy_x_4 of { (HappyWrap81 happy_var_4) -> + case happyOut139 happy_x_6 of { (HappyWrap139 happy_var_6) -> + case happyOut88 happy_x_7 of { (HappyWrap88 happy_var_7) -> + ( do {ma <- happy_var_6 (map addType happy_var_4); return $ ModuleMacro (getRange (happy_var_1, happy_var_2, happy_var_3, ma, happy_var_7)) happy_var_3 ma DoOpen happy_var_7 })}}}}}}) + ) (\r -> happyReturn (happyIn140 r)) + +happyReduce_443 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_443 = happyReduce 5# 131# happyReduction_443 +happyReduction_443 (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 { (TokKeyword KwModule happy_var_1) -> + case happyOut30 happy_x_2 of { (HappyWrap30 happy_var_2) -> + case happyOut81 happy_x_3 of { (HappyWrap81 happy_var_3) -> + case happyOutTok happy_x_4 of { (TokKeyword KwWhere happy_var_4) -> + case happyOut184 happy_x_5 of { (HappyWrap184 happy_var_5) -> + happyIn141 + (Module (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4,happy_var_5)) happy_var_2 (map addType happy_var_3) happy_var_5 + ) `HappyStk` happyRest}}}}} + +happyReduce_444 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_444 = happyReduce 5# 131# happyReduction_444 +happyReduction_444 (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 { (TokKeyword KwModule happy_var_1) -> + case happyOut142 happy_x_2 of { (HappyWrap142 happy_var_2) -> + case happyOut81 happy_x_3 of { (HappyWrap81 happy_var_3) -> + case happyOutTok happy_x_4 of { (TokKeyword KwWhere happy_var_4) -> + case happyOut184 happy_x_5 of { (HappyWrap184 happy_var_5) -> + happyIn141 + (Module (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4,happy_var_5)) (QName happy_var_2) (map addType happy_var_3) happy_var_5 + ) `HappyStk` happyRest}}}}} + +happyReduce_445 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_445 = happySpecReduce_1 132# happyReduction_445 +happyReduction_445 happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymUnderscore happy_var_1) -> + happyIn142 + (noName (getRange happy_var_1) + )} + +happyReduce_446 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_446 = happySpecReduce_1 133# happyReduction_446 +happyReduction_446 happy_x_1 + = case happyOut186 happy_x_1 of { (HappyWrap186 happy_var_1) -> + happyIn143 + (figureOutTopLevelModule happy_var_1 + )} + +happyReduce_447 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_447 = happySpecReduce_1 134# happyReduction_447 +happyReduction_447 happy_x_1 + = case happyOut145 happy_x_1 of { (HappyWrap145 happy_var_1) -> + happyIn144 + (Pragma happy_var_1 + )} + +happyReduce_448 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_448 = happySpecReduce_1 135# happyReduction_448 +happyReduction_448 happy_x_1 + = case happyOut147 happy_x_1 of { (HappyWrap147 happy_var_1) -> + happyIn145 + (happy_var_1 + )} + +happyReduce_449 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_449 = happySpecReduce_1 135# happyReduction_449 +happyReduction_449 happy_x_1 + = case happyOut148 happy_x_1 of { (HappyWrap148 happy_var_1) -> + happyIn145 + (happy_var_1 + )} + +happyReduce_450 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_450 = happySpecReduce_1 135# happyReduction_450 +happyReduction_450 happy_x_1 + = case happyOut150 happy_x_1 of { (HappyWrap150 happy_var_1) -> + happyIn145 + (happy_var_1 + )} + +happyReduce_451 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_451 = happySpecReduce_1 135# happyReduction_451 +happyReduction_451 happy_x_1 + = case happyOut149 happy_x_1 of { (HappyWrap149 happy_var_1) -> + happyIn145 + (happy_var_1 + )} + +happyReduce_452 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_452 = happySpecReduce_1 135# happyReduction_452 +happyReduction_452 happy_x_1 + = case happyOut151 happy_x_1 of { (HappyWrap151 happy_var_1) -> + happyIn145 + (happy_var_1 + )} + +happyReduce_453 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_453 = happySpecReduce_1 135# happyReduction_453 +happyReduction_453 happy_x_1 + = case happyOut154 happy_x_1 of { (HappyWrap154 happy_var_1) -> + happyIn145 + (happy_var_1 + )} + +happyReduce_454 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_454 = happySpecReduce_1 135# happyReduction_454 +happyReduction_454 happy_x_1 + = case happyOut152 happy_x_1 of { (HappyWrap152 happy_var_1) -> + happyIn145 + (happy_var_1 + )} + +happyReduce_455 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_455 = happySpecReduce_1 135# happyReduction_455 +happyReduction_455 happy_x_1 + = case happyOut153 happy_x_1 of { (HappyWrap153 happy_var_1) -> + happyIn145 + (happy_var_1 + )} + +happyReduce_456 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_456 = happySpecReduce_1 135# happyReduction_456 +happyReduction_456 happy_x_1 + = case happyOut163 happy_x_1 of { (HappyWrap163 happy_var_1) -> + happyIn145 + (happy_var_1 + )} + +happyReduce_457 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_457 = happySpecReduce_1 135# happyReduction_457 +happyReduction_457 happy_x_1 + = case happyOut159 happy_x_1 of { (HappyWrap159 happy_var_1) -> + happyIn145 + (happy_var_1 + )} + +happyReduce_458 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_458 = happySpecReduce_1 135# happyReduction_458 +happyReduction_458 happy_x_1 + = case happyOut158 happy_x_1 of { (HappyWrap158 happy_var_1) -> + happyIn145 + (happy_var_1 + )} + +happyReduce_459 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_459 = happySpecReduce_1 135# happyReduction_459 +happyReduction_459 happy_x_1 + = case happyOut157 happy_x_1 of { (HappyWrap157 happy_var_1) -> + happyIn145 + (happy_var_1 + )} + +happyReduce_460 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_460 = happySpecReduce_1 135# happyReduction_460 +happyReduction_460 happy_x_1 + = case happyOut160 happy_x_1 of { (HappyWrap160 happy_var_1) -> + happyIn145 + (happy_var_1 + )} + +happyReduce_461 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_461 = happySpecReduce_1 135# happyReduction_461 +happyReduction_461 happy_x_1 + = case happyOut167 happy_x_1 of { (HappyWrap167 happy_var_1) -> + happyIn145 + (happy_var_1 + )} + +happyReduce_462 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_462 = happySpecReduce_1 135# happyReduction_462 +happyReduction_462 happy_x_1 + = case happyOut168 happy_x_1 of { (HappyWrap168 happy_var_1) -> + happyIn145 + (happy_var_1 + )} + +happyReduce_463 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_463 = happySpecReduce_1 135# happyReduction_463 +happyReduction_463 happy_x_1 + = case happyOut161 happy_x_1 of { (HappyWrap161 happy_var_1) -> + happyIn145 + (happy_var_1 + )} + +happyReduce_464 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_464 = happySpecReduce_1 135# happyReduction_464 +happyReduction_464 happy_x_1 + = case happyOut162 happy_x_1 of { (HappyWrap162 happy_var_1) -> + happyIn145 + (happy_var_1 + )} + +happyReduce_465 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_465 = happySpecReduce_1 135# happyReduction_465 +happyReduction_465 happy_x_1 + = case happyOut155 happy_x_1 of { (HappyWrap155 happy_var_1) -> + happyIn145 + (happy_var_1 + )} + +happyReduce_466 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_466 = happySpecReduce_1 135# happyReduction_466 +happyReduction_466 happy_x_1 + = case happyOut156 happy_x_1 of { (HappyWrap156 happy_var_1) -> + happyIn145 + (happy_var_1 + )} + +happyReduce_467 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_467 = happySpecReduce_1 135# happyReduction_467 +happyReduction_467 happy_x_1 + = case happyOut164 happy_x_1 of { (HappyWrap164 happy_var_1) -> + happyIn145 + (happy_var_1 + )} + +happyReduce_468 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_468 = happySpecReduce_1 135# happyReduction_468 +happyReduction_468 happy_x_1 + = case happyOut165 happy_x_1 of { (HappyWrap165 happy_var_1) -> + happyIn145 + (happy_var_1 + )} + +happyReduce_469 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_469 = happySpecReduce_1 135# happyReduction_469 +happyReduction_469 happy_x_1 + = case happyOut166 happy_x_1 of { (HappyWrap166 happy_var_1) -> + happyIn145 + (happy_var_1 + )} + +happyReduce_470 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_470 = happySpecReduce_1 135# happyReduction_470 +happyReduction_470 happy_x_1 + = case happyOut146 happy_x_1 of { (HappyWrap146 happy_var_1) -> + happyIn145 + (happy_var_1 + )} + +happyReduce_471 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_471 = happyReduce 4# 136# happyReduction_471 +happyReduction_471 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> + case happyOutTok happy_x_2 of { (TokKeyword KwOPTIONS happy_var_2) -> + case happyOut36 happy_x_3 of { (HappyWrap36 happy_var_3) -> + case happyOutTok happy_x_4 of { (TokSymbol SymClosePragma happy_var_4) -> + happyIn146 + (OptionsPragma (getRange (happy_var_1,happy_var_2,happy_var_4)) happy_var_3 + ) `HappyStk` happyRest}}}} + +happyReduce_472 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_472 = happyReduce 5# 137# happyReduction_472 +happyReduction_472 (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 { (TokSymbol SymOpenPragma happy_var_1) -> + case happyOutTok happy_x_2 of { (TokKeyword KwBUILTIN happy_var_2) -> + case happyOutTok happy_x_3 of { (TokString happy_var_3) -> + case happyOut40 happy_x_4 of { (HappyWrap40 happy_var_4) -> + case happyOutTok happy_x_5 of { (TokSymbol SymClosePragma happy_var_5) -> + happyIn147 + (BuiltinPragma (getRange (happy_var_1,happy_var_2,fst happy_var_3,happy_var_4,happy_var_5)) (mkRString happy_var_3) happy_var_4 + ) `HappyStk` happyRest}}}}} + +happyReduce_473 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_473 = happyReduce 5# 137# 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) + = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> + case happyOutTok happy_x_2 of { (TokKeyword KwBUILTIN happy_var_2) -> + case happyOutTok happy_x_3 of { (TokKeyword KwREWRITE happy_var_3) -> + case happyOut40 happy_x_4 of { (HappyWrap40 happy_var_4) -> + case happyOutTok happy_x_5 of { (TokSymbol SymClosePragma happy_var_5) -> + happyIn147 + (BuiltinPragma (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4,happy_var_5)) (Ranged (getRange happy_var_3) "REWRITE") happy_var_4 + ) `HappyStk` happyRest}}}}} + +happyReduce_474 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_474 = happyReduce 4# 138# happyReduction_474 +happyReduction_474 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> + case happyOutTok happy_x_2 of { (TokKeyword KwREWRITE happy_var_2) -> + case happyOut41 happy_x_3 of { (HappyWrap41 happy_var_3) -> + case happyOutTok happy_x_4 of { (TokSymbol SymClosePragma happy_var_4) -> + happyIn148 + (RewritePragma (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4)) (getRange happy_var_2) happy_var_3 + ) `HappyStk` happyRest}}}} + +happyReduce_475 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_475 = happyReduce 5# 139# happyReduction_475 +happyReduction_475 (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 { (TokSymbol SymOpenPragma happy_var_1) -> + case happyOutTok happy_x_2 of { (TokKeyword KwFOREIGN happy_var_2) -> + case happyOutTok happy_x_3 of { (TokString happy_var_3) -> + case happyOut38 happy_x_4 of { (HappyWrap38 happy_var_4) -> + case happyOutTok happy_x_5 of { (TokSymbol SymClosePragma happy_var_5) -> + happyIn149 + (ForeignPragma (getRange (happy_var_1, happy_var_2, fst happy_var_3, happy_var_5)) (mkRString happy_var_3) (recoverLayout happy_var_4) + ) `HappyStk` happyRest}}}}} + +happyReduce_476 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_476 = happyReduce 6# 140# happyReduction_476 +happyReduction_476 (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 { (TokSymbol SymOpenPragma happy_var_1) -> + case happyOutTok happy_x_2 of { (TokKeyword KwCOMPILE happy_var_2) -> + case happyOutTok happy_x_3 of { (TokString happy_var_3) -> + case happyOut40 happy_x_4 of { (HappyWrap40 happy_var_4) -> + case happyOut36 happy_x_5 of { (HappyWrap36 happy_var_5) -> + case happyOutTok happy_x_6 of { (TokSymbol SymClosePragma happy_var_6) -> + happyIn150 + (CompilePragma (getRange (happy_var_1,happy_var_2,fst happy_var_3,happy_var_4,happy_var_6)) (mkRString happy_var_3) happy_var_4 (unwords happy_var_5) + ) `HappyStk` happyRest}}}}}} + +happyReduce_477 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_477 = happyReduce 4# 141# happyReduction_477 +happyReduction_477 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> + case happyOutTok happy_x_2 of { (TokKeyword KwSTATIC happy_var_2) -> + case happyOut40 happy_x_3 of { (HappyWrap40 happy_var_3) -> + case happyOutTok happy_x_4 of { (TokSymbol SymClosePragma happy_var_4) -> + happyIn151 + (StaticPragma (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4)) happy_var_3 + ) `HappyStk` happyRest}}}} + +happyReduce_478 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_478 = happyReduce 4# 142# happyReduction_478 +happyReduction_478 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> + case happyOutTok happy_x_2 of { (TokKeyword KwINLINE happy_var_2) -> + case happyOut40 happy_x_3 of { (HappyWrap40 happy_var_3) -> + case happyOutTok happy_x_4 of { (TokSymbol SymClosePragma happy_var_4) -> + happyIn152 + (InlinePragma (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4)) True happy_var_3 + ) `HappyStk` happyRest}}}} + +happyReduce_479 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_479 = happyReduce 4# 143# happyReduction_479 +happyReduction_479 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> + case happyOutTok happy_x_2 of { (TokKeyword KwNOINLINE happy_var_2) -> + case happyOut40 happy_x_3 of { (HappyWrap40 happy_var_3) -> + case happyOutTok happy_x_4 of { (TokSymbol SymClosePragma happy_var_4) -> + happyIn153 + (InlinePragma (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4)) False happy_var_3 + ) `HappyStk` happyRest}}}} + +happyReduce_480 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_480 = happyReduce 4# 144# happyReduction_480 +happyReduction_480 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> + case happyOutTok happy_x_2 of { (TokKeyword KwINJECTIVE happy_var_2) -> + case happyOut40 happy_x_3 of { (HappyWrap40 happy_var_3) -> + case happyOutTok happy_x_4 of { (TokSymbol SymClosePragma happy_var_4) -> + happyIn154 + (InjectivePragma (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4)) happy_var_3 + ) `HappyStk` happyRest}}}} + +happyReduce_481 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_481 = happyMonadReduce 5# 145# happyReduction_481 +happyReduction_481 (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 { (TokSymbol SymOpenPragma happy_var_1) -> + case happyOutTok happy_x_3 of { (TokString happy_var_3) -> + case happyOut36 happy_x_4 of { (HappyWrap36 happy_var_4) -> + case happyOutTok happy_x_5 of { (TokSymbol SymClosePragma happy_var_5) -> + ( + let (r, s) = happy_var_3 in + parseDisplayPragma (fuseRange happy_var_1 happy_var_5) (iStart r) (unwords (s : happy_var_4)))}}}}) + ) (\r -> happyReturn (happyIn155 r)) + +happyReduce_482 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_482 = happyReduce 4# 146# happyReduction_482 +happyReduction_482 (happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) + = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> + case happyOutTok happy_x_2 of { (TokKeyword KwETA happy_var_2) -> + case happyOut40 happy_x_3 of { (HappyWrap40 happy_var_3) -> + case happyOutTok happy_x_4 of { (TokSymbol SymClosePragma happy_var_4) -> + happyIn156 + (EtaPragma (getRange (happy_var_1,happy_var_2,happy_var_3,happy_var_4)) happy_var_3 + ) `HappyStk` happyRest}}}} + +happyReduce_483 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_483 = happySpecReduce_3 147# happyReduction_483 +happyReduction_483 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> + case happyOutTok happy_x_2 of { (TokKeyword KwNO_TERMINATION_CHECK happy_var_2) -> + case happyOutTok happy_x_3 of { (TokSymbol SymClosePragma happy_var_3) -> + happyIn157 + (TerminationCheckPragma (getRange (happy_var_1,happy_var_2,happy_var_3)) NoTerminationCheck + )}}} + +happyReduce_484 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_484 = happySpecReduce_3 148# happyReduction_484 +happyReduction_484 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> + case happyOutTok happy_x_2 of { (TokKeyword KwNON_TERMINATING happy_var_2) -> + case happyOutTok happy_x_3 of { (TokSymbol SymClosePragma happy_var_3) -> + happyIn158 + (TerminationCheckPragma (getRange (happy_var_1,happy_var_2,happy_var_3)) NonTerminating + )}}} + +happyReduce_485 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_485 = happySpecReduce_3 149# happyReduction_485 +happyReduction_485 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> + case happyOutTok happy_x_2 of { (TokKeyword KwTERMINATING happy_var_2) -> + case happyOutTok happy_x_3 of { (TokSymbol SymClosePragma happy_var_3) -> + happyIn159 + (TerminationCheckPragma (getRange (happy_var_1,happy_var_2,happy_var_3)) Terminating + )}}} + +happyReduce_486 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_486 = happySpecReduce_3 150# happyReduction_486 +happyReduction_486 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> + case happyOutTok happy_x_2 of { (TokKeyword KwNON_COVERING happy_var_2) -> + case happyOutTok happy_x_3 of { (TokSymbol SymClosePragma happy_var_3) -> + happyIn160 + (NoCoverageCheckPragma (getRange (happy_var_1,happy_var_2,happy_var_3)) + )}}} + +happyReduce_487 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_487 = happyReduce 4# 151# 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 { (TokSymbol SymOpenPragma happy_var_1) -> + case happyOutTok happy_x_2 of { (TokKeyword KwMEASURE happy_var_2) -> + case happyOut39 happy_x_3 of { (HappyWrap39 happy_var_3) -> + case happyOutTok happy_x_4 of { (TokSymbol SymClosePragma happy_var_4) -> + happyIn161 + (let r = getRange (happy_var_1, happy_var_2, happy_var_3, happy_var_4) in + TerminationCheckPragma r (TerminationMeasure r happy_var_3) + ) `HappyStk` happyRest}}}} + +happyReduce_488 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_488 = happySpecReduce_3 152# happyReduction_488 +happyReduction_488 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> + case happyOutTok happy_x_2 of { (TokKeyword KwCATCHALL happy_var_2) -> + case happyOutTok happy_x_3 of { (TokSymbol SymClosePragma happy_var_3) -> + happyIn162 + (CatchallPragma (getRange (happy_var_1,happy_var_2,happy_var_3)) + )}}} + +happyReduce_489 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_489 = happySpecReduce_3 153# happyReduction_489 +happyReduction_489 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> + case happyOutTok happy_x_2 of { (TokKeyword KwIMPOSSIBLE happy_var_2) -> + case happyOutTok happy_x_3 of { (TokSymbol SymClosePragma happy_var_3) -> + happyIn163 + (ImpossiblePragma (getRange (happy_var_1,happy_var_2,happy_var_3)) + )}}} + +happyReduce_490 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_490 = happySpecReduce_3 154# happyReduction_490 +happyReduction_490 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> + case happyOutTok happy_x_2 of { (TokKeyword KwNO_POSITIVITY_CHECK happy_var_2) -> + case happyOutTok happy_x_3 of { (TokSymbol SymClosePragma happy_var_3) -> + happyIn164 + (NoPositivityCheckPragma (getRange (happy_var_1,happy_var_2,happy_var_3)) + )}}} + +happyReduce_491 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_491 = happySpecReduce_3 155# happyReduction_491 +happyReduction_491 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOutTok happy_x_1 of { (TokSymbol SymOpenPragma happy_var_1) -> + case happyOutTok happy_x_2 of { (TokKeyword KwNO_UNIVERSE_CHECK happy_var_2) -> + case happyOutTok happy_x_3 of { (TokSymbol SymClosePragma happy_var_3) -> + happyIn165 + (NoUniverseCheckPragma (getRange (happy_var_1,happy_var_2,happy_var_3)) + )}}} + +happyReduce_492 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_492 = happyReduce 5# 156# happyReduction_492 +happyReduction_492 (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 { (TokSymbol SymOpenPragma happy_var_1) -> + case happyOutTok happy_x_2 of { (TokKeyword KwPOLARITY happy_var_2) -> + case happyOut39 happy_x_3 of { (HappyWrap39 happy_var_3) -> + case happyOut169 happy_x_4 of { (HappyWrap169 happy_var_4) -> + case happyOutTok happy_x_5 of { (TokSymbol SymClosePragma happy_var_5) -> + happyIn166 + (let (rs, occs) = unzip (reverse happy_var_4) in + PolarityPragma (getRange (happy_var_1,happy_var_2,happy_var_3,rs,happy_var_5)) happy_var_3 occs + ) `HappyStk` happyRest}}}}} + +happyReduce_493 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_493 = happyMonadReduce 5# 157# happyReduction_493 +happyReduction_493 (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 { (TokSymbol SymOpenPragma happy_var_1) -> + case happyOutTok happy_x_2 of { (TokKeyword KwWARNING_ON_USAGE happy_var_2) -> + case happyOut40 happy_x_3 of { (HappyWrap40 happy_var_3) -> + case happyOutTok happy_x_4 of { (TokLiteral happy_var_4) -> + case happyOutTok happy_x_5 of { (TokSymbol SymClosePragma happy_var_5) -> + ( case happy_var_4 of + { LitString r str -> return $ WarningOnUsage (getRange (happy_var_1,happy_var_2,happy_var_3,r,happy_var_5)) happy_var_3 str + ; _ -> parseError "Expected string literal" + })}}}}}) + ) (\r -> happyReturn (happyIn167 r)) + +happyReduce_494 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_494 = happyMonadReduce 4# 158# happyReduction_494 +happyReduction_494 (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 { (TokSymbol SymOpenPragma happy_var_1) -> + case happyOutTok happy_x_2 of { (TokKeyword KwWARNING_ON_IMPORT happy_var_2) -> + case happyOutTok happy_x_3 of { (TokLiteral happy_var_3) -> + case happyOutTok happy_x_4 of { (TokSymbol SymClosePragma happy_var_4) -> + ( case happy_var_3 of + { LitString r str -> return $ WarningOnImport (getRange (happy_var_1,happy_var_2,r,happy_var_4)) str + ; _ -> parseError "Expected string literal" + })}}}}) + ) (\r -> happyReturn (happyIn168 r)) + +happyReduce_495 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_495 = happySpecReduce_0 159# happyReduction_495 +happyReduction_495 = happyIn169 + ([] + ) + +happyReduce_496 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_496 = happySpecReduce_2 159# happyReduction_496 +happyReduction_496 happy_x_2 + happy_x_1 + = case happyOut169 happy_x_1 of { (HappyWrap169 happy_var_1) -> + case happyOut170 happy_x_2 of { (HappyWrap170 happy_var_2) -> + happyIn169 + (happy_var_2 : happy_var_1 + )}} + +happyReduce_497 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_497 = happyMonadReduce 1# 160# happyReduction_497 +happyReduction_497 (happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOutTok happy_x_1 of { (TokString happy_var_1) -> + ( polarity happy_var_1)}) + ) (\r -> happyReturn (happyIn170 r)) + +happyReduce_498 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_498 = happySpecReduce_2 161# happyReduction_498 +happyReduction_498 happy_x_2 + happy_x_1 + = happyIn171 + ([] + ) + +happyReduce_499 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_499 = happySpecReduce_1 161# happyReduction_499 +happyReduction_499 happy_x_1 + = case happyOut172 happy_x_1 of { (HappyWrap172 happy_var_1) -> + happyIn171 + (happy_var_1 + )} + +happyReduce_500 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_500 = happySpecReduce_3 162# happyReduction_500 +happyReduction_500 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut173 happy_x_2 of { (HappyWrap173 happy_var_2) -> + happyIn172 + (reverse happy_var_2 + )} + +happyReduce_501 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_501 = happySpecReduce_3 163# happyReduction_501 +happyReduction_501 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut173 happy_x_1 of { (HappyWrap173 happy_var_1) -> + case happyOut107 happy_x_3 of { (HappyWrap107 happy_var_3) -> + happyIn173 + (reverse happy_var_3 ++ happy_var_1 + )}} + +happyReduce_502 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_502 = happySpecReduce_1 163# happyReduction_502 +happyReduction_502 happy_x_1 + = case happyOut107 happy_x_1 of { (HappyWrap107 happy_var_1) -> + happyIn173 + (reverse happy_var_1 + )} + +happyReduce_503 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_503 = happySpecReduce_3 164# happyReduction_503 +happyReduction_503 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut175 happy_x_2 of { (HappyWrap175 happy_var_2) -> + happyIn174 + (reverse happy_var_2 + )} + +happyReduce_504 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_504 = happySpecReduce_3 165# happyReduction_504 +happyReduction_504 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut175 happy_x_1 of { (HappyWrap175 happy_var_1) -> + case happyOut108 happy_x_3 of { (HappyWrap108 happy_var_3) -> + happyIn175 + (reverse happy_var_3 ++ happy_var_1 + )}} + +happyReduce_505 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_505 = happySpecReduce_1 165# happyReduction_505 +happyReduction_505 happy_x_1 + = case happyOut108 happy_x_1 of { (HappyWrap108 happy_var_1) -> + happyIn175 + (reverse happy_var_1 + )} + +happyReduce_506 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_506 = happySpecReduce_3 166# happyReduction_506 +happyReduction_506 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut177 happy_x_2 of { (HappyWrap177 happy_var_2) -> + happyIn176 + (reverse happy_var_2 + )} + +happyReduce_507 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_507 = happySpecReduce_3 167# happyReduction_507 +happyReduction_507 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut177 happy_x_1 of { (HappyWrap177 happy_var_1) -> + case happyOut108 happy_x_3 of { (HappyWrap108 happy_var_3) -> + happyIn177 + (reverse happy_var_3 ++ happy_var_1 + )}} + +happyReduce_508 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_508 = happySpecReduce_1 167# happyReduction_508 +happyReduction_508 happy_x_1 + = case happyOut108 happy_x_1 of { (HappyWrap108 happy_var_1) -> + happyIn177 + (reverse happy_var_1 + )} + +happyReduce_509 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_509 = happySpecReduce_0 167# happyReduction_509 +happyReduction_509 = happyIn177 + ([] + ) + +happyReduce_510 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_510 = happyMonadReduce 3# 168# happyReduction_510 +happyReduction_510 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut179 happy_x_2 of { (HappyWrap179 happy_var_2) -> + ( ((,) `fmap` verifyRecordDirectives happy_var_2 <*> pure []))}) + ) (\r -> happyReturn (happyIn178 r)) + +happyReduce_511 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_511 = happyMonadReduce 5# 168# happyReduction_511 +happyReduction_511 (happy_x_5 `HappyStk` + happy_x_4 `HappyStk` + happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut179 happy_x_2 of { (HappyWrap179 happy_var_2) -> + case happyOut185 happy_x_4 of { (HappyWrap185 happy_var_4) -> + ( ((,) `fmap` verifyRecordDirectives happy_var_2 <*> pure happy_var_4))}}) + ) (\r -> happyReturn (happyIn178 r)) + +happyReduce_512 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_512 = happyMonadReduce 3# 168# happyReduction_512 +happyReduction_512 (happy_x_3 `HappyStk` + happy_x_2 `HappyStk` + happy_x_1 `HappyStk` + happyRest) tk + = happyThen ((case happyOut185 happy_x_2 of { (HappyWrap185 happy_var_2) -> + ( ((,) `fmap` verifyRecordDirectives [] <*> pure happy_var_2))}) + ) (\r -> happyReturn (happyIn178 r)) + +happyReduce_513 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_513 = happySpecReduce_0 169# happyReduction_513 +happyReduction_513 = happyIn179 + ([] + ) + +happyReduce_514 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_514 = happySpecReduce_3 169# happyReduction_514 +happyReduction_514 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut179 happy_x_1 of { (HappyWrap179 happy_var_1) -> + case happyOut180 happy_x_3 of { (HappyWrap180 happy_var_3) -> + happyIn179 + (happy_var_3 : happy_var_1 + )}} + +happyReduce_515 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_515 = happySpecReduce_1 169# happyReduction_515 +happyReduction_515 happy_x_1 + = case happyOut180 happy_x_1 of { (HappyWrap180 happy_var_1) -> + happyIn179 + ([happy_var_1] + )} + +happyReduce_516 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_516 = happySpecReduce_1 170# happyReduction_516 +happyReduction_516 happy_x_1 + = case happyOut115 happy_x_1 of { (HappyWrap115 happy_var_1) -> + happyIn180 + (Constructor happy_var_1 + )} + +happyReduce_517 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_517 = happySpecReduce_1 170# happyReduction_517 +happyReduction_517 happy_x_1 + = case happyOut182 happy_x_1 of { (HappyWrap182 happy_var_1) -> + happyIn180 + (Induction happy_var_1 + )} + +happyReduce_518 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_518 = happySpecReduce_1 170# happyReduction_518 +happyReduction_518 happy_x_1 + = case happyOut181 happy_x_1 of { (HappyWrap181 happy_var_1) -> + happyIn180 + (Eta happy_var_1 + )} + +happyReduce_519 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_519 = happySpecReduce_1 171# happyReduction_519 +happyReduction_519 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwEta happy_var_1) -> + happyIn181 + (Ranged (getRange happy_var_1) YesEta + )} + +happyReduce_520 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_520 = happySpecReduce_1 171# happyReduction_520 +happyReduction_520 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwNoEta happy_var_1) -> + happyIn181 + (Ranged (getRange happy_var_1) NoEta + )} + +happyReduce_521 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_521 = happySpecReduce_1 172# happyReduction_521 +happyReduction_521 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwInductive happy_var_1) -> + happyIn182 + (Ranged (getRange happy_var_1) Inductive + )} + +happyReduce_522 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_522 = happySpecReduce_1 172# happyReduction_522 +happyReduction_522 happy_x_1 + = case happyOutTok happy_x_1 of { (TokKeyword KwCoInductive happy_var_1) -> + happyIn182 + (Ranged (getRange happy_var_1) CoInductive + )} + +happyReduce_523 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_523 = happySpecReduce_3 173# happyReduction_523 +happyReduction_523 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut185 happy_x_2 of { (HappyWrap185 happy_var_2) -> + happyIn183 + (happy_var_2 + )} + +happyReduce_524 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_524 = happySpecReduce_2 174# happyReduction_524 +happyReduction_524 happy_x_2 + happy_x_1 + = happyIn184 + ([] + ) + +happyReduce_525 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_525 = happySpecReduce_1 174# happyReduction_525 +happyReduction_525 happy_x_1 + = case happyOut183 happy_x_1 of { (HappyWrap183 happy_var_1) -> + happyIn184 + (happy_var_1 + )} + +happyReduce_526 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_526 = happySpecReduce_3 175# happyReduction_526 +happyReduction_526 happy_x_3 + happy_x_2 + happy_x_1 + = case happyOut106 happy_x_1 of { (HappyWrap106 happy_var_1) -> + case happyOut185 happy_x_3 of { (HappyWrap185 happy_var_3) -> + happyIn185 + (happy_var_1 ++ happy_var_3 + )}} + +happyReduce_527 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_527 = happySpecReduce_2 175# happyReduction_527 +happyReduction_527 happy_x_2 + happy_x_1 + = case happyOut106 happy_x_1 of { (HappyWrap106 happy_var_1) -> + happyIn185 + (happy_var_1 + )} + +happyReduce_528 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_528 = happySpecReduce_1 175# happyReduction_528 +happyReduction_528 happy_x_1 + = case happyOut106 happy_x_1 of { (HappyWrap106 happy_var_1) -> + happyIn185 + (happy_var_1 + )} + +happyReduce_529 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_529 = happySpecReduce_0 176# happyReduction_529 +happyReduction_529 = happyIn186 + ([] + ) + +happyReduce_530 :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) +happyReduce_530 = happySpecReduce_1 176# happyReduction_530 +happyReduction_530 happy_x_1 + = case happyOut185 happy_x_1 of { (HappyWrap185 happy_var_1) -> + happyIn186 + (happy_var_1 + )} + +happyNewToken action sts stk + = lexer(\tk -> + let cont i = happyDoAction i tk action sts stk in + case tk of { + TokEOF{} -> happyDoAction 104# tk action sts stk; + TokKeyword KwAbstract happy_dollar_dollar -> cont 1#; + TokKeyword KwCoData happy_dollar_dollar -> cont 2#; + TokKeyword KwCoInductive happy_dollar_dollar -> cont 3#; + TokKeyword KwConstructor happy_dollar_dollar -> cont 4#; + TokKeyword KwData happy_dollar_dollar -> cont 5#; + TokKeyword KwEta happy_dollar_dollar -> cont 6#; + TokKeyword KwField happy_dollar_dollar -> cont 7#; + TokKeyword KwForall happy_dollar_dollar -> cont 8#; + TokKeyword KwVariable happy_dollar_dollar -> cont 9#; + TokKeyword KwHiding happy_dollar_dollar -> cont 10#; + TokKeyword KwImport happy_dollar_dollar -> cont 11#; + TokKeyword KwIn happy_dollar_dollar -> cont 12#; + TokKeyword KwInductive happy_dollar_dollar -> cont 13#; + TokKeyword KwInfix happy_dollar_dollar -> cont 14#; + TokKeyword KwInfixL happy_dollar_dollar -> cont 15#; + TokKeyword KwInfixR happy_dollar_dollar -> cont 16#; + TokKeyword KwInstance happy_dollar_dollar -> cont 17#; + TokKeyword KwOverlap happy_dollar_dollar -> cont 18#; + TokKeyword KwLet happy_dollar_dollar -> cont 19#; + TokKeyword KwMacro happy_dollar_dollar -> cont 20#; + TokKeyword KwModule happy_dollar_dollar -> cont 21#; + TokKeyword KwMutual happy_dollar_dollar -> cont 22#; + TokKeyword KwNoEta happy_dollar_dollar -> cont 23#; + TokKeyword KwOpen happy_dollar_dollar -> cont 24#; + TokKeyword KwPatternSyn happy_dollar_dollar -> cont 25#; + TokKeyword KwPostulate happy_dollar_dollar -> cont 26#; + TokKeyword KwPrimitive happy_dollar_dollar -> cont 27#; + TokKeyword KwPrivate happy_dollar_dollar -> cont 28#; + TokKeyword KwProp happy_dollar_dollar -> cont 29#; + TokKeyword KwPublic happy_dollar_dollar -> cont 30#; + TokKeyword KwQuote happy_dollar_dollar -> cont 31#; + TokKeyword KwQuoteTerm happy_dollar_dollar -> cont 32#; + TokKeyword KwRecord happy_dollar_dollar -> cont 33#; + TokKeyword KwRenaming happy_dollar_dollar -> cont 34#; + TokKeyword KwRewrite happy_dollar_dollar -> cont 35#; + TokKeyword KwSet happy_dollar_dollar -> cont 36#; + TokKeyword KwSyntax happy_dollar_dollar -> cont 37#; + TokKeyword KwTactic happy_dollar_dollar -> cont 38#; + TokKeyword KwTo happy_dollar_dollar -> cont 39#; + TokKeyword KwUnquote happy_dollar_dollar -> cont 40#; + TokKeyword KwUnquoteDecl happy_dollar_dollar -> cont 41#; + TokKeyword KwUnquoteDef happy_dollar_dollar -> cont 42#; + TokKeyword KwUsing happy_dollar_dollar -> cont 43#; + TokKeyword KwWhere happy_dollar_dollar -> cont 44#; + TokKeyword KwDo happy_dollar_dollar -> cont 45#; + TokKeyword KwWith happy_dollar_dollar -> cont 46#; + TokKeyword KwBUILTIN happy_dollar_dollar -> cont 47#; + TokKeyword KwCATCHALL happy_dollar_dollar -> cont 48#; + TokKeyword KwDISPLAY happy_dollar_dollar -> cont 49#; + TokKeyword KwETA happy_dollar_dollar -> cont 50#; + TokKeyword KwFOREIGN happy_dollar_dollar -> cont 51#; + TokKeyword KwCOMPILE happy_dollar_dollar -> cont 52#; + TokKeyword KwIMPOSSIBLE happy_dollar_dollar -> cont 53#; + TokKeyword KwINJECTIVE happy_dollar_dollar -> cont 54#; + TokKeyword KwINLINE happy_dollar_dollar -> cont 55#; + TokKeyword KwNOINLINE happy_dollar_dollar -> cont 56#; + TokKeyword KwMEASURE happy_dollar_dollar -> cont 57#; + TokKeyword KwNO_TERMINATION_CHECK happy_dollar_dollar -> cont 58#; + TokKeyword KwNO_POSITIVITY_CHECK happy_dollar_dollar -> cont 59#; + TokKeyword KwNO_UNIVERSE_CHECK happy_dollar_dollar -> cont 60#; + TokKeyword KwNON_TERMINATING happy_dollar_dollar -> cont 61#; + TokKeyword KwNON_COVERING happy_dollar_dollar -> cont 62#; + TokKeyword KwOPTIONS happy_dollar_dollar -> cont 63#; + TokKeyword KwPOLARITY happy_dollar_dollar -> cont 64#; + TokKeyword KwWARNING_ON_USAGE happy_dollar_dollar -> cont 65#; + TokKeyword KwWARNING_ON_IMPORT happy_dollar_dollar -> cont 66#; + TokKeyword KwREWRITE happy_dollar_dollar -> cont 67#; + TokKeyword KwSTATIC happy_dollar_dollar -> cont 68#; + TokKeyword KwTERMINATING happy_dollar_dollar -> cont 69#; + TokSetN happy_dollar_dollar -> cont 70#; + TokPropN happy_dollar_dollar -> cont 71#; + TokTeX happy_dollar_dollar -> cont 72#; + TokComment happy_dollar_dollar -> cont 73#; + TokSymbol SymEllipsis happy_dollar_dollar -> cont 74#; + TokSymbol SymDotDot happy_dollar_dollar -> cont 75#; + TokSymbol SymDot happy_dollar_dollar -> cont 76#; + TokSymbol SymSemi happy_dollar_dollar -> cont 77#; + TokSymbol SymColon happy_dollar_dollar -> cont 78#; + TokSymbol SymEqual happy_dollar_dollar -> cont 79#; + TokSymbol SymUnderscore happy_dollar_dollar -> cont 80#; + TokSymbol SymQuestionMark happy_dollar_dollar -> cont 81#; + TokSymbol SymArrow happy_dollar_dollar -> cont 82#; + TokSymbol SymLambda happy_dollar_dollar -> cont 83#; + TokSymbol SymAs happy_dollar_dollar -> cont 84#; + TokSymbol SymBar happy_dollar_dollar -> cont 85#; + TokSymbol SymOpenParen happy_dollar_dollar -> cont 86#; + TokSymbol SymCloseParen happy_dollar_dollar -> cont 87#; + TokSymbol SymOpenIdiomBracket happy_dollar_dollar -> cont 88#; + TokSymbol SymCloseIdiomBracket happy_dollar_dollar -> cont 89#; + TokSymbol SymEmptyIdiomBracket happy_dollar_dollar -> cont 90#; + TokSymbol SymDoubleOpenBrace happy_dollar_dollar -> cont 91#; + TokSymbol SymDoubleCloseBrace happy_dollar_dollar -> cont 92#; + TokSymbol SymOpenBrace happy_dollar_dollar -> cont 93#; + TokSymbol SymCloseBrace happy_dollar_dollar -> cont 94#; + TokSymbol SymOpenVirtualBrace happy_dollar_dollar -> cont 95#; + TokSymbol SymCloseVirtualBrace happy_dollar_dollar -> cont 96#; + TokSymbol SymVirtualSemi happy_dollar_dollar -> cont 97#; + TokSymbol SymOpenPragma happy_dollar_dollar -> cont 98#; + TokSymbol SymClosePragma happy_dollar_dollar -> cont 99#; + TokId happy_dollar_dollar -> cont 100#; + TokQId happy_dollar_dollar -> cont 101#; + TokString happy_dollar_dollar -> cont 102#; + TokLiteral happy_dollar_dollar -> cont 103#; + _ -> happyError' (tk, []) + }) + +happyError_ explist 104# tk = happyError' (tk, explist) +happyError_ explist _ tk = happyError' (tk, explist) + +happyThen :: () => Parser a -> (a -> Parser b) -> Parser b +happyThen = (>>=) +happyReturn :: () => a -> Parser a +happyReturn = (return) +happyParse :: () => Happy_GHC_Exts.Int# -> Parser (HappyAbsSyn ) + +happyNewToken :: () => Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) + +happyDoAction :: () => Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn ) + +happyReduceArr :: () => Happy_Data_Array.Array Int (Happy_GHC_Exts.Int# -> Token -> Happy_GHC_Exts.Int# -> Happy_IntList -> HappyStk (HappyAbsSyn ) -> Parser (HappyAbsSyn )) + +happyThen1 :: () => Parser a -> (a -> Parser b) -> Parser b +happyThen1 = happyThen +happyReturn1 :: () => a -> Parser a +happyReturn1 = happyReturn +happyError' :: () => ((Token), [String]) -> Parser a +happyError' tk = (\(tokens, explist) -> happyError) tk +tokensParser = happySomeParser where + happySomeParser = happyThen (happyParse 0#) (\x -> happyReturn (let {(HappyWrap10 x') = happyOut10 x} in x')) + +exprParser = happySomeParser where + happySomeParser = happyThen (happyParse 1#) (\x -> happyReturn (let {(HappyWrap42 x') = happyOut42 x} in x')) + +exprWhereParser = happySomeParser where + happySomeParser = happyThen (happyParse 2#) (\x -> happyReturn (let {(HappyWrap105 x') = happyOut105 x} in x')) + +moduleParser = happySomeParser where + happySomeParser = happyThen (happyParse 3#) (\x -> happyReturn (let {(HappyWrap13 x') = happyOut13 x} in x')) + +moduleNameParser = happySomeParser where + happySomeParser = happyThen (happyParse 4#) (\x -> happyReturn (let {(HappyWrap30 x') = happyOut30 x} in x')) + +funclauseParser = happySomeParser where + happySomeParser = happyThen (happyParse 5#) (\x -> happyReturn (let {(HappyWrap109 x') = happyOut109 x} in x')) + +holeContentParser = happySomeParser where + happySomeParser = happyThen (happyParse 6#) (\x -> happyReturn (let {(HappyWrap103 x') = happyOut103 x} in x')) + +happySeq = happyDontSeq + + +{-------------------------------------------------------------------------- + Parsers + --------------------------------------------------------------------------} + +-- | Parse the token stream. Used by the TeX compiler. +tokensParser :: Parser [Token] + +-- | Parse an expression. Could be used in interactions. +exprParser :: Parser Expr + +-- | Parse an expression followed by a where clause. Could be used in interactions. +exprWhereParser :: Parser ExprWhere + +-- | Parse a module. +moduleParser :: Parser Module + + +{-------------------------------------------------------------------------- + Happy stuff + --------------------------------------------------------------------------} + +-- | Required by Happy. +happyError :: Parser a +happyError = parseError "Parse error" + + +{-------------------------------------------------------------------------- + Utility functions + --------------------------------------------------------------------------} + +-- | Grab leading OPTIONS pragmas. +takeOptionsPragmas :: [Declaration] -> ([Pragma], [Declaration]) +takeOptionsPragmas = spanJust $ \ d -> case d of + Pragma p@OptionsPragma{} -> Just p + _ -> Nothing + +-- | Insert a top-level module if there is none. +-- Also fix-up for the case the declarations in the top-level module +-- are not indented (this is allowed as a special case). +figureOutTopLevelModule :: [Declaration] -> [Declaration] +figureOutTopLevelModule ds = + case spanAllowedBeforeModule ds of + -- Andreas 2016-02-01, issue #1388. + -- We need to distinguish two additional cases. + + -- Case 1: Regular file layout: imports followed by one module. Nothing to do. + (ds0, [ Module{} ]) -> ds + + -- Case 2: The declarations in the module are not indented. + -- This is allowed for the top level module, and thus rectified here. + (ds0, Module r m tel [] : ds2) -> ds0 ++ [Module r m tel ds2] + + -- Case 3: There is a module with indented declarations, + -- followed by non-indented declarations. This should be a + -- parse error and be reported later (see @toAbstract TopLevel{}@), + -- thus, we do not do anything here. + (ds0, Module r m tel ds1 : ds2) -> ds -- Gives parse error in scope checker. + -- OLD code causing issue 1388: + -- (ds0, Module r m tel ds1 : ds2) -> ds0 ++ [Module r m tel $ ds1 ++ ds2] + + -- Case 4: a top-level module declaration is missing. + -- Andreas, 2017-01-01, issue #2229: + -- Put everything (except OPTIONS pragmas) into an anonymous module. + _ -> ds0 ++ [Module r (QName $ noName r) [] ds1] + where + (ds0, ds1) = (`span` ds) $ \case + Pragma OptionsPragma{} -> True + _ -> False + -- Andreas, 2017-05-17, issue #2574. + -- Since the module noName will act as jump target, it needs a range. + -- We use the beginning of the file as beginning of the top level module. + r = beginningOfFile $ getRange ds1 + +-- | Create a name from a string. + +mkName :: (Interval, String) -> Parser Name +mkName (i, s) = do + let xs = C.stringNameParts s + mapM_ isValidId xs + unless (alternating xs) $ parseError $ "a name cannot contain two consecutive underscores" + return $ Name (getRange i) InScope xs + where + isValidId Hole = return () + isValidId (Id y) = do + let x = rawNameToString y + err = "in the name " ++ s ++ ", the part " ++ x ++ " is not valid" + case parse defaultParseFlags [0] (lexer return) x of + ParseOk _ TokId{} -> return () + ParseFailed{} -> parseError err + ParseOk _ TokEOF{} -> parseError err + ParseOk _ t -> parseError . ((err ++ " because it is ") ++) $ case t of + TokId{} -> __IMPOSSIBLE__ + TokQId{} -> __IMPOSSIBLE__ -- "qualified" + TokKeyword{} -> "a keyword" + TokLiteral{} -> "a literal" + TokSymbol s _ -> case s of + SymDot -> __IMPOSSIBLE__ -- "reserved" + SymSemi -> "used to separate declarations" + SymVirtualSemi -> __IMPOSSIBLE__ + SymBar -> "used for with-arguments" + SymColon -> "part of declaration syntax" + SymArrow -> "the function arrow" + SymEqual -> "part of declaration syntax" + SymLambda -> "used for lambda-abstraction" + SymUnderscore -> "used for anonymous identifiers" + SymQuestionMark -> "a meta variable" + SymAs -> "used for as-patterns" + SymOpenParen -> "used to parenthesize expressions" + SymCloseParen -> "used to parenthesize expressions" + SymOpenIdiomBracket -> "an idiom bracket" + SymCloseIdiomBracket -> "an idiom bracket" + SymDoubleOpenBrace -> "used for instance arguments" + SymDoubleCloseBrace -> "used for instance arguments" + SymOpenBrace -> "used for hidden arguments" + SymCloseBrace -> "used for hidden arguments" + SymOpenVirtualBrace -> __IMPOSSIBLE__ + SymCloseVirtualBrace -> __IMPOSSIBLE__ + SymOpenPragma -> __IMPOSSIBLE__ -- "used for pragmas" + SymClosePragma -> __IMPOSSIBLE__ -- "used for pragmas" + SymEllipsis -> "used for function clauses" + SymDotDot -> __IMPOSSIBLE__ -- "a modality" + SymEndComment -> "the end-of-comment brace" + TokString{} -> __IMPOSSIBLE__ + TokSetN{} -> "a type universe" + TokPropN{} -> "a prop universe" + TokTeX{} -> __IMPOSSIBLE__ -- used by the LaTeX backend only + TokMarkup{} -> __IMPOSSIBLE__ -- ditto + TokComment{} -> __IMPOSSIBLE__ + TokDummy{} -> __IMPOSSIBLE__ + TokEOF{} -> __IMPOSSIBLE__ + + -- we know that there are no two Ids in a row + alternating (Hole : Hole : _) = False + alternating (_ : xs) = alternating xs + alternating [] = True + +-- | Create a qualified name from a list of strings +mkQName :: [(Interval, String)] -> Parser QName +mkQName ss = do + xs <- mapM mkName ss + return $ foldr Qual (QName $ last xs) (init xs) + +-- | Create a DomainFree binding from a name + +mkDomainFree_ :: (NamedArg Binder -> NamedArg Binder) -> Maybe Pattern -> Name -> LamBinding +mkDomainFree_ f p n = DomainFree $ f $ defaultNamedArg $ Binder p $ mkBoundName_ n + +mkRString :: (Interval, String) -> RString +mkRString (i, s) = Ranged (getRange i) s + +-- | Create a qualified name from a string (used in pragmas). +-- Range of each name component is range of whole string. +-- TODO: precise ranges! + +pragmaQName :: (Interval, String) -> Parser QName +pragmaQName (r, s) = do + let ss = chopWhen (== '.') s + mkQName $ map (r,) ss + +mkNamedArg :: Maybe QName -> Either QName Range -> Parser (NamedArg BoundName) +mkNamedArg x y = do + lbl <- case x of + Nothing -> return $ Just $ WithOrigin UserWritten $ unranged "_" + Just (QName x) -> return $ Just $ WithOrigin UserWritten $ Ranged (getRange x) $ prettyShow x + _ -> parseError "expected unqualified variable name" + var <- case y of + Left (QName y) -> return $ mkBoundName y noFixity' + Right r -> return $ mkBoundName (noName r) noFixity' + _ -> parseError "expected unqualified variable name" + return $ defaultArg $ Named lbl var + +-- | Polarity parser. + +polarity :: (Interval, String) -> Parser (Range, Occurrence) +polarity (i, s) = + case s of + "_" -> ret Unused + "++" -> ret StrictPos + "+" -> ret JustPos + "-" -> ret JustNeg + "*" -> ret Mixed + _ -> parseError $ "Not a valid polarity: " ++ s + where + ret x = return (getRange i, x) + +recoverLayout :: [(Interval, String)] -> String +recoverLayout [] = "" +recoverLayout xs@((i, _) : _) = go (iStart i) xs + where + c0 = posCol (iStart i) + + go cur [] = "" + go cur ((i, s) : xs) = padding cur (iStart i) ++ s ++ go (iEnd i) xs + + padding Pn{ posLine = l1, posCol = c1 } Pn{ posLine = l2, posCol = c2 } + | l1 < l2 = genericReplicate (l2 - l1) '\n' ++ genericReplicate (max 0 (c2 - c0)) ' ' + | l1 == l2 = genericReplicate (c2 - c1) ' ' + +ensureUnqual :: QName -> Parser Name +ensureUnqual (QName x) = return x +ensureUnqual q@Qual{} = parseError' (rStart' $ getRange q) "Qualified name not allowed here" + +-- | Match a particular name. +isName :: String -> (Interval, String) -> Parser () +isName s (_,s') + | s == s' = return () + | otherwise = parseError $ "expected " ++ s ++ ", found " ++ s' + +-- | Build a forall pi (forall x y z -> ...) +forallPi :: [LamBinding] -> Expr -> Expr +forallPi bs e = Pi (map addType bs) e + +-- | Builds a 'RawApp' from 'Range' and 'Expr' list, unless the list +-- is a single expression. In the latter case, just the 'Expr' is +-- returned. +rawAppUnlessSingleton :: Range -> [Expr] -> Expr +rawAppUnlessSingleton r = \case + [] -> __IMPOSSIBLE__ + [e] -> e + es -> RawApp r es + +-- | Converts lambda bindings to typed bindings. +addType :: LamBinding -> TypedBinding +addType (DomainFull b) = b +addType (DomainFree x) = TBind r [x] $ Underscore r Nothing + where r = getRange x + +-- | Interpret an expression as a list of names and (not parsed yet) as-patterns + +exprAsTele :: Expr -> [Expr] +exprAsTele (RawApp _ es) = es +exprAsTele e = [e] + +exprAsNamesAndPatterns :: Expr -> Maybe [(Name, Maybe Expr)] +exprAsNamesAndPatterns = mapM exprAsNameAndPattern . exprAsTele + +exprAsNameAndPattern :: Expr -> Maybe (Name, Maybe Expr) +exprAsNameAndPattern (Ident (QName x)) = Just (x, Nothing) +exprAsNameAndPattern (Underscore r _) = Just (Name r InScope [Hole], Nothing) +exprAsNameAndPattern (As _ n e) = Just (n, Just e) +exprAsNameAndPattern (Paren r e) = Just (Name r InScope [Hole], Just e) +exprAsNameAndPattern _ = Nothing + +-- interpret an expression as name or list of hidden / instance names +exprAsNameOrHiddenNames :: Expr -> Maybe [NamedArg (Name, Maybe Expr)] +exprAsNameOrHiddenNames t = case t of + HiddenArg _ (Named Nothing e) -> do + nps <- exprAsNamesAndPatterns e + pure $ map (hide . defaultNamedArg) nps + InstanceArg _ (Named Nothing e) -> do + nps <- exprAsNamesAndPatterns e + pure $ map (makeInstance . defaultNamedArg) nps + e -> (pure . defaultNamedArg) `fmap` exprAsNameAndPattern e + +boundNamesOrAbsurd :: [Expr] -> Parser (Either [NamedArg Binder] [Expr]) +boundNamesOrAbsurd es + | any isAbsurd es = return $ Right es + | otherwise = + case mapM exprAsNameAndPattern es of + Nothing -> parseError $ "expected sequence of bound identifiers" + Just good -> fmap Left $ forM good $ \ (n, me) -> do + p <- traverse exprToPattern me + return (defaultNamedArg (Binder p (mkBoundName_ n))) + + where + + isAbsurd :: Expr -> Bool + isAbsurd (Absurd _) = True + isAbsurd (HiddenArg _ (Named _ e)) = isAbsurd e + isAbsurd (InstanceArg _ (Named _ e)) = isAbsurd e + isAbsurd (Paren _ e) = isAbsurd e + isAbsurd (As _ _ e) = isAbsurd e + isAbsurd (RawApp _ es) = any isAbsurd es + isAbsurd _ = False + +-- | Match a pattern-matching "assignment" statement @p <- e@ +exprToAssignment :: Expr -> Parser (Maybe (Pattern, Range, Expr)) +exprToAssignment (RawApp r es) + | (es1, arr : es2) <- break isLeftArrow es = + case filter isLeftArrow es2 of + arr : _ -> parseError' (rStart' $ getRange arr) $ "Unexpected " ++ prettyShow arr + [] -> Just <$> ((,,) <$> exprToPattern (RawApp (getRange es1) es1) + <*> pure (getRange arr) + <*> pure (RawApp (getRange es2) es2)) + where + isLeftArrow (Ident (QName (Name _ _ [Id arr]))) = arr `elem` ["<-", "←"] + isLeftArrow _ = False +exprToAssignment _ = pure Nothing + +-- | Build a with-block +buildWithBlock :: [Either RewriteEqn [Expr]] -> Parser ([RewriteEqn], [Expr]) +buildWithBlock rees = case groupByEither rees of + (Left rs : rest) -> (rs,) <$> finalWith rest + rest -> ([],) <$> finalWith rest + + where + + finalWith :: [Either [RewriteEqn] [[Expr]]] -> Parser [Expr] + finalWith [] = pure $ [] + finalWith [Right ees] = pure $ concat ees + finalWith (Right{} : tl) = parseError' (rStart' $ getRange tl) + "Cannot use rewrite / pattern-matching with after a with-abstraction." + +-- | Build a with-statement +buildWithStmt :: Expr -> Parser [Either RewriteEqn [Expr]] +buildWithStmt e = do + es <- mapM buildSingleWithStmt $ fromWithApp e + let ees = groupByEither es + pure $ map (mapLeft (Invert ())) ees + +buildSingleWithStmt :: Expr -> Parser (Either (Pattern, Expr) Expr) +buildSingleWithStmt e = do + mpatexpr <- exprToAssignment e + pure $ case mpatexpr of + Just (pat, _, expr) -> Left (pat, expr) + Nothing -> Right e + +fromWithApp :: Expr -> [Expr] +fromWithApp = \case + WithApp _ e es -> e : es + e -> [e] + +-- | Build a do-statement +defaultBuildDoStmt :: Expr -> [LamClause] -> Parser DoStmt +defaultBuildDoStmt e (_ : _) = parseError' (rStart' $ getRange e) "Only pattern matching do-statements can have where clauses." +defaultBuildDoStmt e [] = pure $ DoThen e + +buildDoStmt :: Expr -> [LamClause] -> Parser DoStmt +buildDoStmt (RawApp r [e]) cs = buildDoStmt e cs +buildDoStmt (Let r ds Nothing) [] = return $ DoLet r ds +buildDoStmt e@(RawApp r es) cs = do + mpatexpr <- exprToAssignment e + case mpatexpr of + Just (pat, r, expr) -> pure $ DoBind r pat expr cs + Nothing -> defaultBuildDoStmt e cs +buildDoStmt e cs = defaultBuildDoStmt e cs + + +mergeImportDirectives :: [ImportDirective] -> Parser ImportDirective +mergeImportDirectives is = do + i <- foldl merge (return defaultImportDir) is + verifyImportDirective i + where + merge mi i2 = do + i1 <- mi + let err = parseError' (rStart' $ getRange i2) "Cannot mix using and hiding module directives" + return $ ImportDirective + { importDirRange = fuseRange i1 i2 + , using = mappend (using i1) (using i2) + , hiding = hiding i1 ++ hiding i2 + , impRenaming = impRenaming i1 ++ impRenaming i2 + , publicOpen = publicOpen i1 <|> publicOpen i2 } + +-- | Check that an import directive doesn't contain repeated names +verifyImportDirective :: ImportDirective -> Parser ImportDirective +verifyImportDirective i = + case filter ((>1) . length) + $ group + $ sort xs + of + [] -> return i + yss -> parseErrorRange (head $ concat yss) $ + "Repeated name" ++ s ++ " in import directive: " ++ + concat (intersperse ", " $ map (prettyShow . head) yss) + where + s = case yss of + [_] -> "" + _ -> "s" + where + xs = names (using i) ++ hiding i ++ map renFrom (impRenaming i) + names (Using xs) = xs + names UseEverything = [] + +data RecordDirective + = Induction (Ranged Induction) + | Constructor (Name, IsInstance) + | Eta (Ranged HasEta) + deriving (Eq,Show) + +verifyRecordDirectives :: [RecordDirective] -> Parser (Maybe (Ranged Induction), Maybe HasEta, Maybe (Name, IsInstance)) +verifyRecordDirectives xs + | null rs = return (ltm is, ltm es, ltm cs) + | otherwise = parseErrorRange (head rs) $ "Repeated record directives at: \n" ++ intercalate "\n" (map prettyShow rs) + where + ltm :: [a] -> Maybe a + ltm [] = Nothing + ltm (x:xs) = Just x + errorFromList [] = [] + errorFromList [x] = [] + errorFromList xs = map getRange xs + rs = sort (concat ([errorFromList is, errorFromList es', errorFromList cs])) + is = [ i | Induction i <- xs ] + es' = [ i | Eta i <- xs ] + es = map rangedThing es' + cs = [ i | Constructor i <- xs ] + + +-- | Breaks up a string into substrings. Returns every maximal +-- subsequence of zero or more characters distinct from @'.'@. +-- +-- > splitOnDots "" == [""] +-- > splitOnDots "foo.bar" == ["foo", "bar"] +-- > splitOnDots ".foo.bar" == ["", "foo", "bar"] +-- > splitOnDots "foo.bar." == ["foo", "bar", ""] +-- > splitOnDots "foo..bar" == ["foo", "", "bar"] +splitOnDots :: String -> [String] +splitOnDots "" = [""] +splitOnDots ('.' : s) = [] : splitOnDots s +splitOnDots (c : s) = case splitOnDots s of + p : ps -> (c : p) : ps + + +-- | Returns 'True' iff the name is a valid Haskell (hierarchical) +-- module name. +validHaskellModuleName :: String -> Bool +validHaskellModuleName = all ok . splitOnDots + where + -- Checks if a dot-less module name is well-formed. + ok :: String -> Bool + ok [] = False + ok (c : s) = + isUpper c && + all (\c -> isLower c || c == '_' || + isUpper c || + generalCategory c == DecimalNumber || + c == '\'') + s + +{-------------------------------------------------------------------------- + Patterns + --------------------------------------------------------------------------} + +-- | Turn an expression into a left hand side. +exprToLHS :: Expr -> Parser ([RewriteEqn] -> [WithHiding Expr] -> LHS) +exprToLHS e = (\e rwr wth -> LHS e rwr wth NoEllipsis) <$> exprToPattern e + +-- | Turn an expression into a pattern. Fails if the expression is not a +-- valid pattern. +exprToPattern :: Expr -> Parser Pattern +exprToPattern e = case C.isPattern e of + Nothing -> parseErrorRange e $ "Not a valid pattern: " ++ prettyShow e + Just p -> pure p + +opAppExprToPattern :: OpApp Expr -> Parser Pattern +opAppExprToPattern (SyntaxBindingLambda _ _ _) = parseError "Syntax binding lambda cannot appear in a pattern" +opAppExprToPattern (Ordinary e) = exprToPattern e + +-- | Turn an expression into a name. Fails if the expression is not a +-- valid identifier. +exprToName :: Expr -> Parser Name +exprToName (Ident (QName x)) = return x +exprToName e = parseErrorRange e $ "Not a valid identifier: " ++ prettyShow e + +stripSingletonRawApp :: Expr -> Expr +stripSingletonRawApp (RawApp _ [e]) = stripSingletonRawApp e +stripSingletonRawApp e = e + +isEqual :: Expr -> Maybe (Expr, Expr) +isEqual e = + case stripSingletonRawApp e of + Equal _ a b -> Just (stripSingletonRawApp a, stripSingletonRawApp b) + _ -> Nothing + +-- | When given expression is @e1 = e2@, turn it into a named expression. +-- Call this inside an implicit argument @{e}@ or @{{e}}@, where +-- an equality must be a named argument (rather than a cubical partial match). +maybeNamed :: Expr -> Parser (Named_ Expr) +maybeNamed e = + case isEqual e of + Nothing -> return $ unnamed e + Just (e1, e2) -> do + let succeed x = return $ named (WithOrigin UserWritten $ Ranged (getRange e1) x) e2 + case e1 of + Ident (QName x) -> succeed $ nameToRawName x + -- We could have the following, but names of arguments cannot be _. + -- Underscore{} -> succeed $ "_" + _ -> parseErrorRange e $ "Not a valid named argument: " ++ prettyShow e + +patternSynArgs :: [Either Hiding LamBinding] -> Parser [Arg Name] +patternSynArgs = mapM pSynArg + where + pSynArg Left{} = parseError "Absurd patterns are not allowed in pattern synonyms" + pSynArg (Right DomainFull{}) = parseError "Unexpected type signature in pattern synonym argument" + pSynArg (Right (DomainFree x)) + | let h = getHiding x, h `notElem` [Hidden, NotHidden] + = parseError $ prettyShow h ++ " arguments not allowed to pattern synonyms" + | not (isRelevant x) = parseError "Arguments to pattern synonyms must be relevant" + | otherwise = return $ fmap (boundName . binderName . namedThing) x + +parsePanic s = parseError $ "Internal parser error: " ++ s ++ ". Please report this as a bug." + +{- RHS or type signature -} + +data RHSOrTypeSigs + = JustRHS RHS + | TypeSigsRHS Expr + deriving Show + +patternToNames :: Pattern -> Parser [(ArgInfo, Name)] +patternToNames p = + case p of + IdentP (QName i) -> return [(defaultArgInfo, i)] + WildP r -> return [(defaultArgInfo, C.noName r)] + DotP _ (Ident (QName i)) -> return [(setRelevance Irrelevant defaultArgInfo, i)] + RawAppP _ ps -> concat <$> mapM patternToNames ps + _ -> parseError $ + "Illegal name in type signature: " ++ prettyShow p + +funClauseOrTypeSigs :: [Attr] -> LHS -> RHSOrTypeSigs -> WhereClause -> Parser [Declaration] +funClauseOrTypeSigs attrs lhs mrhs wh = do + -- traceShowM lhs + case mrhs of + JustRHS rhs -> do + unless (null attrs) $ parseErrorRange attrs $ "A function clause cannot have attributes" + return [FunClause lhs rhs wh False] + TypeSigsRHS e -> case wh of + NoWhere -> case lhs of + LHS p _ _ _ | hasEllipsis p -> parseError "The ellipsis ... cannot have a type signature" + LHS _ _ (_:_) _ -> parseError "Illegal: with in type signature" + LHS _ (_:_) _ _ -> parseError "Illegal: rewrite in type signature" + LHS p _ _ _ | hasWithPatterns p -> parseError "Illegal: with patterns in type signature" + LHS p [] [] _ -> forMM (patternToNames p) $ \ (info, x) -> do + info <- applyAttrs attrs info + return $ typeSig info (getTacticAttr attrs) x e + _ -> parseError "A type signature cannot have a where clause" + +parseDisplayPragma :: Range -> Position -> String -> Parser Pragma +parseDisplayPragma r pos s = + case parsePosString pos defaultParseFlags [normal] funclauseParser s of + ParseOk s [FunClause (LHS lhs [] [] _) (RHS rhs) NoWhere ca] | null (parseInp s) -> + return $ DisplayPragma r lhs rhs + _ -> parseError "Invalid DISPLAY pragma. Should have form {-# DISPLAY LHS = RHS #-}." + +typeSig :: ArgInfo -> TacticAttribute -> Name -> Expr -> Declaration +typeSig i tac n e = TypeSig i tac n (Generalized e) + +-- * Attributes + +-- | Parsed attribute. + +data Attr = Attr + { attrRange :: Range -- ^ Range includes the @. + , attrName :: String -- ^ Concrete, user written attribute for error reporting. + , theAttr :: Attribute -- ^ Parsed attribute. + } + +instance HasRange Attr where + getRange = attrRange + +instance SetRange Attr where + setRange r (Attr _ x a) = Attr r x a + +-- | Parse an attribute. +toAttribute :: Expr -> Parser Attr +toAttribute x = maybe failure (return . Attr (getRange x) y) $ exprToAttribute x + where + y = prettyShow x + failure = parseErrorRange x $ "Unknown attribute: " ++ y + +-- | Apply an attribute to thing (usually `Arg`). +-- This will fail if one of the attributes is already set +-- in the thing to something else than the default value. +applyAttr :: (LensAttribute a) => Attr -> a -> Parser a +applyAttr attr@(Attr r x a) = maybe failure return . setPristineAttribute a + where + failure = errorConflictingAttribute attr + +-- | Apply attributes to thing (usually `Arg`). +-- Expects a reversed list of attributes. +-- This will fail if one of the attributes is already set +-- in the thing to something else than the default value. +applyAttrs :: (LensAttribute a) => [Attr] -> a -> Parser a +applyAttrs rattrs arg = do + let attrs = reverse rattrs + checkForUniqueAttribute (isJust . isQuantityAttribute ) attrs + checkForUniqueAttribute (isJust . isRelevanceAttribute) attrs + checkForUniqueAttribute (isJust . isTacticAttribute) attrs + foldM (flip applyAttr) arg attrs + +-- | Set the tactic attribute of a binder +setTacticAttr :: [Attr] -> NamedArg Binder -> NamedArg Binder +setTacticAttr as = updateNamedArg $ fmap $ \ b -> + case getTacticAttr as of + Just t -> b { bnameTactic = Just t } + Nothing -> b + +-- | Get the tactic attribute if present. +getTacticAttr :: [Attr] -> TacticAttribute +getTacticAttr as = + case tacticAttributes [ a | Attr _ _ a <- as ] of + [TacticAttribute e] -> Just e + [] -> Nothing + _ -> __IMPOSSIBLE__ + +-- | Report a parse error if two attributes in the list are of the same kind, +-- thus, present conflicting information. +checkForUniqueAttribute :: (Attribute -> Bool) -> [Attr] -> Parser () +checkForUniqueAttribute p attrs = do + let pAttrs = filter (p . theAttr) attrs + when (length pAttrs >= 2) $ + errorConflictingAttributes pAttrs + +-- | Report an attribute as conflicting (e.g., with an already set value). +errorConflictingAttribute :: Attr -> Parser a +errorConflictingAttribute a = parseErrorRange a $ "Conflicting attribute: " ++ attrName a + +-- | Report attributes as conflicting (e.g., with each other). +-- Precondition: List not emtpy. +errorConflictingAttributes :: [Attr] -> Parser a +errorConflictingAttributes [a] = errorConflictingAttribute a +errorConflictingAttributes as = parseErrorRange as $ + "Conflicting attributes: " ++ unwords (map attrName as) +{-# 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)) :: Bool) +#define GTE(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.>=# m)) :: Bool) +#define EQ(n,m) ((Happy_GHC_Exts.tagToEnum# (n Happy_GHC_Exts.==# m)) :: 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)) :: 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 False + action + | check = indexShortOffAddr happyTable off_i + | 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 `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: diff --git a/doc/release-notes/2.2.0.md b/doc/release-notes/2.2.0.md new file mode 100644 --- /dev/null +++ b/doc/release-notes/2.2.0.md @@ -0,0 +1,102 @@ +Release notes for Agda 2 version 2.2.0 +====================================== + +Important changes since 2.1.2 (which was released 2007-08-16): + +Language +-------- + +* Exhaustive pattern checking. Agda complains if there are missing + clauses in a function definition. + +* Coinductive types are supported. This feature is under + development/evaluation, and may change. + + http://wiki.portal.chalmers.se/agda/agda.php?n=ReferenceManual.Codatatypes + +* Another experimental feature: Sized types, which can make it easier + to explain why your code is terminating. + +* Improved constraint solving for functions with constructor headed + right hand sides. + + http://wiki.portal.chalmers.se/agda/agda.php?n=ReferenceManual.FindingTheValuesOfImplicitArguments + +* A simple, well-typed foreign function interface, which allows use of + Haskell functions in Agda code. + + http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Docs.FFI + +* The tokens `forall`, `->` and `\` can be written as `∀`, `→` and + `λ`. + +* Absurd lambdas: `λ ()` and `λ {}`. + + http://thread.gmane.org/gmane.comp.lang.agda/440 + +* Record fields whose values can be inferred can be omitted. + +* Agda complains if it spots an unreachable clause, or if a pattern + variable "shadows" a hidden constructor of matching type. + + http://thread.gmane.org/gmane.comp.lang.agda/720 + +Tools +----- + +* Case-split: The user interface can replace a pattern variable with + the corresponding constructor patterns. You get one new left-hand + side for every possible constructor. + + http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Main.QuickGuideToEditingTypeCheckingAndCompilingAgdaCode + +* The MAlonzo compiler. + + http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Docs.MAlonzo + +* A new Emacs input method, which contains bindings for many Unicode + symbols, is by default activated in the Emacs mode. + + http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Docs.UnicodeInput + +* Highlighted, hyperlinked HTML can be generated from Agda source + code. + + http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Main.HowToGenerateWebPagesFromSourceCode + +* The command-line interactive mode (`agda -I`) is no longer + supported, but should still work. + + http://thread.gmane.org/gmane.comp.lang.agda/245 + +* Reload times when working on large projects are now considerably + better. + + http://thread.gmane.org/gmane.comp.lang.agda/551 + +Libraries +--------- + +* A standard library is under development. + + http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Libraries.StandardLibrary + +Documentation +------------- + +* The Agda wiki is better organised. It should be easier for a + newcomer to find relevant information now. + + http://wiki.portal.chalmers.se/agda/ + +Infrastructure +-------------- + +* Easy-to-install packages for Windows and Debian/Ubuntu have been + prepared. + + http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Main.Download + +* Agda 2.2.0 is available from Hackage. + + http://hackage.haskell.org/ diff --git a/doc/release-notes/2.2.10.md b/doc/release-notes/2.2.10.md new file mode 100644 --- /dev/null +++ b/doc/release-notes/2.2.10.md @@ -0,0 +1,238 @@ +Release notes for Agda 2 version 2.2.10 +======================================= + +Language +-------- + +* New flag: `--without-K`. + + This flag makes pattern matching more restricted. If the flag is + activated, then Agda only accepts certain case-splits. If the type + of the variable to be split is `D pars ixs`, where `D` is a data (or + record) type, pars stands for the parameters, and `ixs` the indices, + then the following requirements must be satisfied: + + - The indices `ixs` must be applications of constructors to distinct + variables. + + - These variables must not be free in pars. + + The intended purpose of `--without-K` is to enable experiments with + a propositional equality without the K rule. Let us define + propositional equality as follows: + + ```agda + data _≡_ {A : Set} : A → A → Set where + refl : ∀ x → x ≡ x + ``` + + Then the obvious implementation of the J rule is accepted: + + ```agda + J : {A : Set} (P : {x y : A} → x ≡ y → Set) → + (∀ x → P (refl x)) → + ∀ {x y} (x≡y : x ≡ y) → P x≡y + J P p (refl x) = p x + ``` + + The same applies to Christine Paulin-Mohring's version of the J rule: + + ```agda + J′ : {A : Set} {x : A} (P : {y : A} → x ≡ y → Set) → + P (refl x) → + ∀ {y} (x≡y : x ≡ y) → P x≡y + J′ P p (refl x) = p + ``` + + On the other hand, the obvious implementation of the K rule is not + accepted: + + ```agda + K : {A : Set} (P : {x : A} → x ≡ x → Set) → + (∀ x → P (refl x)) → + ∀ {x} (x≡x : x ≡ x) → P x≡x + K P p (refl x) = p x + ``` + + However, we have *not* proved that activation of `--without-K` + ensures that the K rule cannot be proved in some other way. + +* Irrelevant declarations. + + Postulates and functions can be marked as irrelevant by prefixing + the name with a dot when the name is declared. Example: + + ```agda + postulate + .irrelevant : {A : Set} → .A → A + ``` + + Irrelevant names may only be used in irrelevant positions or in + definitions of things which have been declared irrelevant. + + The axiom irrelevant above can be used to define a projection from + an irrelevant record field: + + ```agda + data Subset (A : Set) (P : A → Set) : Set where + _#_ : (a : A) → .(P a) → Subset A P + + elem : ∀ {A P} → Subset A P → A + elem (a # p) = a + + .certificate : ∀ {A P} (x : Subset A P) → P (elem x) + certificate (a # p) = irrelevant p + ``` + + The right-hand side of certificate is relevant, so we cannot define + + ```agda + certificate (a # p) = p + ``` + + (because `p` is irrelevant). However, certificate is declared to be + irrelevant, so it can use the axiom irrelevant. Furthermore the + first argument of the axiom is irrelevant, which means that + irrelevant `p` is well-formed. + + As shown above the axiom irrelevant justifies irrelevant + projections. Previously no projections were generated for irrelevant + record fields, such as the field certificate in the following + record type: + + ```agda + record Subset (A : Set) (P : A → Set) : Set where + constructor _#_ + field + elem : A + .certificate : P elem + ``` + + Now projections are generated automatically for irrelevant fields + (unless the flag `--no-irrelevant-projections` is used). Note that + irrelevant projections are highly experimental. + +* Termination checker recognises projections. + + Projections now preserve sizes, both in patterns and expressions. + Example: + + ```agda + record Wrap (A : Set) : Set where + constructor wrap + field + unwrap : A + + open Wrap public + + data WNat : Set where + zero : WNat + suc : Wrap WNat → WNat + + id : WNat → WNat + id zero = zero + id (suc w) = suc (wrap (id (unwrap w))) + ``` + + In the structural ordering `unwrap w` ≤ `w`. This means that + + ```agda + unwrap w ≤ w < suc w, + ``` + + and hence the recursive call to id is accepted. + + Projections also preserve guardedness. + +Tools +----- + +* Hyperlinks for top-level module names now point to the start of the + module rather than to the declaration of the module name. This + applies both to the Emacs mode and to the output of `agda --html`. + +* Most occurrences of record field names are now highlighted as + "fields". Previously many occurrences were highlighted as + "functions". + +* Emacs mode: It is no longer possible to change the behaviour of the + `TAB` key by customising `agda2-indentation`. + +* Epic compiler backend. + + A new compiler backend is being implemented. This backend makes use + of Edwin Brady's language Epic + (http://www.cs.st-andrews.ac.uk/~eb/epic.php) and its compiler. The + backend should handle most Agda code, but is still at an + experimental stage: more testing is needed, and some things written + below may not be entirely true. + + The Epic compiler can be invoked from the command line using the + flag `--epic`: + + ``` + agda --epic --epic-flag= --compile-dir= .agda + ``` + + The `--epic-flag` flag can be given multiple times; each flag is + given verbatim to the Epic compiler (in the given order). The + resulting executable is named after the main module and placed in + the directory specified by the `--compile-dir` flag (default: the + project root). Intermediate files are placed in a subdirectory + called `Epic`. + + The backend requires that there is a definition named main. This + definition should be a value of type `IO Unit`, but at the moment + this is not checked (so it is easy to produce a program which + segfaults). Currently the backend represents actions of type `IO A` + as functions from `Unit` to `A`, and main is applied to the unit + value. + + The Epic compiler compiles via C, not Haskell, so the pragmas + related to the Haskell FFI (`IMPORT`, `COMPILED_DATA` and + `COMPILED`) are not used by the Epic backend. Instead there is a new + pragma `COMPILED_EPIC`. This pragma is used to give Epic code for + postulated definitions (Epic code can in turn call C code). The form + of the pragma is `{-# COMPILED_EPIC def code #-}`, where `def` is + the name of an Agda postulate and `code` is some Epic code which + should include the function arguments, return type and function + body. As an example the `IO` monad can be defined as follows: + + ```agda + postulate + IO : Set → Set + return : ∀ {A} → A → IO A + _>>=_ : ∀ {A B} → IO A → (A → IO B) → IO B + + {-# COMPILED_EPIC return (u : Unit, a : Any) -> Any = + ioreturn(a) #-} + {-# COMPILED_EPIC + _>>=_ (u1 : Unit, u2 : Unit, x : Any, f : Any) -> Any = + iobind(x,f) #-} + ``` + + Here `ioreturn` and `iobind` are Epic functions which are defined in + the file `AgdaPrelude.e` which is always included. + + By default the backend will remove so-called forced constructor + arguments (and case-splitting on forced variables will be + rewritten). This optimisation can be disabled by using the flag + `--no-forcing`. + + All data types which look like unary natural numbers after forced + constructor arguments have been removed (i.e. types with two + constructors, one nullary and one with a single recursive argument) + will be represented as "BigInts". This applies to the standard `Fin` + type, for instance. + + The backend supports Agda's primitive functions and the BUILTIN + pragmas. If the BUILTIN pragmas for unary natural numbers are used, + then some operations, like addition and multiplication, will use + more efficient "BigInt" operations. + + If you want to make use of the Epic backend you need to install some + dependencies, see the README. + +* The Emacs mode can compile using either the MAlonzo or the Epic + backend. The variable `agda2-backend` controls which backend is + used. diff --git a/doc/release-notes/2.2.2.md b/doc/release-notes/2.2.2.md new file mode 100644 --- /dev/null +++ b/doc/release-notes/2.2.2.md @@ -0,0 +1,22 @@ +Release notes for Agda 2 version 2.2.2 +====================================== + +Tools +----- + +* The `--malonzodir` option has been renamed to `--malonzo-dir`. + +* The output of `agda --html` is by default placed in a directory + called `html`. + +Infrastructure +-------------- + +* The Emacs mode is included in the Agda Cabal package, and installed + by `cabal install`. The recommended way to enable the Emacs mode is + to include the following code in `.emacs`: + + ```elisp + (load-file (let ((coding-system-for-read 'utf-8)) + (shell-command-to-string "agda-mode locate"))) + ``` diff --git a/doc/release-notes/2.2.4.md b/doc/release-notes/2.2.4.md new file mode 100644 --- /dev/null +++ b/doc/release-notes/2.2.4.md @@ -0,0 +1,54 @@ +Release notes for Agda 2 version 2.2.4 +====================================== + +Important changes since 2.2.2: + +* Change to the semantics of `open import` and `open module`. The + declaration + + ```agda + open import M + ``` + + now translates to + + ```agda + import A + open A + ``` + + instead of + + ```agda + import A + open A + ``` + + The same translation is used for `open module M = E …`. Declarations + involving the keywords as or public are changed in a corresponding + way (`as` always goes with import, and `public` always with open). + + This change means that import directives do not affect the qualified + names when open import/module is used. To get the old behaviour you + can use the expanded version above. + +* Names opened publicly in parameterised modules no longer inherit the + module parameters. Example: + + ```agda + module A where + postulate X : Set + + module B (Y : Set) where + open A public + ``` + + In Agda 2.2.2 `B.X` has type `(Y : Set) → Set`, whereas in + Agda 2.2.4 `B.X` has type Set. + +* Previously it was not possible to export a given constructor name + through two different `open public` statements in the same module. + This is now possible. + +* Unicode subscript digits are now allowed for the hierarchy of + universes (`Set₀`, `Set₁`, …): `Set₁` is equivalent to `Set1`. diff --git a/doc/release-notes/2.2.6.md b/doc/release-notes/2.2.6.md new file mode 100644 --- /dev/null +++ b/doc/release-notes/2.2.6.md @@ -0,0 +1,290 @@ +Release notes for Agda 2 version 2.2.6 +====================================== + +Language +-------- + +* Universe polymorphism (experimental extension). + + To enable universe polymorphism give the flag + `--universe-polymorphism` on the command line or (recommended) as an + `OPTIONS` pragma. + + When universe polymorphism is enabled `Set` takes an argument which is + the universe level. For instance, the type of universe polymorphic + identity is + + ```agda + id : {a : Level} {A : Set a} → A → A. + ``` + + The type Level is isomorphic to the unary natural numbers and should + be specified using the BUILTINs `LEVEL`, `LEVELZERO`, and + `LEVELSUC`: + + ```agda + data Level : Set where + zero : Level + suc : Level → Level + + {-# BUILTIN LEVEL Level #-} + {-# BUILTIN LEVELZERO zero #-} + {-# BUILTIN LEVELSUC suc #-} + ``` + + There is an additional BUILTIN `LEVELMAX` for taking the maximum of two + levels: + + ```agda + max : Level → Level → Level + max zero m = m + max (suc n) zero = suc n + max (suc n) (suc m) = suc (max n m) + + {-# BUILTIN LEVELMAX max #-} + ``` + + The non-polymorphic universe levels `Set`, `Set₁` and so on are + sugar for `Set zero`, `Set (suc zero)`, etc. + + At present there is no automatic lifting of types from one level to + another. It can still be done (rather clumsily) by defining types + like the following one: + + ```agda + data Lifted {a} (A : Set a) : Set (suc a) where + lift : A → Lifted A + ``` + + However, it is likely that automatic lifting is introduced at some + point in the future. + +* Multiple constructors, record fields, postulates or primitives can + be declared using a single type signature: + + ```agda + data Bool : Set where + false true : Bool + + postulate + A B : Set + ``` + +* Record fields can be implicit: + + ```agda + record R : Set₁ where + field + {A} : Set + f : A → A + {B C} D {E} : Set + g : B → C → E + ``` + + By default implicit fields are not printed. + +* Record constructors can be defined: + + ```agda + record Σ (A : Set) (B : A → Set) : Set where + constructor _,_ + field + proj₁ : A + proj₂ : B proj₁ + ``` + + In this example `_,_` gets the type + + ```agda + (proj₁ : A) → B proj₁ → Σ A B. + ``` + + For implicit fields the corresponding constructor arguments become + implicit. + + Note that the constructor is defined in the *outer* scope, so any + fixity declaration has to be given outside the record definition. + The constructor is not in scope inside the record module. + + Note also that pattern matching for records has not been implemented + yet. + +* BUILTIN hooks for equality. + + The data type + + ```agda + data _≡_ {A : Set} (x : A) : A → Set where + refl : x ≡ x + ``` + + can be specified as the builtin equality type using the following + pragmas: + + ```agda + {-# BUILTIN EQUALITY _≡_ #-} + {-# BUILTIN REFL refl #-} + ``` + + The builtin equality is used for the new rewrite construct and + the `primTrustMe` primitive described below. + +* New `rewrite` construct. + + If `eqn : a ≡ b`, where `_≡_` is the builtin equality (see above) you + can now write + + ```agda + f ps rewrite eqn = rhs + ``` + + instead of + + ```agda + f ps with a | eqn + ... | ._ | refl = rhs + ``` + + The `rewrite` construct has the effect of rewriting the goal and the + context by the given equation (left to right). + + You can rewrite using several equations (in sequence) by separating + them with vertical bars (|): + + ```agda + f ps rewrite eqn₁ | eqn₂ | … = rhs + ``` + + It is also possible to add `with`-clauses after rewriting: + + ```agda + f ps rewrite eqns with e + ... | p = rhs + ``` + + Note that pattern matching happens before rewriting—if you want to + rewrite and then do pattern matching you can use a with after the + rewrite. + + See `test/Succeed/Rewrite.agda` for some examples. + +* A new primitive, `primTrustMe`, has been added: + + ```agda + primTrustMe : {A : Set} {x y : A} → x ≡ y + ``` + + Here `_≡_` is the builtin equality (see BUILTIN hooks for equality, + above). + + If `x` and `y` are definitionally equal, then + `primTrustMe {x = x} {y = y}` reduces to `refl`. + + Note that the compiler replaces all uses of `primTrustMe` with the + `REFL` builtin, without any check for definitional + equality. Incorrect uses of `primTrustMe` can potentially lead to + segfaults or similar problems. + + For an example of the use of `primTrustMe`, see `Data.String` in + version 0.3 of the standard library, where it is used to implement + decidable equality on strings using the primitive boolean equality. + +* Changes to the syntax and semantics of IMPORT pragmas, which are + used by the Haskell FFI. Such pragmas must now have the following + form: + + ```agda + {-# IMPORT #-} + ``` + + These pragmas are interpreted as *qualified* imports, so Haskell + names need to be given qualified (unless they come from the Haskell + prelude). + +* The horizontal tab character (U+0009) is no longer treated as white + space. + +* Line pragmas are no longer supported. + +* The `--include-path` flag can no longer be used as a pragma. + +* The experimental and incomplete support for proof irrelevance has + been disabled. + +Tools +----- + +* New `intro` command in the Emacs mode. When there is a canonical way + of building something of the goal type (for instance, if the goal + type is a pair), the goal can be refined in this way. The command + works for the following goal types: + + - A data type where only one of its constructors can be used to + construct an element of the goal type. (For instance, if the + goal is a non-empty vector, a `cons` will be introduced.) + + - A record type. A record value will be introduced. Implicit + fields will not be included unless showing of implicit arguments + is switched on. + + - A function type. A lambda binding as many variables as possible + will be introduced. The variable names will be chosen from the + goal type if its normal form is a dependent function type, + otherwise they will be variations on `x`. Implicit lambdas will + only be inserted if showing of implicit arguments is switched + on. + + This command can be invoked by using the `refine` command + (`C-c C-r`) when the goal is empty. (The old behaviour of the refine + command in this situation was to ask for an expression using the + minibuffer.) + +* The Emacs mode displays `Checked` in the mode line if the current + file type checked successfully without any warnings. + +* If a file `F` is loaded, and this file defines the module `M`, it is + an error if `F` is not the file which defines `M` according to the + include path. + + Note that the command-line tool and the Emacs mode define the + meaning of relative include paths differently: the command-line tool + interprets them relative to the current working directory, whereas + the Emacs mode interprets them relative to the root directory of the + current project. (As an example, if the module `A.B.C` is loaded + from the file `/A/B/C.agda`, then the root directory is + ``.) + +* It is an error if there are several files on the include path which + match a given module name. + +* Interface files are relocatable. You can move around source trees as + long as the include path is updated in a corresponding way. Note + that a module `M` may be re-typechecked if its time stamp is + strictly newer than that of the corresponding interface file + (`M.agdai`). + +* Type-checking is no longer done when an up-to-date interface exists. + (Previously the initial module was always type-checked.) + +* Syntax highlighting files for Emacs (`.agda.el`) are no longer used. + The `--emacs` flag has been removed. (Syntax highlighting + information is cached in the interface files.) + +* The Agate and Alonzo compilers have been retired. The options + `--agate`, `--alonzo` and `--malonzo` have been removed. + +* The default directory for MAlonzo output is the project's root + directory. The `--malonzo-dir` flag has been renamed to + `--compile-dir`. + +* Emacs mode: `C-c C-x C-d` no longer resets the type checking state. + `C-c C-x C-r` can be used for a more complete reset. `C-c C-x C-s` + (which used to reload the syntax highlighting information) has been + removed. `C-c C-l` can be used instead. + +* The Emacs mode used to define some "abbrevs", unless the user + explicitly turned this feature off. The new default is *not* to add + any abbrevs. The old default can be obtained by customising + `agda2-mode-abbrevs-use-defaults` (a customisation buffer can be + obtained by typing `M-x customize-group agda2 RET` after an Agda + file has been loaded). diff --git a/doc/release-notes/2.2.8.md b/doc/release-notes/2.2.8.md new file mode 100644 --- /dev/null +++ b/doc/release-notes/2.2.8.md @@ -0,0 +1,626 @@ +Release notes for Agda 2 version 2.2.8 +====================================== + +Language +-------- + +* Record pattern matching. + + It is now possible to pattern match on named record constructors. + Example: + + ```agda + record Σ (A : Set) (B : A → Set) : Set where + constructor _,_ + field + proj₁ : A + proj₂ : B proj₁ + + map : {A B : Set} {P : A → Set} {Q : B → Set} + (f : A → B) → (∀ {x} → P x → Q (f x)) → + Σ A P → Σ B Q + map f g (x , y) = (f x , g y) + ``` + + The clause above is internally translated into the following one: + + ```agda + map f g p = (f (Σ.proj₁ p) , g (Σ.proj₂ p)) + ``` + + Record patterns containing data type patterns are not translated. + Example: + + ```agda + add : ℕ × ℕ → ℕ + add (zero , n) = n + add (suc m , n) = suc (add (m , n)) + ``` + + Record patterns which do not contain data type patterns, but which + do contain dot patterns, are currently rejected. Example: + + ```agda + Foo : {A : Set} (p₁ p₂ : A × A) → proj₁ p₁ ≡ proj₁ p₂ → Set₁ + Foo (x , y) (.x , y′) refl = Set + ``` + +* Proof irrelevant function types. + + Agda now supports irrelevant non-dependent function types: + + ```agda + f : .A → B + ``` + + This type implies that `f` does not depend computationally on its + argument. One intended use case is data structures with embedded + proofs, like sorted lists: + + ```agda + postulate + _≤_ : ℕ → ℕ → Set + p₁ : 0 ≤ 1 + p₂ : 0 ≤ 1 + + data SList (bound : ℕ) : Set where + [] : SList bound + scons : (head : ℕ) → + .(head ≤ bound) → + (tail : SList head) → + SList bound + ``` + + The effect of the irrelevant type in the signature of `scons` is + that `scons`'s second argument is never inspected after Agda has + ensured that it has the right type. It is even thrown away, leading + to smaller term sizes and hopefully some gain in efficiency. The + type-checker ignores irrelevant arguments when checking equality, so + two lists can be equal even if they contain different proofs: + + ```agda + l₁ : SList 1 + l₁ = scons 0 p₁ [] + + l₂ : SList 1 + l₂ = scons 0 p₂ [] + + l₁≡l₂ : l₁ ≡ l₂ + l₁≡l₂ = refl + ``` + + Irrelevant arguments can only be used in irrelevant contexts. + Consider the following subset type: + + ```agda + data Subset (A : Set) (P : A → Set) : Set where + _#_ : (elem : A) → .(P elem) → Subset A P + ``` + + The following two uses are fine: + + ```agda + elimSubset : ∀ {A C : Set} {P} → + Subset A P → ((a : A) → .(P a) → C) → C + elimSubset (a # p) k = k a p + + elem : {A : Set} {P : A → Set} → Subset A P → A + elem (x # p) = x + ``` + + However, if we try to project out the proof component, then Agda + complains that `variable p is declared irrelevant, so it cannot be + used here`: + + ```agda + prjProof : ∀ {A P} (x : Subset A P) → P (elem x) + prjProof (a # p) = p + ``` + + Matching against irrelevant arguments is also forbidden, except in + the case of irrefutable matches (record constructor patterns which + have been translated away). For instance, the match against the + pattern `(p , q)` here is accepted: + + ```agda + elim₂ : ∀ {A C : Set} {P Q : A → Set} → + Subset A (λ x → Σ (P x) (λ _ → Q x)) → + ((a : A) → .(P a) → .(Q a) → C) → C + elim₂ (a # (p , q)) k = k a p q + ``` + + Absurd matches `()` are also allowed. + + Note that record fields can also be irrelevant. Example: + + ```agda + record Subset (A : Set) (P : A → Set) : Set where + constructor _#_ + field + elem : A + .proof : P elem + ``` + + Irrelevant fields are never in scope, neither inside nor outside the + record. This means that no record field can depend on an irrelevant + field, and furthermore projections are not defined for such fields. + Irrelevant fields can only be accessed using pattern matching, as in + `elimSubset` above. + + Irrelevant function types were added very recently, and have not + been subjected to much experimentation yet, so do not be surprised + if something is changed before the next release. For instance, + dependent irrelevant function spaces (`.(x : A) → B`) might be added + in the future. + +* Mixfix binders. + + It is now possible to declare user-defined syntax that binds + identifiers. Example: + + ```agda + postulate + State : Set → Set → Set + put : ∀ {S} → S → State S ⊤ + get : ∀ {S} → State S S + return : ∀ {A S} → A → State S A + bind : ∀ {A B S} → State S B → (B → State S A) → State S A + + syntax bind e₁ (λ x → e₂) = x ← e₁ , e₂ + + increment : State ℕ ⊤ + increment = x ← get , + put (1 + x) + ``` + + The syntax declaration for `bind` implies that `x` is in scope in + `e₂`, but not in `e₁`. + + You can give fixity declarations along with syntax declarations: + + ```agda + infixr 40 bind + syntax bind e₁ (λ x → e₂) = x ← e₁ , e₂ + ``` + + The fixity applies to the syntax, not the name; syntax declarations + are also restricted to ordinary, non-operator names. The following + declaration is disallowed: + + ```agda + syntax _==_ x y = x === y + ```agda + + Syntax declarations must also be linear; the following declaration + is disallowed: + + ```agda + syntax wrong x = x + x + ``` + + Syntax declarations were added very recently, and have not been + subjected to much experimentation yet, so do not be surprised if + something is changed before the next release. + +* `Prop` has been removed from the language. + + The experimental sort `Prop` has been disabled. Any program using + `Prop` should typecheck if `Prop` is replaced by `Set₀`. Note that + `Prop` is still a keyword. + +* Injective type constructors off by default. + + Automatic injectivity of type constructors has been disabled (by + default). To enable it, use the flag + `--injective-type-constructors`, either on the command line or in an + `OPTIONS` pragma. Note that this flag makes Agda anti-classical and + possibly inconsistent: + + Agda with excluded middle is inconsistent + http://thread.gmane.org/gmane.comp.lang.agda/1367 + + See `test/Succeed/InjectiveTypeConstructors.agda` for an example. + +* Termination checker can count. + + There is a new flag `--termination-depth=N` accepting values `N >= + 1` (with `N = 1` being the default) which influences the behavior of + the termination checker. So far, the termination checker has only + distinguished three cases when comparing the argument of a recursive + call with the formal parameter of the callee. + + `<`: the argument is structurally smaller than the parameter + + `=`: they are equal + + `?`: the argument is bigger or unrelated to the parameter + + This behavior, which is still the default (`N = 1`), will not + recognise the following functions as terminating. + + ```agda + mutual + + f : ℕ → ℕ + f zero = zero + f (suc zero) = zero + f (suc (suc n)) = aux n + + aux : ℕ → ℕ + aux m = f (suc m) + ``` + + The call graph + + ``` + f --(<)--> aux --(?)--> f + ``` + + yields a recursive call from `f` to `f` via `aux` where the relation + of call argument to callee parameter is computed as "unrelated" + (composition of `<` and `?`). + + Setting `N >= 2` allows a finer analysis: `n` has two constructors + less than `suc (suc n)`, and `suc m` has one more than `m`, so we get the + call graph: + + ``` + f --(-2)--> aux --(+1)--> f + ``` + + The indirect call `f --> f` is now labeled with `(-1)`, and the + termination checker can recognise that the call argument is + decreasing on this path. + + Setting the termination depth to `N` means that the termination + checker counts decrease up to `N` and increase up to `N-1`. The + default, `N=1`, means that no increase is counted, every increase + turns to "unrelated". + + In practice, examples like the one above sometimes arise when `with` + is used. As an example, the program + + ```agda + f : ℕ → ℕ + f zero = zero + f (suc zero) = zero + f (suc (suc n)) with zero + ... | _ = f (suc n) + ``` + + is internally represented as + + ```agda + mutual + + f : ℕ → ℕ + f zero = zero + f (suc zero) = zero + f (suc (suc n)) = aux n zero + + aux : ℕ → ℕ → ℕ + aux m k = f (suc m) + ``` + + Thus, by default, the definition of `f` using `with` is not accepted + by the termination checker, even though it looks structural (`suc n` + is a subterm of `suc suc n`). Now, the termination checker is + satisfied if the option `--termination-depth=2` is used. + + Caveats: + + - This is an experimental feature, hopefully being replaced by + something smarter in the near future. + + - Increasing the termination depth will quickly lead to very long + termination checking times. So, use with care. Setting termination + depth to `100` by habit, just to be on the safe side, is not a good + idea! + + - Increasing termination depth only makes sense for linear data + types such as `ℕ` and `Size`. For other types, increase cannot be + recognised. For instance, consider a similar example with lists. + + ```agda + data List : Set where + nil : List + cons : ℕ → List → List + + mutual + f : List → List + f nil = nil + f (cons x nil) = nil + f (cons x (cons y ys)) = aux y ys + + aux : ℕ → List → List + aux z zs = f (cons z zs) + ``` + + Here the termination checker compares `cons z zs` to `z` and also + to `zs`. In both cases, the result will be "unrelated", no matter + how high we set the termination depth. This is because when + comparing `cons z zs` to `zs`, for instance, `z` is unrelated to + `zs`, thus, `cons z zs` is also unrelated to `zs`. We cannot say + it is just "one larger" since `z` could be a very large term. Note + that this points to a weakness of untyped termination checking. + + To regain the benefit of increased termination depth, we need to + index our lists by a linear type such as `ℕ` or `Size`. With + termination depth `2`, the above example is accepted for vectors + instead of lists. + +* The `codata` keyword has been removed. To use coinduction, use the + following new builtins: `INFINITY`, `SHARP` and `FLAT`. Example: + + ```agda + {-# OPTIONS --universe-polymorphism #-} + + module Coinduction where + + open import Level + + infix 1000 ♯_ + + postulate + ∞ : ∀ {a} (A : Set a) → Set a + ♯_ : ∀ {a} {A : Set a} → A → ∞ A + ♭ : ∀ {a} {A : Set a} → ∞ A → A + + {-# BUILTIN INFINITY ∞ #-} + {-# BUILTIN SHARP ♯_ #-} + {-# BUILTIN FLAT ♭ #-} + ``` + + Note that (non-dependent) pattern matching on `SHARP` is no longer + allowed. + + Note also that strange things might happen if you try to combine the + pragmas above with `COMPILED_TYPE`, `COMPILED_DATA` or `COMPILED` + pragmas, or if the pragmas do not occur right after the postulates. + + The compiler compiles the `INFINITY` builtin to nothing (more or + less), so that the use of coinduction does not get in the way of FFI + declarations: + + ```agda + data Colist (A : Set) : Set where + [] : Colist A + _∷_ : (x : A) (xs : ∞ (Colist A)) → Colist A + + {-# COMPILED_DATA Colist [] [] (:) #-} + ``` + +* Infinite types. + + If the new flag `--guardedness-preserving-type-constructors` is + used, then type constructors are treated as inductive constructors + when we check productivity (but only in parameters, and only if they + are used strictly positively or not at all). This makes examples + such as the following possible: + + ```agda + data Rec (A : ∞ Set) : Set where + fold : ♭ A → Rec A + + -- Σ cannot be a record type below. + + data Σ (A : Set) (B : A → Set) : Set where + _,_ : (x : A) → B x → Σ A B + + syntax Σ A (λ x → B) = Σ[ x ∶ A ] B + + -- Corecursive definition of the W-type. + + W : (A : Set) → (A → Set) → Set + W A B = Rec (♯ (Σ[ x ∶ A ] (B x → W A B))) + + syntax W A (λ x → B) = W[ x ∶ A ] B + + sup : {A : Set} {B : A → Set} (x : A) (f : B x → W A B) → W A B + sup x f = fold (x , f) + + W-rec : {A : Set} {B : A → Set} + (P : W A B → Set) → + (∀ {x} {f : B x → W A B} → (∀ y → P (f y)) → P (sup x f)) → + ∀ x → P x + W-rec P h (fold (x , f)) = h (λ y → W-rec P h (f y)) + + -- Induction-recursion encoded as corecursion-recursion. + + data Label : Set where + ′0 ′1 ′2 ′σ ′π ′w : Label + + mutual + + U : Set + U = Σ Label U′ + + U′ : Label → Set + U′ ′0 = ⊤ + U′ ′1 = ⊤ + U′ ′2 = ⊤ + U′ ′σ = Rec (♯ (Σ[ a ∶ U ] (El a → U))) + U′ ′π = Rec (♯ (Σ[ a ∶ U ] (El a → U))) + U′ ′w = Rec (♯ (Σ[ a ∶ U ] (El a → U))) + + El : U → Set + El (′0 , _) = ⊥ + El (′1 , _) = ⊤ + El (′2 , _) = Bool + El (′σ , fold (a , b)) = Σ[ x ∶ El a ] El (b x) + El (′π , fold (a , b)) = (x : El a) → El (b x) + El (′w , fold (a , b)) = W[ x ∶ El a ] El (b x) + + U-rec : (P : ∀ u → El u → Set) → + P (′1 , _) tt → + P (′2 , _) true → + P (′2 , _) false → + (∀ {a b x y} → + P a x → P (b x) y → P (′σ , fold (a , b)) (x , y)) → + (∀ {a b f} → + (∀ x → P (b x) (f x)) → P (′π , fold (a , b)) f) → + (∀ {a b x f} → + (∀ y → P (′w , fold (a , b)) (f y)) → + P (′w , fold (a , b)) (sup x f)) → + ∀ u (x : El u) → P u x + U-rec P P1 P2t P2f Pσ Pπ Pw = rec + where + rec : ∀ u (x : El u) → P u x + rec (′0 , _) () + rec (′1 , _) _ = P1 + rec (′2 , _) true = P2t + rec (′2 , _) false = P2f + rec (′σ , fold (a , b)) (x , y) = Pσ (rec _ x) (rec _ y) + rec (′π , fold (a , b)) f = Pπ (λ x → rec _ (f x)) + rec (′w , fold (a , b)) (fold (x , f)) = Pw (λ y → rec _ (f y)) + ``` + + The `--guardedness-preserving-type-constructors` extension is based + on a rather operational understanding of `∞`/`♯_`; it's not yet + clear if this extension is consistent. + +* Qualified constructors. + + Constructors can now be referred to qualified by their data type. + For instance, given + + ```agda + data Nat : Set where + zero : Nat + suc : Nat → Nat + + data Fin : Nat → Set where + zero : ∀ {n} → Fin (suc n) + suc : ∀ {n} → Fin n → Fin (suc n) + ``` + + you can refer to the constructors unambiguously as `Nat.zero`, + `Nat.suc`, `Fin.zero`, and `Fin.suc` (`Nat` and `Fin` are modules + containing the respective constructors). Example: + + ```agda + inj : (n m : Nat) → Nat.suc n ≡ suc m → n ≡ m + inj .m m refl = refl + ``` + + Previously you had to write something like + + ```agda + inj : (n m : Nat) → _≡_ {Nat} (suc n) (suc m) → n ≡ m + ``` + + to make the type checker able to figure out that you wanted the + natural number suc in this case. + +* Reflection. + + There are two new constructs for reflection: + + - `quoteGoal x in e` + + In `e` the value of `x` will be a representation of the goal type + (the type expected of the whole expression) as an element in a + datatype of Agda terms (see below). For instance, + + ```agda + example : ℕ + example = quoteGoal x in {! at this point x = def (quote ℕ) [] !} + ``` + + - `quote x : Name` + + If `x` is the name of a definition (function, datatype, record, + or a constructor), `quote x` gives you the representation of `x` + as a value in the primitive type `Name` (see below). + + Quoted terms use the following BUILTINs and primitives (available + from the standard library module `Reflection`): + + ```agda + -- The type of Agda names. + + postulate Name : Set + + {-# BUILTIN QNAME Name #-} + + primitive primQNameEquality : Name → Name → Bool + + -- Arguments. + + Explicit? = Bool + + data Arg A : Set where + arg : Explicit? → A → Arg A + + {-# BUILTIN ARG Arg #-} + {-# BUILTIN ARGARG arg #-} + + -- The type of Agda terms. + + data Term : Set where + var : ℕ → List (Arg Term) → Term + con : Name → List (Arg Term) → Term + def : Name → List (Arg Term) → Term + lam : Explicit? → Term → Term + pi : Arg Term → Term → Term + sort : Term + unknown : Term + + {-# BUILTIN AGDATERM Term #-} + {-# BUILTIN AGDATERMVAR var #-} + {-# BUILTIN AGDATERMCON con #-} + {-# BUILTIN AGDATERMDEF def #-} + {-# BUILTIN AGDATERMLAM lam #-} + {-# BUILTIN AGDATERMPI pi #-} + {-# BUILTIN AGDATERMSORT sort #-} + {-# BUILTIN AGDATERMUNSUPPORTED unknown #-} + ``` + + Reflection may be useful when working with internal decision + procedures, such as the standard library's ring solver. + +* Minor record definition improvement. + + The definition of a record type is now available when type checking + record module definitions. This means that you can define things + like the following: + + ```agda + record Cat : Set₁ where + field + Obj : Set + _=>_ : Obj → Obj → Set + -- ... + + -- not possible before: + op : Cat + op = record { Obj = Obj; _=>_ = λ A B → B => A } + ``` + +Tools +----- + +* The `Goal type and context` command now shows the goal type before + the context, and the context is shown in reverse order. The `Goal + type, context and inferred type` command has been modified in a + similar way. + +* Show module contents command. + + Given a module name `M` the Emacs mode can now display all the + top-level modules and names inside `M`, along with types for the + names. The command is activated using `C-c C-o` or the menus. + +* Auto command. + + A command which searches for type inhabitants has been added. The + command is invoked by pressing `C-C C-a` (or using the goal menu). + There are several flags and parameters, e.g. `-c` which enables + case-splitting in the search. For further information, see the Agda + wiki: + + http://wiki.portal.chalmers.se/agda/pmwiki.php?n=Main.Auto + +* HTML generation is now possible for a module with unsolved + meta-variables, provided that the `--allow-unsolved-metas` flag is + used. diff --git a/doc/release-notes/2.3.0.md b/doc/release-notes/2.3.0.md new file mode 100644 --- /dev/null +++ b/doc/release-notes/2.3.0.md @@ -0,0 +1,1124 @@ +Release notes for Agda 2 version 2.3.0 +====================================== + +Language +-------- + +* New more liberal syntax for mutually recursive definitions. + + It is no longer necessary to use the `mutual` keyword to define + mutually recursive functions or datatypes. Instead, it is enough to + declare things before they are used. Instead of + + ```agda + mutual + f : A + f = a[f, g] + + g : B[f] + g = b[f, g] + ``` + + you can now write + + ```agda + f : A + g : B[f] + f = a[f, g] + g = b[f, g]. + ``` + + With the new style you have more freedom in choosing the order in + which things are type checked (previously type signatures were + always checked before definitions). Furthermore you can mix + arbitrary declarations, such as modules and postulates, with + mutually recursive definitions. + + For data types and records the following new syntax is used to + separate the declaration from the definition: + + ```agda + -- Declaration. + data Vec (A : Set) : Nat → Set -- Note the absence of 'where'. + + -- Definition. + data Vec A where + [] : Vec A zero + _::_ : {n : Nat} → A → Vec A n → Vec A (suc n) + + -- Declaration. + record Sigma (A : Set) (B : A → Set) : Set + + -- Definition. + record Sigma A B where + constructor _,_ + field fst : A + snd : B fst + ``` + + When making separated declarations/definitions private or abstract + you should attach the `private` keyword to the declaration and the + `abstract` keyword to the definition. For instance, a private, + abstract function can be defined as + + ```agda + private + f : A + abstract + f = e + ``` + + Finally it may be worth noting that the old style of mutually + recursive definitions is still supported (it basically desugars into + the new style). + +* Pattern matching lambdas. + + Anonymous pattern matching functions can be defined using the syntax + + ``` + \ { p11 .. p1n -> e1 ; ... ; pm1 .. pmn -> em } + ``` + + (where, as usual, `\` and `->` can be replaced by `λ` and + `→`). Internally this is translated into a function definition of + the following form: + + ``` + .extlam p11 .. p1n = e1 + ... + .extlam pm1 .. pmn = em + ``` + + This means that anonymous pattern matching functions are generative. + For instance, `refl` will not be accepted as an inhabitant of the type + + ```agda + (λ { true → true ; false → false }) ≡ + (λ { true → true ; false → false }), + ``` + + because this is equivalent to `extlam1 ≡ extlam2` for some distinct + fresh names `extlam1` and `extlam2`. + + Currently the `where` and `with` constructions are not allowed in + (the top-level clauses of) anonymous pattern matching functions. + + Examples: + + ```agda + and : Bool → Bool → Bool + and = λ { true x → x ; false _ → false } + + xor : Bool → Bool → Bool + xor = λ { true true → false + ; false false → false + ; _ _ → true + } + + fst : {A : Set} {B : A → Set} → Σ A B → A + fst = λ { (a , b) → a } + + snd : {A : Set} {B : A → Set} (p : Σ A B) → B (fst p) + snd = λ { (a , b) → b } + ``` + +* Record update syntax. + + Assume that we have a record type and a corresponding value: + + ```agda + record MyRecord : Set where + field + a b c : ℕ + + old : MyRecord + old = record { a = 1; b = 2; c = 3 } + ``` + + Then we can update (some of) the record value's fields in the + following way: + + ```agda + new : MyRecord + new = record old { a = 0; c = 5 } + ``` + + Here new normalises to `record { a = 0; b = 2; c = 5 }`. Any + expression yielding a value of type `MyRecord` can be used instead of + old. + + Record updating is not allowed to change types: the resulting value + must have the same type as the original one, including the record + parameters. Thus, the type of a record update can be inferred if the + type of the original record can be inferred. + + The record update syntax is expanded before type checking. When the + expression + + ```agda + record old { upd-fields } + ``` + + is checked against a record type `R`, it is expanded to + + ```agda + let r = old in record { new-fields }, + ``` + + where old is required to have type `R` and new-fields is defined as + follows: for each field `x` in `R`, + + - if `x = e` is contained in `upd-fields` then `x = e` is included in + `new-fields`, and otherwise + + - if `x` is an explicit field then `x = R.x r` is included in + `new-fields`, and + + - if `x` is an implicit or instance field, then it is omitted from + `new-fields`. + + (Instance arguments are explained below.) The reason for treating + implicit and instance fields specially is to allow code like the + following: + + ```agda + record R : Set where + field + {length} : ℕ + vec : Vec ℕ length + -- More fields… + + xs : R + xs = record { vec = 0 ∷ 1 ∷ 2 ∷ [] } + + ys = record xs { vec = 0 ∷ [] } + ``` + + Without the special treatment the last expression would need to + include a new binding for length (for instance `length = _`). + +* Record patterns which do not contain data type patterns, but which + do contain dot patterns, are no longer rejected. + +* When the `--without-K` flag is used literals are now treated as + constructors. + +* Under-applied functions can now reduce. + + Consider the following definition: + + ```agda + id : {A : Set} → A → A + id x = x + ``` + + Previously the expression `id` would not reduce. This has been + changed so that it now reduces to `λ x → x`. Usually this makes + little difference, but it can be important in conjunction with + `with`. See Issue [#365](https://github.com/agda/agda/issues/365) + for an example. + +* Unused AgdaLight legacy syntax `(x y : A; z v : B)` for telescopes + has been removed. + +### Universe polymorphism + +* Universe polymorphism is now enabled by default. Use + `--no-universe-polymorphism` to disable it. + +* Universe levels are no longer defined as a data type. + + The basic level combinators can be introduced in the following way: + + ```agda + postulate + Level : Set + zero : Level + suc : Level → Level + max : Level → Level → Level + + {-# BUILTIN LEVEL Level #-} + {-# BUILTIN LEVELZERO zero #-} + {-# BUILTIN LEVELSUC suc #-} + {-# BUILTIN LEVELMAX max #-} + ``` + +* The BUILTIN equality is now required to be universe-polymorphic. + +* `trustMe` is now universe-polymorphic. + +### Meta-variables and unification + +* Unsolved meta-variables are now frozen after every mutual block. + This means that they cannot be instantiated by subsequent code. For + instance, + + ```agda + one : Nat + one = _ + + bla : one ≡ suc zero + bla = refl + ``` + + leads to an error now, whereas previously it lead to the + instantiation of `_` with `suc zero`. If you want to make use of the + old behaviour, put the two definitions in a mutual block. + + All meta-variables are unfrozen during interactive editing, so that + the user can fill holes interactively. Note that type-checking of + interactively given terms is not perfect: Agda sometimes refuses to + load a file, even though no complaints were raised during the + interactive construction of the file. This is because certain checks + (for instance, positivity) are only invoked when a file is loaded. + +* Record types can now be inferred. + + If there is a unique known record type with fields matching the + fields in a record expression, then the type of the expression will + be inferred to be the record type applied to unknown parameters. + + If there is no known record type with the given fields the type + checker will give an error instead of producing lots of unsolved + meta-variables. + + Note that "known record type" refers to any record type in any + imported module, not just types which are in scope. + +* The occurrence checker distinguishes rigid and strongly rigid + occurrences [Reed, LFMTP 2009; Abel & Pientka, TLCA 2011]. + + The completeness checker now accepts the following code: + + ```agda + h : (n : Nat) → n ≡ suc n → Nat + h n () + ``` + + Internally this generates a constraint `_n = suc _n` where the + meta-variable `_n` occurs strongly rigidly, i.e. on a constructor + path from the root, in its own defining term tree. This is never + solvable. + + Weakly rigid recursive occurrences may have a solution [Jason Reed's + PhD thesis, page 106]: + + ```agda + test : (k : Nat) → + let X : (Nat → Nat) → Nat + X = _ + in + (f : Nat → Nat) → X f ≡ suc (f (X (λ x → k))) + test k f = refl + ``` + + The constraint `_X k f = suc (f (_X k (λ x → k)))` has the solution + `_X k f = suc (f (suc k))`, despite the recursive occurrence of + `_X`. Here `_X` is not strongly rigid, because it occurs under the + bound variable `f`. Previously Agda rejected this code; now it instead + complains about an unsolved meta-variable. + +* Equation constraints involving the same meta-variable in the head + now trigger pruning [Pientka, PhD, Sec. 3.1.2; Abel & Pientka, TLCA + 2011]. Example: + + ```agda + same : let X : A → A → A → A × A + X = _ + in {x y z : A} → X x y y ≡ (x , y) + × X x x y ≡ X x y y + same = refl , refl + ``` + + The second equation implies that `X` cannot depend on its second + argument. After pruning the first equation is linear and can be + solved. + +* Instance arguments. + + A new type of hidden function arguments has been added: instance + arguments. This new feature is based on influences from Scala's + implicits and Agda's existing implicit arguments. + + Plain implicit arguments are marked by single braces: `{…}`. Instance + arguments are instead marked by double braces: `{{…}}`. Example: + + ```agda + postulate + A : Set + B : A → Set + a : A + f : {{a : A}} → B a + ``` + + Instead of the double braces you can use the symbols `⦃` and `⦄`, + but these symbols must in many cases be surrounded by + whitespace. (If you are using Emacs and the Agda input method, then + you can conjure up the symbols by typing `\{{` and `\}}`, + respectively.) + + Instance arguments behave as ordinary implicit arguments, except for + one important aspect: resolution of arguments which are not provided + explicitly. For instance, consider the following code: + + ```agda + test = f + ``` + + Here Agda will notice that `f`'s instance argument was not provided + explicitly, and try to infer it. All definitions in scope at `f`'s + call site, as well as all variables in the context, are considered. + If exactly one of these names has the required type `A`, then the + instance argument will be instantiated to this name. + + This feature can be used as an alternative to Haskell type classes. + If we define + + ```agda + record Eq (A : Set) : Set where + field equal : A → A → Bool, + ``` + + then we can define the following projection: + + ```agda + equal : {A : Set} {{eq : Eq A}} → A → A → Bool + equal {{eq}} = Eq.equal eq + ``` + + Now consider the following expression: + + ```agda + equal false false ∨ equal 3 4 + ``` + + If the following `Eq` "instances" for `Bool` and `ℕ` are in scope, and no + others, then the expression is accepted: + + ```agda + eq-Bool : Eq Bool + eq-Bool = record { equal = … } + + eq-ℕ : Eq ℕ + eq-ℕ = record { equal = … } + ``` + + A shorthand notation is provided to avoid the need to define + projection functions manually: + + ```agda + module Eq-with-implicits = Eq {{...}} + ``` + + This notation creates a variant of `Eq`'s record module, where the + main `Eq` argument is an instance argument instead of an explicit one. + It is equivalent to the following definition: + + ```agda + module Eq-with-implicits {A : Set} {{eq : Eq A}} = Eq eq + ``` + + Note that the short-hand notation allows you to avoid naming the + "-with-implicits" module: + + ```agda + open Eq {{...}} + ``` + + Instance argument resolution is not recursive. As an example, + consider the following "parametrised instance": + + ```agda + eq-List : {A : Set} → Eq A → Eq (List A) + eq-List {A} eq = record { equal = eq-List-A } + where + eq-List-A : List A → List A → Bool + eq-List-A [] [] = true + eq-List-A (a ∷ as) (b ∷ bs) = equal a b ∧ eq-List-A as bs + eq-List-A _ _ = false + ``` + + Assume that the only `Eq` instances in scope are `eq-List` and + `eq-ℕ`. Then the following code does not type-check: + + ```agda + test = equal (1 ∷ 2 ∷ []) (3 ∷ 4 ∷ []) + ``` + + However, we can make the code work by constructing a suitable + instance manually: + + ```agda + test′ = equal (1 ∷ 2 ∷ []) (3 ∷ 4 ∷ []) + where eq-List-ℕ = eq-List eq-ℕ + ``` + + By restricting the "instance search" to be non-recursive we avoid + introducing a new, compile-time-only evaluation model to Agda. + + For more information about instance arguments, see Devriese & + Piessens [ICFP 2011]. Some examples are also available in the + examples/instance-arguments subdirectory of the Agda distribution. + +### Irrelevance + +* Dependent irrelevant function types. + + Some examples illustrating the syntax of dependent irrelevant + function types: + + ``` + .(x y : A) → B .{x y z : A} → B + ∀ x .y → B ∀ x .{y} {z} .v → B + ``` + + The declaration + + ``` + f : .(x : A) → B[x] + f x = t[x] + ``` + + requires that `x` is irrelevant both in `t[x]` and in `B[x]`. This + is possible if, for instance, `B[x] = B′ x`, with `B′ : .A → Set`. + + Dependent irrelevance allows us to define the eliminator for the + `Squash` type: + + ```agda + record Squash (A : Set) : Set where + constructor squash + field + .proof : A + + elim-Squash : {A : Set} (P : Squash A → Set) + (ih : .(a : A) → P (squash a)) → + (a⁻ : Squash A) → P a⁻ + elim-Squash P ih (squash a) = ih a + ``` + + Note that this would not type-check with + + ```agda + (ih : (a : A) -> P (squash a)). + ``` + +* Records with only irrelevant fields. + + The following now works: + + ```agda + record IsEquivalence {A : Set} (_≈_ : A → A → Set) : Set where + field + .refl : Reflexive _≈_ + .sym : Symmetric _≈_ + .trans : Transitive _≈_ + + record Setoid : Set₁ where + infix 4 _≈_ + field + Carrier : Set + _≈_ : Carrier → Carrier → Set + .isEquivalence : IsEquivalence _≈_ + + open IsEquivalence isEquivalence public + ``` + + Previously Agda complained about the application + `IsEquivalence isEquivalence`, because `isEquivalence` is irrelevant + and the `IsEquivalence` module expected a relevant argument. Now, + when record modules are generated for records consisting solely of + irrelevant arguments, the record parameter is made irrelevant: + + ```agda + module IsEquivalence {A : Set} {_≈_ : A → A → Set} + .(r : IsEquivalence {A = A} _≈_) where + … + ``` + +* Irrelevant things are no longer erased internally. This means that + they are printed as ordinary terms, not as `_` as before. + +* The new flag `--experimental-irrelevance` enables irrelevant + universe levels and matching on irrelevant data when only one + constructor is available. These features are very experimental and + likely to change or disappear. + +### Reflection + +* The reflection API has been extended to mirror features like + irrelevance, instance arguments and universe polymorphism, and to + give (limited) access to definitions. For completeness all the + builtins and primitives are listed below: + + ```agda + -- Names. + + postulate Name : Set + + {-# BUILTIN QNAME Name #-} + + primitive + -- Equality of names. + primQNameEquality : Name → Name → Bool + + -- Is the argument visible (explicit), hidden (implicit), or an + -- instance argument? + + data Visibility : Set where + visible hidden instance : Visibility + + {-# BUILTIN HIDING Visibility #-} + {-# BUILTIN VISIBLE visible #-} + {-# BUILTIN HIDDEN hidden #-} + {-# BUILTIN INSTANCE instance #-} + + -- Arguments can be relevant or irrelevant. + + data Relevance : Set where + relevant irrelevant : Relevance + + {-# BUILTIN RELEVANCE Relevance #-} + {-# BUILTIN RELEVANT relevant #-} + {-# BUILTIN IRRELEVANT irrelevant #-} + + -- Arguments. + + data Arg A : Set where + arg : (v : Visibility) (r : Relevance) (x : A) → Arg A + + {-# BUILTIN ARG Arg #-} + {-# BUILTIN ARGARG arg #-} + + -- Terms. + + mutual + data Term : Set where + -- Variable applied to arguments. + var : (x : ℕ) (args : List (Arg Term)) → Term + -- Constructor applied to arguments. + con : (c : Name) (args : List (Arg Term)) → Term + -- Identifier applied to arguments. + def : (f : Name) (args : List (Arg Term)) → Term + -- Different kinds of λ-abstraction. + lam : (v : Visibility) (t : Term) → Term + -- Pi-type. + pi : (t₁ : Arg Type) (t₂ : Type) → Term + -- A sort. + sort : Sort → Term + -- Anything else. + unknown : Term + + data Type : Set where + el : (s : Sort) (t : Term) → Type + + data Sort : Set where + -- A Set of a given (possibly neutral) level. + set : (t : Term) → Sort + -- A Set of a given concrete level. + lit : (n : ℕ) → Sort + -- Anything else. + unknown : Sort + + {-# BUILTIN AGDASORT Sort #-} + {-# BUILTIN AGDATYPE Type #-} + {-# BUILTIN AGDATERM Term #-} + {-# BUILTIN AGDATERMVAR var #-} + {-# BUILTIN AGDATERMCON con #-} + {-# BUILTIN AGDATERMDEF def #-} + {-# BUILTIN AGDATERMLAM lam #-} + {-# BUILTIN AGDATERMPI pi #-} + {-# BUILTIN AGDATERMSORT sort #-} + {-# BUILTIN AGDATERMUNSUPPORTED unknown #-} + {-# BUILTIN AGDATYPEEL el #-} + {-# BUILTIN AGDASORTSET set #-} + {-# BUILTIN AGDASORTLIT lit #-} + {-# BUILTIN AGDASORTUNSUPPORTED unknown #-} + + postulate + -- Function definition. + Function : Set + -- Data type definition. + Data-type : Set + -- Record type definition. + Record : Set + + {-# BUILTIN AGDAFUNDEF Function #-} + {-# BUILTIN AGDADATADEF Data-type #-} + {-# BUILTIN AGDARECORDDEF Record #-} + + -- Definitions. + + data Definition : Set where + function : Function → Definition + data-type : Data-type → Definition + record′ : Record → Definition + constructor′ : Definition + axiom : Definition + primitive′ : Definition + + {-# BUILTIN AGDADEFINITION Definition #-} + {-# BUILTIN AGDADEFINITIONFUNDEF function #-} + {-# BUILTIN AGDADEFINITIONDATADEF data-type #-} + {-# BUILTIN AGDADEFINITIONRECORDDEF record′ #-} + {-# BUILTIN AGDADEFINITIONDATACONSTRUCTOR constructor′ #-} + {-# BUILTIN AGDADEFINITIONPOSTULATE axiom #-} + {-# BUILTIN AGDADEFINITIONPRIMITIVE primitive′ #-} + + primitive + -- The type of the thing with the given name. + primQNameType : Name → Type + -- The definition of the thing with the given name. + primQNameDefinition : Name → Definition + -- The constructors of the given data type. + primDataConstructors : Data-type → List Name + ``` + + As an example the expression + + ```agda + primQNameType (quote zero) + ``` + + is definitionally equal to + + ```agda + el (lit 0) (def (quote ℕ) []) + ``` + + (if `zero` is a constructor of the data type `ℕ`). + +* New keyword: `unquote`. + + The construction `unquote t` converts a representation of an Agda term + to actual Agda code in the following way: + + 1. The argument `t` must have type `Term` (see the reflection API above). + + 2. The argument is normalised. + + 3. The entire construction is replaced by the normal form, which is + treated as syntax written by the user and type-checked in the + usual way. + + Examples: + + ```agda + test : unquote (def (quote ℕ) []) ≡ ℕ + test = refl + + id : (A : Set) → A → A + id = unquote (lam visible (lam visible (var 0 []))) + + id-ok : id ≡ (λ A (x : A) → x) + id-ok = refl + ``` + +* New keyword: `quoteTerm`. + + The construction `quoteTerm t` is similar to `quote n`, but whereas + `quote` is restricted to names `n`, `quoteTerm` accepts terms + `t`. The construction is handled in the following way: + + 1. The type of `t` is inferred. The term `t` must be type-correct. + + 2. The term `t` is normalised. + + 3. The construction is replaced by the Term representation (see the + reflection API above) of the normal form. Any unsolved metavariables + in the term are represented by the `unknown` term constructor. + + Examples: + + ```agda + test₁ : quoteTerm (λ {A : Set} (x : A) → x) ≡ + lam hidden (lam visible (var 0 [])) + test₁ = refl + + -- Local variables are represented as de Bruijn indices. + test₂ : (λ {A : Set} (x : A) → quoteTerm x) ≡ (λ x → var 0 []) + test₂ = refl + + -- Terms are normalised before being quoted. + test₃ : quoteTerm (0 + 0) ≡ con (quote zero) [] + test₃ = refl + ``` + +Compiler backends +----------------- + +### MAlonzo + +* The MAlonzo backend's FFI now handles universe polymorphism in a + better way. + + The translation of Agda types and kinds into Haskell now supports + universe-polymorphic postulates. The core changes are that the + translation of function types has been changed from + + ``` + T[[ Pi (x : A) B ]] = + if A has a Haskell kind then + forall x. () -> T[[ B ]] + else if x in fv B then + undef + else + T[[ A ]] -> T[[ B ]] + ``` + + into + + ``` + T[[ Pi (x : A) B ]] = + if x in fv B then + forall x. T[[ A ]] -> T[[ B ]] -- Note: T[[A]] not Unit. + else + T[[ A ]] -> T[[ B ]], + ``` + + and that the translation of constants (postulates, constructors and + literals) has been changed from + + ``` + T[[ k As ]] = + if COMPILED_TYPE k T then + T T[[ As ]] + else + undef + ``` + + into + + ``` + T[[ k As ]] = + if COMPILED_TYPE k T then + T T[[ As ]] + else if COMPILED k E then + () + else + undef. + ``` + + For instance, assuming a Haskell definition + + ```haskell + type AgdaIO a b = IO b, + ``` + + we can set up universe-polymorphic `IO` in the following way: + + ```agda + postulate + IO : ∀ {ℓ} → Set ℓ → Set ℓ + return : ∀ {a} {A : Set a} → A → IO A + _>>=_ : ∀ {a b} {A : Set a} {B : Set b} → + IO A → (A → IO B) → IO B + + {-# COMPILED_TYPE IO AgdaIO #-} + {-# COMPILED return (\_ _ -> return) #-} + {-# COMPILED _>>=_ (\_ _ _ _ -> (>>=)) #-} + ``` + + This is accepted because (assuming that the universe level type is + translated to the Haskell unit type `()`) + + ```haskell + (\_ _ -> return) + : forall a. () -> forall b. () -> b -> AgdaIO a b + = T [[ ∀ {a} {A : Set a} → A → IO A ]] + ``` + + and + + ```haskell + (\_ _ _ _ -> (>>=)) + : forall a. () -> forall b. () -> + forall c. () -> forall d. () -> + AgdaIO a c -> (c -> AgdaIO b d) -> AgdaIO b d + = T [[ ∀ {a b} {A : Set a} {B : Set b} → + IO A → (A → IO B) → IO B ]]. + ``` + +### Epic + +* New Epic backend pragma: `STATIC`. + + In the Epic backend, functions marked with the `STATIC` pragma will be + normalised before compilation. Example usage: + + ``` + {-# STATIC power #-} + + power : ℕ → ℕ → ℕ + power 0 x = 1 + power 1 x = x + power (suc n) x = power n x * x + ``` + + Occurrences of `power 4 x` will be replaced by `((x * x) * x) * x`. + +* Some new optimisations have been implemented in the Epic backend: + + - Removal of unused arguments. + + A worker/wrapper transformation is performed so that unused + arguments can be removed by Epic's inliner. For instance, the map + function is transformed in the following way: + + ```agda + map_wrap : (A B : Set) → (A → B) → List A → List B + map_wrap A B f xs = map_work f xs + + map_work f [] = [] + map_work f (x ∷ xs) = f x ∷ map_work f xs + ``` + + If `map_wrap` is inlined (which it will be in any saturated call), + then `A` and `B` disappear in the generated code. + + Unused arguments are found using abstract interpretation. The bodies + of all functions in a module are inspected to decide which variables + are used. The behaviour of postulates is approximated based on their + types. Consider `return`, for instance: + + ```agda + postulate return : {A : Set} → A → IO A + ``` + + The first argument of `return` can be removed, because it is of type + Set and thus cannot affect the outcome of a program at runtime. + + - Injection detection. + + At runtime many functions may turn out to be inefficient variants of + the identity function. This is especially true after forcing. + Injection detection replaces some of these functions with more + efficient versions. Example: + + ```agda + inject : {n : ℕ} → Fin n → Fin (1 + n) + inject {suc n} zero = zero + inject {suc n} (suc i) = suc (inject {n} i) + ``` + + Forcing removes the `Fin` constructors' `ℕ` arguments, so this + function is an inefficient identity function that can be replaced by + the following one: + + ```agda + inject {_} x = x + ``` + + To actually find this function, we make the induction hypothesis + that inject is an identity function in its second argument and look + at the branches of the function to decide if this holds. + + Injection detection also works over data type barriers. Example: + + ```agda + forget : {A : Set} {n : ℕ} → Vec A n → List A + forget [] = [] + forget (x ∷ xs) = x ∷ forget xs + ``` + + Given that the constructor tags (in the compiled Epic code) for + `Vec.[]` and `List.[]` are the same, and that the tags for `Vec._∷_` + and `List._∷_` are also the same, this is also an identity + function. We can hence replace the definition with the following + one: + + ```agda + forget {_} xs = xs + ``` + + To get this to apply as often as possible, constructor tags are + chosen *after* injection detection has been run, in a way to make as + many functions as possible injections. + + Constructor tags are chosen once per source file, so it may be + advantageous to define conversion functions like forget in the same + module as one of the data types. For instance, if `Vec.agda` imports + `List.agda`, then the forget function should be put in `Vec.agda` to + ensure that vectors and lists get the same tags (unless some other + injection function, which puts different constraints on the tags, is + prioritised). + + - Smashing. + + This optimisation finds types whose values are inferable at runtime: + + * A data type with only one constructor where all fields are + inferable is itself inferable. + + * `Set ℓ` is inferable (as it has no runtime representation). + + A function returning an inferable data type can be smashed, which + means that it is replaced by a function which simply returns the + inferred value. + + An important example of an inferable type is the usual propositional + equality type (`_≡_`). Any function returning a propositional + equality can simply return the reflexivity constructor directly + without computing anything. + + This optimisation makes more arguments unused. It also makes the + Epic code size smaller, which in turn speeds up compilation. + +### JavaScript + +* ECMAScript compiler backend. + + A new compiler backend is being implemented, targetting ECMAScript + (also known as JavaScript), with the goal of allowing Agda programs + to be run in browsers or other ECMAScript environments. + + The backend is still at an experimental stage: the core language is + implemented, but many features are still missing. + + The ECMAScript compiler can be invoked from the command line using + the flag `--js`: + + ``` + agda --js --compile-dir= .agda + ``` + + Each source `.agda` is compiled into an ECMAScript target + `/jAgda..js`. The compiler can also be + invoked using the Emacs mode (the variable `agda2-backend` controls + which backend is used). + + Note that ECMAScript is a strict rather than lazy language. Since + Agda programs are total, this should not impact program semantics, + but it may impact their space or time usage. + + ECMAScript does not support algebraic datatypes or pattern-matching. + These features are translated to a use of the visitor pattern. For + instance, the standard library's `List` data type and `null` + function are translated into the following code: + + ```javascript + exports["List"] = {}; + exports["List"]["[]"] = function (x0) { + return x0["[]"](); + }; + exports["List"]["_∷_"] = function (x0) { + return function (x1) { + return function (x2) { + return x2["_∷_"](x0, x1); + }; + }; + }; + + exports["null"] = function (x0) { + return function (x1) { + return function (x2) { + return x2({ + "[]": function () { + return jAgda_Data_Bool["Bool"]["true"]; + }, + "_∷_": function (x3, x4) { + return jAgda_Data_Bool["Bool"]["false"]; + } + }); + }; + }; + }; + ``` + + Agda records are translated to ECMAScript objects, preserving field + names. + + Top-level Agda modules are translated to ECMAScript modules, + following the `common.js` module specification. A top-level Agda + module `Foo.Bar` is translated to an ECMAScript module + `jAgda.Foo.Bar`. + + The ECMAScript compiler does not compile to Haskell, so the pragmas + related to the Haskell FFI (`IMPORT`, `COMPILED_DATA` and + `COMPILED`) are not used by the ECMAScript backend. Instead, there + is a `COMPILED_JS` pragma which may be applied to any + declaration. For postulates, primitives, functions and values, it + gives the ECMAScript code to be emitted by the compiler. For data + types, it gives a function which is applied to a value of that type, + and a visitor object. For instance, a binding of natural numbers to + ECMAScript integers (ignoring overflow errors) is: + + ```agda + data ℕ : Set where + zero : ℕ + suc : ℕ → ℕ + + {-# COMPILED_JS ℕ function (x,v) { + if (x < 1) { return v.zero(); } else { return v.suc(x-1); } + } #-} + {-# COMPILED_JS zero 0 #-} + {-# COMPILED_JS suc function (x) { return x+1; } #-} + + _+_ : ℕ → ℕ → ℕ + zero + n = n + suc m + n = suc (m + n) + + {-# COMPILED_JS _+_ function (x) { return function (y) { + return x+y; }; + } #-} + ``` + + To allow FFI code to be optimised, the ECMAScript in a `COMPILED_JS` + declaration is parsed, using a simple parser that recognises a pure + functional subset of ECMAScript, consisting of functions, function + applications, return, if-statements, if-expressions, + side-effect-free binary operators (no precedence, left associative), + side-effect-free prefix operators, objects (where all member names + are quoted), field accesses, and string and integer literals. + Modules may be imported using the require (``) syntax: any + impure code, or code outside the supported fragment, can be placed + in a module and imported. + +Tools +----- + +* New flag `--safe`, which can be used to type-check untrusted code. + + This flag disables postulates, `primTrustMe`, and "unsafe" `OPTIONS` + pragmas, some of which are known to make Agda inconsistent. + + Rejected pragmas: + + ``` + --allow-unsolved-metas + --experimental-irrelevance + --guardedness-preserving-type-construtors + --injective-type-constructors + --no-coverage-check + --no-positivity-check + --no-termination-check + --sized-types + --type-in-type + ``` + + Note that, at the moment, it is not possible to define the universe + level or coinduction primitives when `--safe` is used (because they + must be introduced as postulates). This can be worked around by + type-checking trusted files in a first pass, without using `--safe`, + and then using `--saf`e in a second pass. Modules which have already + been type-checked are not re-type-checked just because `--safe` is + used. + +* Dependency graphs. + + The new flag `--dependency-graph=FILE` can be used to generate a DOT + file containing a module dependency graph. The generated file (FILE) + can be rendered using a tool like dot. + +* The `--no-unreachable-check` flag has been removed. + +* Projection functions are highlighted as functions instead of as + fields. Field names (in record definitions and record values) are + still highlighted as fields. + +* Support for jumping to positions mentioned in the information + buffer has been added. + +* The `make install` command no longer installs Agda globally (by + default). diff --git a/doc/release-notes/2.3.2.1.md b/doc/release-notes/2.3.2.1.md new file mode 100644 --- /dev/null +++ b/doc/release-notes/2.3.2.1.md @@ -0,0 +1,16 @@ +Release notes for Agda 2 version 2.3.2.1 +======================================== + +Installation +------------ + +* Made it possible to compile Agda with more recent versions of + hashable, QuickCheck and Win32. + +* Excluded mtl-2.1. + +Type checking +------------- + +* Fixed bug in the termination checker + (Issue [#754](https://github.com/agda/agda/issues/754)). diff --git a/doc/release-notes/2.3.2.2.md b/doc/release-notes/2.3.2.2.md new file mode 100644 --- /dev/null +++ b/doc/release-notes/2.3.2.2.md @@ -0,0 +1,10 @@ +Release notes for Agda 2 version 2.3.2.2 +======================================== + +* Fixed a bug that sometimes made it tricky to use the Emacs mode on + Windows [Issue [#757](https://github.com/agda/agda/issues/757)]. + +* Made Agda build with newer versions of some libraries. + +* Fixed a bug that caused ambiguous parse error messages + [Issue [#147](https://github.com/agda/agda/issues/147)]. diff --git a/doc/release-notes/2.3.2.md b/doc/release-notes/2.3.2.md new file mode 100644 --- /dev/null +++ b/doc/release-notes/2.3.2.md @@ -0,0 +1,806 @@ +Release notes for Agda 2 version 2.3.2 +====================================== + +Installation +------------ + +* The Agda-executable package has been removed. + + The executable is now provided as part of the Agda package. + +* The Emacs mode no longer depends on haskell-mode or GHCi. + +* Compilation of Emacs mode Lisp files. + + You can now compile the Emacs mode Lisp files by running `agda-mode + compile`. This command is run by `make install`. + + Compilation can, in some cases, give a noticeable speedup. + + WARNING: If you reinstall the Agda mode without recompiling the + Emacs Lisp files, then Emacs may continue using the old, compiled + files. + +Pragmas and options +------------------- + +* The `--without-K` check now reconstructs constructor parameters. + + New specification of `--without-K`: + + If the flag is activated, then Agda only accepts certain + case-splits. If the type of the variable to be split is + `D pars ixs`, where `D` is a data (or record) type, `pars` stands + for the parameters, and `ixs` the indices, then the following + requirements must be satisfied: + + - The indices `ixs` must be applications of constructors (or + literals) to distinct variables. Constructors are usually not + applied to parameters, but for the purposes of this check + constructor parameters are treated as other arguments. + + - These distinct variables must not be free in pars. + +* Irrelevant arguments are printed as `_` by default now. To turn on + printing of irrelevant arguments, use option + + ``` + --show-irrelevant + ``` + +* New: Pragma `NO_TERMINATION_CHECK` to switch off termination checker + for individual function definitions and mutual blocks. + + The pragma must precede a function definition or a mutual block. + Examples (see `test/Succeed/NoTerminationCheck.agda`): + + 1. Skipping a single definition: before type signature. + + ```agda + {-# NO_TERMINATION_CHECK #-} + a : A + a = a + ``` + + 2. Skipping a single definition: before first clause. + + ```agda + b : A + {-# NO_TERMINATION_CHECK #-} + b = b + ``` + + 3. Skipping an old-style mutual block: Before `mutual` keyword. + + ```agda + {-# NO_TERMINATION_CHECK #-} + mutual + c : A + c = d + + d : A + d = c + ``` + + 4. Skipping a new-style mutual block: Anywhere before a type + signature or first function clause in the block + + ```agda + i : A + j : A + + i = j + {-# NO_TERMINATION_CHECK #-} + j = i + ``` + + The pragma cannot be used in `--safe` mode. + +Language +-------- + +* Let binding record patterns + + ```agda + record _×_ (A B : Set) : Set where + constructor _,_ + field + fst : A + snd : B + open _×_ + + let (x , (y , z)) = t + in u + ``` + + will now be interpreted as + + ```agda + let x = fst t + y = fst (snd t) + z = snd (snd t) + in u + ``` + + Note that the type of `t` needs to be inferable. If you need to + provide a type signature, you can write the following: + + ```agda + let a : ... + a = t + (x , (y , z)) = a + in u + ``` + +* Pattern synonyms + + A pattern synonym is a declaration that can be used on the left hand + side (when pattern matching) as well as the right hand side (in + expressions). For example: + + ```agda + pattern z = zero + pattern ss x = suc (suc x) + + f : ℕ -> ℕ + f z = z + f (suc z) = ss z + f (ss n) = n + ``` + + Pattern synonyms are implemented by substitution on the abstract + syntax, so definitions are scope-checked but not type-checked. They + are particularly useful for universe constructions. + +* Qualified mixfix operators + + It is now possible to use a qualified mixfix operator by qualifying + the first part of the name. For instance + + ```agda + import Data.Nat as Nat + import Data.Bool as Bool + + two = Bool.if true then 1 Nat.+ 1 else 0 + ``` + +* Sections [Issue [#735](https://github.com/agda/agda/issues/735)]. + Agda now parses anonymous modules as sections: + + ```agda + module _ {a} (A : Set a) where + + data List : Set a where + [] : List + _∷_ : (x : A) (xs : List) → List + + module _ {a} {A : Set a} where + + _++_ : List A → List A → List A + [] ++ ys = ys + (x ∷ xs) ++ ys = x ∷ (xs ++ ys) + + test : List Nat + test = (5 ∷ []) ++ (3 ∷ []) + ``` + + In general, now the syntax + + ```agda + module _ parameters where + declarations + ``` + + is accepted and has the same effect as + + ```agda + private + module M parameters where + declarations + open M public + ``` + + for a fresh name `M`. + +* Instantiating a module in an open import statement + [Issue [#481](https://github.com/agda/agda/issues/481)]. Now + accepted: + + ```agda + open import Path.Module args [using/hiding/renaming (...)] + ``` + + This only brings the imported identifiers from `Path.Module` into scope, + not the module itself! Consequently, the following is pointless, and raises + an error: + + ```agda + import Path.Module args [using/hiding/renaming (...)] + ``` + + You can give a private name `M` to the instantiated module via + + ```agda + import Path.Module args as M [using/hiding/renaming (...)] + open import Path.Module args as M [using/hiding/renaming (...)] + ``` + + Try to avoid `as` as part of the arguments. `as` is not a keyword; + the following can be legal, although slightly obfuscated Agda code: + + ```agda + open import as as as as as as + ``` + +* Implicit module parameters can be given by name. E.g. + + ```agda + open M {namedArg = bla} + ``` + + This feature has been introduced in Agda 2.3.0 already. + +* Multiple type signatures sharing a same type can now be written as a single + type signature. + + ```agda + one two : ℕ + one = suc zero + two = suc one + ``` + +Goal and error display +---------------------- + +* Meta-variables that were introduced by hidden argument `arg` are now + printed as `_arg_number` instead of just `_number`. + [Issue [#526](https://github.com/agda/agda/issues/526)] + +* Agda expands identifiers in anonymous modules when printing. Should + make some goals nicer to read. + [Issue [#721](https://github.com/agda/agda/issues/721)] + +* When a module identifier is ambiguous, Agda tells you if one of them + is a data type module. + [Issues [#318](https://github.com/agda/agda/issues/318), + [#705](https://github.com/agda/agda/issues/705)] + +Type checking +------------- + +* Improved coverage checker. The coverage checker splits on arguments + that have constructor or literal pattern, committing to the + left-most split that makes progress. Consider the lookup function + for vectors: + + ```agda + data Fin : Nat → Set where + zero : {n : Nat} → Fin (suc n) + suc : {n : Nat} → Fin n → Fin (suc n) + + data Vec (A : Set) : Nat → Set where + [] : Vec A zero + _∷_ : {n : Nat} → A → Vec A n → Vec A (suc n) + + _!!_ : {A : Set}{n : Nat} → Vec A n → Fin n → A + (x ∷ xs) !! zero = x + (x ∷ xs) !! suc i = xs !! i + ``` + + In Agda up to 2.3.0, this definition is rejected unless we add + an absurd clause + + ```agda + [] !! () + ``` + + This is because the coverage checker committed on splitting on the + vector argument, even though this inevitably lead to failed + coverage, because a case for the empty vector `[]` is missing. + + The improvement to the coverage checker consists on committing only + on splits that have a chance of covering, since all possible + constructor patterns are present. Thus, Agda will now split first + on the `Fin` argument, since cases for both `zero` and `suc` are + present. Then, it can split on the `Vec` argument, since the empty + vector is already ruled out by instantiating `n` to a `suc _`. + +* Instance arguments resolution will now consider candidates which + still expect hidden arguments. For example: + + ```agda + record Eq (A : Set) : Set where + field eq : A → A → Bool + + open Eq {{...}} + + eqFin : {n : ℕ} → Eq (Fin n) + eqFin = record { eq = primEqFin } + + testFin : Bool + testFin = eq fin1 fin2 + ``` + + The type-checker will now resolve the instance argument of the `eq` + function to `eqFin {_}`. This is only done for hidden arguments, not + instance arguments, so that the instance search stays non-recursive. + +* Constraint solving: Upgraded Miller patterns to record patterns. + [Issue [#456](https://github.com/agda/agda/issues/456)] + + Agda now solves meta-variables that are applied to record patterns. + A typical (but here, artificial) case is: + + ```agda + record Sigma (A : Set)(B : A -> Set) : Set where + constructor _,_ + field + fst : A + snd : B fst + + test : (A : Set)(B : A -> Set) -> + let X : Sigma A B -> Sigma A B + X = _ + in (x : A)(y : B x) -> X (x , y) ≡ (x , y) + test A B x y = refl + ``` + + This yields a constraint of the form + + ``` + _X A B (x , y) := t[x,y] + ``` + + (with `t[x,y] = (x, y)`) which is not a Miller pattern. + However, Agda now solves this as + + ``` + _X A B z := t[fst z,snd z]. + ``` + +* Changed: solving recursive constraints. + [Issue [#585](https://github.com/agda/agda/issues/585)] + + Until 2.3.0, Agda sometimes inferred values that did not pass the + termination checker later, or would even make Agda loop. To prevent + this, the occurs check now also looks into the definitions of the + current mutual block, to avoid constructing recursive solutions. As + a consequence, also terminating recursive solutions are no longer + found automatically. + + This effects a programming pattern where the recursively computed + type of a recursive function is left to Agda to solve. + + ```agda + mutual + + T : D -> Set + T pattern1 = _ + T pattern2 = _ + + f : (d : D) -> T d + f pattern1 = rhs1 + f pattern2 = rhs2 + ``` + + This might no longer work from now on. See examples + `test/Fail/Issue585*.agda`. + +* Less eager introduction of implicit parameters. + [Issue [#679](https://github.com/agda/agda/issues/679)] + + Until Agda 2.3.0, trailing hidden parameters were introduced eagerly + on the left hand side of a definition. For instance, one could not + write + + ```agda + test : {A : Set} -> Set + test = \ {A} -> A + ``` + + because internally, the hidden argument `{A : Set}` was added to the + left-hand side, yielding + + ```agda + test {_} = \ {A} -> A + ``` + + which raised a type error. Now, Agda only introduces the trailing + implicit parameters it has to, in order to maintain uniform function + arity. For instance, in + + ```agda + test : Bool -> {A B C : Set} -> Set + test true {A} = A + test false {B = B} = B + ``` + + Agda will introduce parameters `A` and `B` in all clauses, but not + `C`, resulting in + + ```agda + test : Bool -> {A B C : Set} -> Set + test true {A} {_} = A + test false {_} {B = B} = B + ``` + + Note that for checking `where`-clauses, still all hidden trailing + parameters are in scope. For instance: + + ```agda + id : {i : Level}{A : Set i} -> A -> A + id = myId + where myId : forall {A} -> A -> A + myId x = x + ``` + + To be able to fill in the meta variable `_1` in + + ```agda + myId : {A : Set _1} -> A -> A + ``` + + the hidden parameter `{i : Level}` needs to be in scope. + + As a result of this more lazy introduction of implicit parameters, + the following code now passes. + + ```agda + data Unit : Set where + unit : Unit + + T : Unit → Set + T unit = {u : Unit} → Unit + + test : (u : Unit) → T u + test unit with unit + ... | _ = λ {v} → v + ``` + + Before, Agda would eagerly introduce the hidden parameter `{v}` as + unnamed left-hand side parameter, leaving no way to refer to it. + + The related Issue [#655](https://github.com/agda/agda/issues/655) + has also been addressed. It is now possible to make `synonym' + definitions + + ``` + name = expression + ``` + + even when the type of expression begins with a hidden quantifier. + Simple example: + + ``` + id2 = id + ``` + + That resulted in unsolved metas until 2.3.0. + +* Agda detects unused arguments and ignores them during equality + checking. [Issue [#691](https://github.com/agda/agda/issues/691), + solves also Issue [#44](https://github.com/agda/agda/issues/44)] + + Agda's polarity checker now assigns 'Nonvariant' to arguments that + are not actually used (except for absurd matches). If `f`'s first + argument is Nonvariant, then `f x` is definitionally equal to `f y` + regardless of `x` and `y`. It is similar to irrelevance, but does + not require user annotation. + + For instance, unused module parameters do no longer get in the way: + + ```agda + module M (x : Bool) where + + not : Bool → Bool + not true = false + not false = true + + open M true + open M false renaming (not to not′) + + test : (y : Bool) → not y ≡ not′ y + test y = refl + ``` + + Matching against record or absurd patterns does not count as `use', + so we get some form of proof irrelevance: + + ```agda + data ⊥ : Set where + record ⊤ : Set where + constructor trivial + + data Bool : Set where + true false : Bool + + True : Bool → Set + True true = ⊤ + True false = ⊥ + + fun : (b : Bool) → True b → Bool + fun true trivial = true + fun false () + + test : (b : Bool) → (x y : True b) → fun b x ≡ fun b y + test b x y = refl + ``` + + More examples in `test/Succeed/NonvariantPolarity.agda`. + + Phantom arguments: Parameters of record and data types are considered + `used' even if they are not actually used. Consider: + + ```agda + False : Nat → Set + False zero = ⊥ + False (suc n) = False n + + module Invariant where + record Bla (n : Nat)(p : False n) : Set where + + module Nonvariant where + Bla : (n : Nat) → False n → Set + Bla n p = ⊤ + ``` + + Even though record `Bla` does not use its parameters `n` and `p`, + they are considered as used, allowing "phantom type" techniques. + + In contrast, the arguments of function `Bla` are recognized as + unused. The following code type-checks if we open `Invariant` but + leaves unsolved metas if we open `Nonvariant`. + + ```agda + drop-suc : {n : Nat}{p : False n} → Bla (suc n) p → Bla n p + drop-suc _ = _ + + bla : (n : Nat) → {p : False n} → Bla n p → ⊥ + bla zero {()} b + bla (suc n) b = bla n (drop-suc b) + ``` + + If `Bla` is considered invariant, the hidden argument in the + recursive call can be inferred to be `p`. If it is considered + non-variant, then `Bla n X = Bla n p` does not entail `X = p` and + the hidden argument remains unsolved. Since `bla` does not actually + use its hidden argument, its value is not important and it could be + searched for. Unfortunately, polarity analysis of `bla` happens + only after type checking, thus, the information that `bla` is + non-variant in `p` is not available yet when meta-variables are + solved. (See + `test/Fail/BrokenInferenceDueToNonvariantPolarity.agda`) + +* Agda now expands simple definitions (one clause, terminating) to + check whether a function is constructor + headed. [Issue [#747](https://github.com/agda/agda/issues/747)] For + instance, the following now also works: + + ```agda + MyPair : Set -> Set -> Set + MyPair A B = Pair A B + + Vec : Set -> Nat -> Set + Vec A zero = Unit + Vec A (suc n) = MyPair A (Vec A n) + ``` + + Here, `Unit` and `Pair` are data or record types. + +Compiler backends +----------------- + +* `-Werror` is now overridable. + + To enable compilation of Haskell modules containing warnings, the + `-Werror` flag for the MAlonzo backend has been made + overridable. If, for example, `--ghc-flag=-Wwarn` is passed when + compiling, one can get away with things like: + + ```agda + data PartialBool : Set where + true : PartialBool + + {-# COMPILED_DATA PartialBool Bool True #-} + ``` + + The default behavior remains as it used to be and rejects the above + program. + +Tools +----- + +### Emacs mode + +* Asynchronous Emacs mode. + + One can now use Emacs while a buffer is type-checked. If the buffer + is edited while the type-checker runs, then syntax highlighting will + not be updated when type-checking is complete. + +* Interactive syntax highlighting. + + The syntax highlighting is updated while a buffer is type-checked: + + - At first the buffer is highlighted in a somewhat crude way + (without go-to-definition information for overloaded + constructors). + + - If the highlighting level is "interactive", then the piece of code + that is currently being type-checked is highlighted as such. (The + default is "non-interactive".) + + - When a mutual block has been type-checked it is highlighted + properly (this highlighting includes warnings for potential + non-termination). + + The highlighting level can be controlled via the new configuration + variable `agda2-highlight-level`. + +* Multiple case-splits can now be performed in one go. + + Consider the following example: + + ```agda + _==_ : Bool → Bool → Bool + b₁ == b₂ = {!!} + ``` + + If you split on `b₁ b₂`, then you get the following code: + + ```agda + _==_ : Bool → Bool → Bool + true == true = {!!} + true == false = {!!} + false == true = {!!} + false == false = {!!} + ``` + + The order of the variables matters. Consider the following code: + + ```agda + lookup : ∀ {a n} {A : Set a} → Vec A n → Fin n → A + lookup xs i = {!!} + ``` + + If you split on `xs i`, then you get the following code: + + ```agda + lookup : ∀ {a n} {A : Set a} → Vec A n → Fin n → A + lookup [] () + lookup (x ∷ xs) zero = {!!} + lookup (x ∷ xs) (suc i) = {!!} + ``` + + However, if you split on `i xs`, then you get the following code + instead: + + ```agda + lookup : ∀ {a n} {A : Set a} → Vec A n → Fin n → A + lookup (x ∷ xs) zero = ? + lookup (x ∷ xs) (suc i) = ? + ``` + + This code is rejected by Agda 2.3.0, but accepted by 2.3.2 thanks + to improved coverage checking (see above). + +* The Emacs mode now presents information about which module is + currently being type-checked. + +* New global menu entry: `Information about the character at point`. + + If this entry is selected, then information about the character at + point is displayed, including (in many cases) information about how + to type the character. + +* Commenting/uncommenting the rest of the buffer. + + One can now comment or uncomment the rest of the buffer by typing + `C-c C-x M-;` or by selecting the menu entry `Comment/uncomment` the + rest of the buffer". + +* The Emacs mode now uses the Agda executable instead of GHCi. + + The `*ghci*` buffer has been renamed to `*agda2*`. + + A new configuration variable has been introduced: + `agda2-program-name`, the name of the Agda executable (by default + `agda`). + + The variable `agda2-ghci-options` has been replaced by + `agda2-program-args`: extra arguments given to the Agda executable + (by default `none`). + + If you want to limit Agda's memory consumption you can add some + arguments to `agda2-program-args`, for instance `+RTS -M1.5G -RTS`. + +* The Emacs mode no longer depends on haskell-mode. + + Users who have customised certain haskell-mode variables (such as + `haskell-ghci-program-args`) may want to update their configuration. + +### LaTeX-backend + +An experimental LaTeX-backend which does precise highlighting a la the +HTML-backend and code alignment a la lhs2TeX has been added. + +Here is a sample input literate Agda file: + + ```latex + \documentclass{article} + + \usepackage{agda} + + \begin{document} + + The following module declaration will be hidden in the output. + + \AgdaHide{ + \begin{code} + module M where + \end{code} + } + + Two or more spaces can be used to make the backend align stuff. + + \begin{code} + data ℕ : Set where + zero : ℕ + suc : ℕ → ℕ + + _+_ : ℕ → ℕ → ℕ + zero + n = n + suc m + n = suc (m + n) + \end{code} + + \end{document} + ``` + +To produce an output PDF issue the following commands: + + ``` + agda --latex -i . .lagda + pdflatex latex/.tex + ``` + +Only the top-most module is processed, like with lhs2tex and unlike +with the HTML-backend. If you want to process imported modules you +have to call `agda --latex` manually on each of those modules. + +There are still issues related to formatting, see the bug tracker for +more information: + + https://code.google.com/p/agda/issues/detail?id=697 + +The default `agda.sty` might therefore change in backwards-incompatible +ways, as work proceeds in trying to resolve those problems. + +Implemented features: + +* Two or more spaces can be used to force alignment of things, like + with lhs2tex. See example above. + +* The highlighting information produced by the type checker is used to + generate the output. For example, the data declaration in the + example above, produces: + + ```agda + \AgdaKeyword{data} \AgdaDatatype{ℕ} \AgdaSymbol{:} + \AgdaPrimitiveType{Set} \AgdaKeyword{where} + ``` + + These LaTeX commands are defined in `agda.sty` (which is imported by + `\usepackage{agda}`) and cause the highlighting. + +* The LaTeX-backend checks if `agda.sty` is found by the LaTeX + environment, if it isn't a default `agda.sty` is copied from Agda's + `data-dir` into the working directory (and thus made available to + the LaTeX environment). + + If the default `agda.sty` isn't satisfactory (colors, fonts, + spacing, etc) then the user can modify it and make put it somewhere + where the LaTeX environment can find it. Hopefully most aspects + should be modifiable via `agda.sty` rather than having to tweak the + implementation. + +* `--latex-dir` can be used to change the default output directory. diff --git a/doc/release-notes/2.4.0.1.md b/doc/release-notes/2.4.0.1.md new file mode 100644 --- /dev/null +++ b/doc/release-notes/2.4.0.1.md @@ -0,0 +1,8 @@ +Release notes for Agda 2 version 2.4.0.1 +======================================== + +* The option `--compile-no-main` has been renamed to `--no-main`. + +* `COMPILED_DATA` pragmas can now be given for records. + +* Various bug fixes. diff --git a/doc/release-notes/2.4.0.2.md b/doc/release-notes/2.4.0.2.md new file mode 100644 --- /dev/null +++ b/doc/release-notes/2.4.0.2.md @@ -0,0 +1,90 @@ +Release notes for Agda 2 version 2.4.0.2 +======================================== + +* The Agda input mode now supports alphabetical super and subscripts, + in addition to the numerical ones that were already present. + [Issue [#1240](https://github.com/agda/agda/issues/1240)] + +* New feature: Interactively split result. + + Make case (`C-c C-c`) with no variables given tries to split on the + result to introduce projection patterns. The hole needs to be of + record type, of course. + + ```agda + test : {A B : Set} (a : A) (b : B) → A × B + test a b = ? + ``` + + Result-splitting `?` will produce the new clauses: + + ```agda + proj₁ (test a b) = ? + proj₂ (test a b) = ? + ``` + + If hole is of function type ending in a record type, the necessary + pattern variables will be introduced before the split. Thus, the + same result can be obtained by starting from: + + ```agda + test : {A B : Set} (a : A) (b : B) → A × B + test = ? + ``` + +* The so far undocumented `ETA` pragma now throws an error if applied to + definitions that are not records. + + `ETA` can be used to force eta-equality at recursive record types, + for which eta is not enabled automatically by Agda. Here is such an + example: + + ```agda + mutual + data Colist (A : Set) : Set where + [] : Colist A + _∷_ : A → ∞Colist A → Colist A + + record ∞Colist (A : Set) : Set where + coinductive + constructor delay + field force : Colist A + + open ∞Colist + + {-# ETA ∞Colist #-} + + test : {A : Set} (x : ∞Colist A) → x ≡ delay (force x) + test x = refl + ``` + + Note: Unsafe use of `ETA` can make Agda loop, e.g. by triggering + infinite eta expansion! + +* Bugs fixed (see [bug tracker](https://github.com/agda/agda/issues)): + + [#1203](https://github.com/agda/agda/issues/1203) + + [#1205](https://github.com/agda/agda/issues/1205) + + [#1209](https://github.com/agda/agda/issues/1209) + + [#1213](https://github.com/agda/agda/issues/1213) + + [#1214](https://github.com/agda/agda/issues/1214) + + [#1216](https://github.com/agda/agda/issues/1216) + + [#1225](https://github.com/agda/agda/issues/1225) + + [#1226](https://github.com/agda/agda/issues/1226) + + [#1231](https://github.com/agda/agda/issues/1231) + + [#1233](https://github.com/agda/agda/issues/1233) + + [#1239](https://github.com/agda/agda/issues/1239) + + [#1241](https://github.com/agda/agda/issues/1241) + + [#1243](https://github.com/agda/agda/issues/1243) diff --git a/doc/release-notes/2.4.0.md b/doc/release-notes/2.4.0.md new file mode 100644 --- /dev/null +++ b/doc/release-notes/2.4.0.md @@ -0,0 +1,1211 @@ +Release notes for Agda 2 version 2.4.0 +====================================== + +Installation and infrastructure +------------------------------- + +* A new module called `Agda.Primitive` has been introduced. This + module is available to all users, even if the standard library is + not used. Currently the module contains level primitives and their + representation in Haskell when compiling with MAlonzo: + + ```agda + infixl 6 _⊔_ + + postulate + Level : Set + lzero : Level + lsuc : (ℓ : Level) → Level + _⊔_ : (ℓ₁ ℓ₂ : Level) → Level + + {-# COMPILED_TYPE Level () #-} + {-# COMPILED lzero () #-} + {-# COMPILED lsuc (\_ -> ()) #-} + {-# COMPILED _⊔_ (\_ _ -> ()) #-} + + {-# BUILTIN LEVEL Level #-} + {-# BUILTIN LEVELZERO lzero #-} + {-# BUILTIN LEVELSUC lsuc #-} + {-# BUILTIN LEVELMAX _⊔_ #-} + ``` + + To bring these declarations into scope you can use a declaration + like the following one: + + ```agda + open import Agda.Primitive using (Level; lzero; lsuc; _⊔_) + ``` + + The standard library reexports these primitives (using the names + `zero` and `suc` instead of `lzero` and `lsuc`) from the `Level` + module. + + Existing developments using universe polymorphism might now trigger + the following error message: + + ``` + Duplicate binding for built-in thing LEVEL, previous binding to + .Agda.Primitive.Level + ``` + + To fix this problem, please remove the duplicate bindings. + + Technical details (perhaps relevant to those who build Agda + packages): + + The include path now always contains a directory + `/lib/prim`, and this directory is supposed to contain a + subdirectory Agda containing a file `Primitive.agda`. + + The standard location of `` is system- and + installation-specific. E.g., in a Cabal `--user` installation of + Agda-2.3.4 on a standard single-ghc Linux system it would be + `$HOME/.cabal/share/Agda-2.3.4` or something similar. + + The location of the `` directory can be configured at + compile-time using Cabal flags (`--datadir` and `--datasubdir`). + The location can also be set at run-time, using the `Agda_datadir` + environment variable. + +Pragmas and options +------------------- + +* Pragma `NO_TERMINATION_CHECK` placed within a mutual block is now + applied to the whole mutual block (rather than being discarded + silently). Adding to the uses 1.-4. outlined in the release notes + for 2.3.2 we allow: + + 3a. Skipping an old-style mutual block: Somewhere within `mutual` + block before a type signature or first function clause. + + ```agda + mutual + {-# NO_TERMINATION_CHECK #-} + c : A + c = d + + d : A + d = c + ``` + +* New option `--no-pattern-matching` + + Disables all forms of pattern matching (for the current file). + You can still import files that use pattern matching. + +* New option `-v profile:7` + + Prints some stats on which phases Agda spends how much time. + (Number might not be very reliable, due to garbage collection + interruptions, and maybe due to laziness of Haskell.) + +* New option `--no-sized-types` + + Option `--sized-types` is now default. `--no-sized-types` will turn + off an extra (inexpensive) analysis on data types used for subtyping + of sized types. + +Language +-------- + +* Experimental feature: `quoteContext` + + There is a new keyword `quoteContext` that gives users access to the + list of names in the current local context. For instance: + + ```agda + open import Data.Nat + open import Data.List + open import Reflection + + foo : ℕ → ℕ → ℕ + foo 0 m = 0 + foo (suc n) m = quoteContext xs in ? + ``` + + In the remaining goal, the list `xs` will consist of two names, `n` + and `m`, corresponding to the two local variables. At the moment it + is not possible to access let bound variables (this feature may be + added in the future). + +* Experimental feature: Varying arity. + Function clauses may now have different arity, e.g., + + ```agda + Sum : ℕ → Set + Sum 0 = ℕ + Sum (suc n) = ℕ → Sum n + + sum : (n : ℕ) → ℕ → Sum n + sum 0 acc = acc + sum (suc n) acc m = sum n (m + acc) + ``` + + or, + + ```agda + T : Bool → Set + T true = Bool + T false = Bool → Bool + + f : (b : Bool) → T b + f false true = false + f false false = true + f true = true + ``` + + This feature is experimental. Yet unsupported: + - Varying arity and `with`. + + - Compilation of functions with varying arity to Haskell, JS, or Epic. + +* Experimental feature: copatterns. (Activated with option `--copatterns`) + + We can now define a record by explaining what happens if you project + the record. For instance: + + ```agda + {-# OPTIONS --copatterns #-} + + record _×_ (A B : Set) : Set where + constructor _,_ + field + fst : A + snd : B + open _×_ + + pair : {A B : Set} → A → B → A × B + fst (pair a b) = a + snd (pair a b) = b + + swap : {A B : Set} → A × B → B × A + fst (swap p) = snd p + snd (swap p) = fst p + + swap3 : {A B C : Set} → A × (B × C) → C × (B × A) + fst (swap3 t) = snd (snd t) + fst (snd (swap3 t)) = fst (snd t) + snd (snd (swap3 t)) = fst t + ``` + + Taking a projection on the left hand side (lhs) is called a + projection pattern, applying to a pattern is called an application + pattern. (Alternative terms: projection/application copattern.) + + In the first example, the symbol `pair`, if applied to variable + patterns `a` and `b` and then projected via `fst`, reduces to + `a`. `pair` by itself does not reduce. + + A typical application are coinductive records such as streams: + + ```agda + record Stream (A : Set) : Set where + coinductive + field + head : A + tail : Stream A + open Stream + + repeat : {A : Set} (a : A) -> Stream A + head (repeat a) = a + tail (repeat a) = repeat a + ``` + + Again, `repeat a` by itself will not reduce, but you can take a + projection (head or tail) and then it will reduce to the respective + rhs. This way, we get the lazy reduction behavior necessary to + avoid looping corecursive programs. + + Application patterns do not need to be trivial (i.e., variable + patterns), if we mix with projection patterns. E.g., we can have + + ```agda + nats : Nat -> Stream Nat + head (nats zero) = zero + tail (nats zero) = nats zero + head (nats (suc x)) = x + tail (nats (suc x)) = nats x + ``` + + Here is an example (not involving coinduction) which demostrates + records with fields of function type: + + ```agda + -- The State monad + + record State (S A : Set) : Set where + constructor state + field + runState : S → A × S + open State + + -- The Monad type class + + record Monad (M : Set → Set) : Set1 where + constructor monad + field + return : {A : Set} → A → M A + _>>=_ : {A B : Set} → M A → (A → M B) → M B + + + -- State is an instance of Monad + -- Demonstrates the interleaving of projection and application patterns + + stateMonad : {S : Set} → Monad (State S) + runState (Monad.return stateMonad a ) s = a , s + runState (Monad._>>=_ stateMonad m k) s₀ = + let a , s₁ = runState m s₀ + in runState (k a) s₁ + + module MonadLawsForState {S : Set} where + + open Monad (stateMonad {S}) + + leftId : {A B : Set}(a : A)(k : A → State S B) → + (return a >>= k) ≡ k a + leftId a k = refl + + rightId : {A B : Set}(m : State S A) → + (m >>= return) ≡ m + rightId m = refl + + assoc : {A B C : Set}(m : State S A)(k : A → State S B)(l : B → State S C) → + ((m >>= k) >>= l) ≡ (m >>= λ a → (k a >>= l)) + assoc m k l = refl + ``` + + Copatterns are yet experimental and the following does not work: + + - Copatterns and `with` clauses. + + - Compilation of copatterns to Haskell, JS, or Epic. + + - Projections generated by + + ```agda + open R {{...}} + ``` + + are not handled properly on lhss yet. + + - Conversion checking is slower in the presence of copatterns, since + stuck definitions of record type do no longer count as neutral, + since they can become unstuck by applying a projection. Thus, + comparing two neutrals currently requires comparing all they + projections, which repeats a lot of work. + +* Top-level module no longer required. + + The top-level module can be omitted from an Agda file. The module + name is then inferred from the file name by dropping the path and + the `.agda` extension. So, a module defined in `/A/B/C.agda` would get + the name `C`. + + You can also suppress only the module name of the top-level module + by writing + + ```agda + module _ where + ``` + + This works also for parameterised modules. + +* Module parameters are now always hidden arguments in projections. + For instance: + + ```agda + module M (A : Set) where + + record Prod (B : Set) : Set where + constructor _,_ + field + fst : A + snd : B + open Prod public + + open M + ``` + + Now, the types of `fst` and `snd` are + + ```agda + fst : {A : Set}{B : Set} → Prod A B → A + snd : {A : Set}{B : Set} → Prod A B → B + ``` + + Until 2.3.2, they were + + ```agda + fst : (A : Set){B : Set} → Prod A B → A + snd : (A : Set){B : Set} → Prod A B → B + ``` + + This change is a step towards symmetry of constructors and projections. + (Constructors always took the module parameters as hidden arguments). + +* Telescoping lets: Local bindings are now accepted in telescopes + of modules, function types, and lambda-abstractions. + + The syntax of telescopes as been extended to support `let`: + + ```agda + id : (let ★ = Set) (A : ★) → A → A + id A x = x + ``` + + In particular one can now `open` modules inside telescopes: + + ```agda + module Star where + ★ : Set₁ + ★ = Set + + + module MEndo (let open Star) (A : ★) where + Endo : ★ + Endo = A → A + ``` + + Finally a shortcut is provided for opening modules: + + ```agda + module N (open Star) (A : ★) (open MEndo A) (f : Endo) where + ... + ``` + + The semantics of the latter is + + ```agda + module _ where + open Star + module _ (A : ★) where + open MEndo A + module N (f : Endo) where + ... + ``` + + The semantics of telescoping lets in function types and lambda + abstractions is just expanding them into ordinary lets. + +* More liberal left-hand sides in lets + [Issue [#1028](https://github.com/agda/agda/issues/1028)]: + + You can now write left-hand sides with arguments also for let + bindings without a type signature. For instance, + + ```agda + let f x = suc x in f zero + ``` + + Let bound functions still can't do pattern matching though. + +* Ambiguous names in patterns are now optimistically resolved in favor + of constructors. [Issue [#822](https://github.com/agda/agda/issues/822)] + In particular, the following succeeds now: + + ```agda + module M where + + data D : Set₁ where + [_] : Set → D + + postulate [_] : Set → Set + + open M + + Foo : _ → Set + Foo [ A ] = A + ``` + +* Anonymous `where`-modules are opened + public. [Issue [#848](https://github.com/agda/agda/issues/848)] + + ``` + + f args = rhs + module _ telescope where + body + + ``` + + means the following (not proper Agda code, since you cannot put a + module in-between clauses) + + ``` + + module _ {arg-telescope} telescope where + body + + f args = rhs + + ``` + + Example: + + ```agda + A : Set1 + A = B module _ where + B : Set1 + B = Set + + C : Set1 + C = B + ``` + +* Builtin `ZERO` and `SUC` have been merged with `NATURAL`. + + When binding the `NATURAL` builtin, `ZERO` and `SUC` are bound to + the appropriate constructors automatically. This means that instead + of writing + + ```agda + {-# BUILTIN NATURAL Nat #-} + {-# BUILTIN ZERO zero #-} + {-# BUILTIN SUC suc #-} + ``` + + you just write + + ```agda + {-# BUILTIN NATURAL Nat #-} + ``` + +* Pattern synonym can now have implicit + arguments. [Issue [#860](https://github.com/agda/agda/issues/860)] + + For example, + + ```agda + pattern tail=_ {x} xs = x ∷ xs + + len : ∀ {A} → List A → Nat + len [] = 0 + len (tail= xs) = 1 + len xs + ``` + +* Syntax declarations can now have implicit + arguments. [Issue [#400](https://github.com/agda/agda/issues/400)] + + For example + + ```agda + id : ∀ {a}{A : Set a} -> A -> A + id x = x + + syntax id {A} x = x ∈ A + ``` + +* Minor syntax changes + + - `-}` is now parsed as end-comment even if no comment was begun. As + a consequence, the following definition gives a parse error + + ```agda + f : {A- : Set} -> Set + f {A-} = A- + ``` + + because Agda now sees `ID(f) LBRACE ID(A) END-COMMENT`, and no + longer `ID(f) LBRACE ID(A-) RBRACE`. + + The rational is that the previous lexing was to context-sensitive, + attempting to comment-out `f` using `{-` and `-}` lead to a parse + error. + + - Fixities (binding strengths) can now be negative numbers as + well. [Issue [#1109](https://github.com/agda/agda/issues/1109)] + + ```agda + infix -1 _myop_ + ``` + + - Postulates are now allowed in mutual + blocks. [Issue [#977](https://github.com/agda/agda/issues/977)] + + - Empty where blocks are now + allowed. [Issue [#947](https://github.com/agda/agda/issues/947)] + + - Pattern synonyms are now allowed in parameterised + modules. [Issue [#941](https://github.com/agda/agda/issues/941)] + + - Empty hiding and renaming lists in module directives are now allowed. + + - Module directives `using`, `hiding`, `renaming` and `public` can + now appear in arbitrary order. Multiple + `using`/`hiding`/`renaming` directives are allowed, but you still + cannot have both using and `hiding` (because that doesn't make + sense). [Issue [#493](https://github.com/agda/agda/issues/493)] + +Goal and error display +---------------------- + +* The error message `Refuse to construct infinite term` has been + removed, instead one gets unsolved meta variables. Reason: the + error was thrown over-eagerly. + [Issue [#795](https://github.com/agda/agda/issues/795)] + +* If an interactive case split fails with message + + ``` + Since goal is solved, further case distinction is not supported; + try `Solve constraints' instead + ``` + + then the associated interaction meta is assigned to a solution. + Press `C-c C-=` (Show constraints) to view the solution and `C-c + C-s` (Solve constraints) to apply it. + [Issue [#289](https://github.com/agda/agda/issues/289)] + +Type checking +------------- + +* [ Issue [#376](https://github.com/agda/agda/issues/376) ] + Implemented expansion of bound record variables during meta + assignment. Now Agda can solve for metas X that are applied to + projected variables, e.g.: + + ```agda + X (fst z) (snd z) = z + + X (fst z) = fst z + ``` + + Technically, this is realized by substituting `(x , y)` for `z` with fresh + bound variables `x` and `y`. Here the full code for the examples: + + ```agda + record Sigma (A : Set)(B : A -> Set) : Set where + constructor _,_ + field + fst : A + snd : B fst + open Sigma + + test : (A : Set) (B : A -> Set) -> + let X : (x : A) (y : B x) -> Sigma A B + X = _ + in (z : Sigma A B) -> X (fst z) (snd z) ≡ z + test A B z = refl + + test' : (A : Set) (B : A -> Set) -> + let X : A -> A + X = _ + in (z : Sigma A B) -> X (fst z) ≡ fst z + test' A B z = refl + ``` + + The fresh bound variables are named `fst(z)` and `snd(z)` and can appear + in error messages, e.g.: + + ```agda + fail : (A : Set) (B : A -> Set) -> + let X : A -> Sigma A B + X = _ + in (z : Sigma A B) -> X (fst z) ≡ z + fail A B z = refl + ``` + + results in error: + + ``` + Cannot instantiate the metavariable _7 to solution fst(z) , snd(z) + since it contains the variable snd(z) which is not in scope of the + metavariable or irrelevant in the metavariable but relevant in the + solution + when checking that the expression refl has type _7 A B (fst z) ≡ z + ``` + +* Dependent record types and definitions by copatterns require + reduction with previous function clauses while checking the current + clause. [Issue [#907](https://github.com/agda/agda/issues/907)] + + For a simple example, consider + + ```agda + test : ∀ {A} → Σ Nat λ n → Vec A n + proj₁ test = zero + proj₂ test = [] + ``` + + For the second clause, the lhs and rhs are typed as + + ```agda + proj₂ test : Vec A (proj₁ test) + [] : Vec A zero + ``` + + In order for these types to match, we have to reduce the lhs type + with the first function clause. + + Note that termination checking comes after type checking, so be + careful to avoid non-termination! Otherwise, the type checker + might get into an infinite loop. + +* The implementation of the primitive `primTrustMe` has changed. It + now only reduces to `REFL` if the two arguments `x` and `y` have the + same computational normal form. Before, it reduced when `x` and `y` + were definitionally equal, which included type-directed equality + laws such as eta-equality. Yet because reduction is untyped, + calling conversion from reduction lead to Agda crashes + [Issue [#882](https://github.com/agda/agda/issues/882)]. + + The amended description of `primTrustMe` is (cf. release notes + for 2.2.6): + + ```agda + primTrustMe : {A : Set} {x y : A} → x ≡ y + ``` + + Here `_≡_` is the builtin equality (see BUILTIN hooks for equality, + above). + + If `x` and `y` have the same computational normal form, then + `primTrustMe {x = x} {y = y}` reduces to `refl`. + + A note on `primTrustMe`'s runtime behavior: The MAlonzo compiler + replaces all uses of `primTrustMe` with the `REFL` builtin, without + any check for definitional equality. Incorrect uses of `primTrustMe` + can potentially lead to segfaults or similar problems of the + compiled code. + +* Implicit patterns of record type are now only eta-expanded if there + is a record constructor. + [Issues [#473](https://github.com/agda/agda/issues/473), + [#635](https://github.com/agda/agda/issues/635)] + + ```agda + data D : Set where + d : D + + data P : D → Set where + p : P d + + record Rc : Set where + constructor c + field f : D + + works : {r : Rc} → P (Rc.f r) → Set + works p = D + ``` + + This works since the implicit pattern `r` is eta-expanded to `c x` + which allows the type of `p` to reduce to `P x` and `x` to be + unified with `d`. The corresponding explicit version is: + + ```agda + works' : (r : Rc) → P (Rc.f r) → Set + works' (c .d) p = D + ``` + + However, if the record constructor is removed, the same example will + fail: + + ```agda + record R : Set where + field f : D + + fails : {r : R} → P (R.f r) → Set + fails p = D + + -- d != R.f r of type D + -- when checking that the pattern p has type P (R.f r) + ``` + + The error is justified since there is no pattern we could write down + for `r`. It would have to look like + + ```agda + record { f = .d } + ``` + + but anonymous record patterns are not part of the language. + +* Absurd lambdas at different source locations are no longer + different. [Issue [#857](https://github.com/agda/agda/issues/857)] + In particular, the following code type-checks now: + + ```agda + absurd-equality : _≡_ {A = ⊥ → ⊥} (λ()) λ() + absurd-equality = refl + ``` + + Which is a good thing! + +* Printing of named implicit function types. + + When printing terms in a context with bound variables Agda renames + new bindings to avoid clashes with the previously bound names. For + instance, if `A` is in scope, the type `(A : Set) → A` is printed as + `(A₁ : Set) → A₁`. However, for implicit function types the name of + the binding matters, since it can be used when giving implicit + arguments. + + For this situation, the following new syntax has been introduced: + `{x = y : A} → B` is an implicit function type whose bound variable + (in scope in `B`) is `y`, but where the name of the argument is `x` + for the purposes of giving it explicitly. For instance, with `A` in + scope, the type `{A : Set} → A` is now printed as `{A = A₁ : Set} → + A₁`. + + This syntax is only used when printing and is currently not being parsed. + +* Changed the semantics of `--without-K`. + [Issue [#712](https://github.com/agda/agda/issues/712), + Issue [#865](https://github.com/agda/agda/issues/865), + Issue [#1025](https://github.com/agda/agda/issues/1025)] + + New specification of `--without-K`: + + When `--without-K` is enabled, the unification of indices for + pattern matching is restricted in two ways: + + 1. Reflexive equations of the form `x == x` are no longer solved, + instead Agda gives an error when such an equation is encountered. + + 2. When unifying two same-headed constructor forms `c us` and `c vs` + of type `D pars ixs`, the datatype indices `ixs` (but not the + parameters) have to be *self-unifiable*, i.e. unification of + `ixs` with itself should succeed positively. This is a nontrivial + requirement because of point 1. + + Examples: + + - The J rule is accepted. + + ```agda + J : {A : Set} (P : {x y : A} → x ≡ y → Set) → + (∀ x → P (refl x)) → + ∀ {x y} (x≡y : x ≡ y) → P x≡y + J P p (refl x) = p x + ```agda + + This definition is accepted since unification of `x` with `y` + doesn't require deletion or injectivity. + + - The K rule is rejected. + + ```agda + K : {A : Set} (P : {x : A} → x ≡ x → Set) → + (∀ x → P (refl {x = x})) → + ∀ {x} (x≡x : x ≡ x) → P x≡x + K P p refl = p _ + ``` + + Definition is rejected with the following error: + + ``` + Cannot eliminate reflexive equation x = x of type A because K has + been disabled. + when checking that the pattern refl has type x ≡ x + ``` + + - Symmetry of the new criterion. + + ```agda + test₁ : {k l m : ℕ} → k + l ≡ m → ℕ + test₁ refl = zero + + test₂ : {k l m : ℕ} → k ≡ l + m → ℕ + test₂ refl = zero + ``` + + Both versions are now accepted (previously only the first one was). + + - Handling of parameters. + + ```agda + cons-injective : {A : Set} (x y : A) → (x ∷ []) ≡ (y ∷ []) → x ≡ y + cons-injective x .x refl = refl + ``` + + Parameters are not unified, so they are ignored by the new criterion. + + - A larger example: antisymmetry of ≤. + + ```agda + data _≤_ : ℕ → ℕ → Set where + lz : (n : ℕ) → zero ≤ n + ls : (m n : ℕ) → m ≤ n → suc m ≤ suc n + + ≤-antisym : (m n : ℕ) → m ≤ n → n ≤ m → m ≡ n + ≤-antisym .zero .zero (lz .zero) (lz .zero) = refl + ≤-antisym .(suc m) .(suc n) (ls m n p) (ls .n .m q) = + cong suc (≤-antisym m n p q) + ``` + + - [ Issue [#1025](https://github.com/agda/agda/issues/1025) ] + + ```agda + postulate mySpace : Set + postulate myPoint : mySpace + + data Foo : myPoint ≡ myPoint → Set where + foo : Foo refl + + test : (i : foo ≡ foo) → i ≡ refl + test refl = {!!} + ``` + + When applying injectivity to the equation `foo ≡ foo` of type `Foo + refl`, it is checked that the index `refl` of type `myPoint ≡ + myPoint` is self-unifiable. The equation `refl ≡ refl` again + requires injectivity, so now the index `myPoint` is checked for + self-unifiability, hence the error: + + ``` + Cannot eliminate reflexive equation myPoint = myPoint of type + mySpace because K has been disabled. + when checking that the pattern refl has type foo ≡ foo + ``` + +Termination checking +-------------------- + +* A buggy facility coined "matrix-shaped orders" that supported + uncurried functions (which take tuples of arguments instead of one + argument after another) has been removed from the termination + checker. [Issue [#787](https://github.com/agda/agda/issues/787)] + +* Definitions which fail the termination checker are not unfolded any + longer to avoid loops or stack overflows in Agda. However, the + termination checker for a mutual block is only invoked after + type-checking, so there can still be loops if you define a + non-terminating function. But termination checking now happens + before the other supplementary checks: positivity, polarity, + injectivity and projection-likeness. Note that with the pragma `{-# + NO_TERMINATION_CHECK #-}` you can make Agda treat any function as + terminating. + +* Termination checking of functions defined by `with` has been improved. + + Cases which previously required `--termination-depth` to pass the + termination checker (due to use of `with`) no longer need the + flag. For example + + ```agda + merge : List A → List A → List A + merge [] ys = ys + merge xs [] = xs + merge (x ∷ xs) (y ∷ ys) with x ≤ y + merge (x ∷ xs) (y ∷ ys) | false = y ∷ merge (x ∷ xs) ys + merge (x ∷ xs) (y ∷ ys) | true = x ∷ merge xs (y ∷ ys) + ``` + + This failed to termination check previously, since the `with` + expands to an auxiliary function `merge-aux`: + + ```agda + merge-aux x y xs ys false = y ∷ merge (x ∷ xs) ys + merge-aux x y xs ys true = x ∷ merge xs (y ∷ ys) + ``` + + This function makes a call to `merge` in which the size of one of + the arguments is increasing. To make this pass the termination + checker now inlines the definition of `merge-aux` before checking, + thus effectively termination checking the original source program. + + As a result of this transformation doing `with` on a variable no longer + preserves termination. For instance, this does not termination check: + + ```agda + bad : Nat → Nat + bad n with n + ... | zero = zero + ... | suc m = bad m + ``` + +* The performance of the termination checker has been improved. For + higher `--termination-depth` the improvement is significant. While + the default `--termination-depth` is still 1, checking with higher + `--termination-depth` should now be feasible. + +Compiler backends +----------------- + +* The MAlonzo compiler backend now has support for compiling modules + that are not full programs (i.e. don't have a main function). The + goal is that you can write part of a program in Agda and the rest in + Haskell, and invoke the Agda functions from the Haskell code. The + following features were added for this reason: + + - A new command-line option `--compile-no-main`: the command + + ``` + agda --compile-no-main Test.agda + ``` + + will compile `Test.agda` and all its dependencies to Haskell and + compile the resulting Haskell files with `--make`, but (unlike + `--compile`) not tell GHC to treat `Test.hs` as the main + module. This type of compilation can be invoked from Emacs by + customizing the `agda2-backend` variable to value `MAlonzoNoMain` and + then calling `C-c C-x C-c` as before. + + - A new pragma `COMPILED_EXPORT` was added as part of the MAlonzo + FFI. If we have an Agda file containing the following: + + ```agda + module A.B where + + test : SomeType + test = someImplementation + + {-# COMPILED_EXPORT test someHaskellId #-} + ``` + + then test will be compiled to a Haskell function called + `someHaskellId` in module `MAlonzo.Code.A.B` that can be invoked + from other Haskell code. Its type will be translated according to + the normal MAlonzo rules. + +Tools +----- + +### Emacs mode + +* A new goal command `Helper Function Type` (`C-c C-h`) has been added. + + If you write an application of an undefined function in a goal, the + `Helper Function Type` command will print the type that the function + needs to have in order for it to fit the goal. The type is also + added to the Emacs kill-ring and can be pasted into the buffer using + `C-y`. + + The application must be of the form `f args` where `f` is the name of the + helper function you want to create. The arguments can use all the normal + features like named implicits or instance arguments. + + Example: + + Here's a start on a naive reverse on vectors: + + ```agda + reverse : ∀ {A n} → Vec A n → Vec A n + reverse [] = [] + reverse (x ∷ xs) = {!snoc (reverse xs) x!} + ``` + + Calling `C-c C-h` in the goal prints + + ```agda + snoc : ∀ {A} {n} → Vec A n → A → Vec A (suc n) + ``` + +* A new command `Explain why a particular name is in scope` (`C-c + C-w`) has been added. + [Issue [#207](https://github.com/agda/agda/issues/207)] + + This command can be called from a goal or from the top-level and will as the + name suggests explain why a particular name is in scope. + + For each definition or module that the given name can refer to a trace is + printed of all open statements and module applications leading back to the + original definition of the name. + + For example, given + + ```agda + module A (X : Set₁) where + data Foo : Set where + mkFoo : Foo + module B (Y : Set₁) where + open A Y public + module C = B Set + open C + ``` + + Calling `C-c C-w` on `mkFoo` at the top-level prints + + ``` + mkFoo is in scope as + * a constructor Issue207.C._.Foo.mkFoo brought into scope by + - the opening of C at Issue207.agda:13,6-7 + - the application of B at Issue207.agda:11,12-13 + - the application of A at Issue207.agda:9,8-9 + - its definition at Issue207.agda:6,5-10 + ``` + + This command is useful if Agda complains about an ambiguous name and + you need to figure out how to hide the undesired interpretations. + +* Improvements to the `make case` command (`C-c C-c`) + + - One can now also split on hidden variables, using the name + (starting with `.`) with which they are printed. Use `C-c C-`, to + see all variables in context. + + - Concerning the printing of generated clauses: + + * Uses named implicit arguments to improve readability. + + * Picks explicit occurrences over implicit ones when there is a + choice of binding site for a variable. + + * Avoids binding variables in implicit positions by replacing dot + patterns that uses them by wildcards (`._`). + +* Key bindings for lots of "mathematical" characters (examples: 𝐴𝑨𝒜𝓐𝔄) + have been added to the Agda input method. Example: type + `\MiA\MIA\McA\MCA\MfA` to get 𝐴𝑨𝒜𝓐𝔄. + + Note: `\McB` does not exist in Unicode (as well as others in that style), + but the `\MC` (bold) alphabet is complete. + +* Key bindings for "blackboard bold" B (𝔹) and 0-9 (𝟘-𝟡) have been + added to the Agda input method (`\bb` and `\b[0-9]`). + +* Key bindings for controlling simplification/normalisation: + + Commands like `Goal type and context` (`C-c C-,`) could previously + be invoked in two ways. By default the output was normalised, but if + a prefix argument was used (for instance via `C-u C-c C-,`), then no + explicit normalisation was performed. Now there are three options: + + - By default (`C-c C-,`) the output is simplified. + + - If `C-u` is used exactly once (`C-u C-c C-,`), then the result is + neither (explicitly) normalised nor simplified. + + - If `C-u` is used twice (`C-u C-u C-c C-,`), then the result is + normalised. + +### LaTeX-backend + +* Two new color scheme options were added to `agda.sty`: + + `\usepackage[bw]{agda}`, which highlights in black and white; + `\usepackage[conor]{agda}`, which highlights using Conor's colors. + + The default (no options passed) is to use the standard colors. + +* If `agda.sty` cannot be found by the LateX environment, it is now + copied into the LateX output directory (`latex` by default) instead + of the working directory. This means that the commands needed to + produce a PDF now is + + ``` + agda --latex -i . .lagda + cd latex + pdflatex .tex + ``` + +* The LaTeX-backend has been made more tool agnostic, in particular + XeLaTeX and LuaLaTeX should now work. Here is a small example + (`test/LaTeXAndHTML/succeed/UnicodeInput.lagda`): + + ```latex + \documentclass{article} + \usepackage{agda} + \begin{document} + + \begin{code} + data αβγδεζθικλμνξρστυφχψω : Set₁ where + + postulate + →⇒⇛⇉⇄↦⇨↠⇀⇁ : Set + \end{code} + + \[ + ∀X [ ∅ ∉ X ⇒ ∃f:X ⟶ ⋃ X\ ∀A ∈ X (f(A) ∈ A) ] + \] + \end{document} + ``` + + Compiled as follows, it should produce a nice looking PDF (tested with + TeX Live 2012): + + ``` + agda --latex .lagda + cd latex + xelatex .tex (or lualatex .tex) + ``` + + If symbols are missing or XeLaTeX/LuaLaTeX complains about the font + missing, try setting a different font using: + + ```latex + \setmathfont{} + ``` + + Use the `fc-list` tool to list available fonts. + +* Add experimental support for hyperlinks to identifiers + + If the `hyperref` LateX package is loaded before the Agda package + and the links option is passed to the Agda package, then the Agda + package provides a function called `\AgdaTarget`. Identifiers which + have been declared targets, by the user, will become clickable + hyperlinks in the rest of the document. Here is a small example + (`test/LaTeXAndHTML/succeed/Links.lagda`): + + ```latex + \documentclass{article} + \usepackage{hyperref} + \usepackage[links]{agda} + \begin{document} + + \AgdaTarget{ℕ} + \AgdaTarget{zero} + \begin{code} + data ℕ : Set where + zero : ℕ + suc : ℕ → ℕ + \end{code} + + See next page for how to define \AgdaFunction{two} (doesn't turn into a + link because the target hasn't been defined yet). We could do it + manually though; \hyperlink{two}{\AgdaDatatype{two}}. + + \newpage + + \AgdaTarget{two} + \hypertarget{two}{} + \begin{code} + two : ℕ + two = suc (suc zero) + \end{code} + + \AgdaInductiveConstructor{zero} is of type + \AgdaDatatype{ℕ}. \AgdaInductiveConstructor{suc} has not been defined to + be a target so it doesn't turn into a link. + + \newpage + + Now that the target for \AgdaFunction{two} has been defined the link + works automatically. + + \begin{code} + data Bool : Set where + true false : Bool + \end{code} + + The AgdaTarget command takes a list as input, enabling several + targets to be specified as follows: + + \AgdaTarget{if, then, else, if\_then\_else\_} + \begin{code} + if_then_else_ : {A : Set} → Bool → A → A → A + if true then t else f = t + if false then t else f = f + \end{code} + + \newpage + + Mixfix identifier need their underscores escaped: + \AgdaFunction{if\_then\_else\_}. + + \end{document} + ``` + + The boarders around the links can be suppressed using hyperref's + hidelinks option: + + ```latex + \usepackage[hidelinks]{hyperref} + ``` + + Note that the current approach to links does not keep track of scoping + or types, and hence overloaded names might create links which point to + the wrong place. Therefore it is recommended to not overload names + when using the links option at the moment, this might get fixed in the + future. diff --git a/doc/release-notes/2.4.2.1.md b/doc/release-notes/2.4.2.1.md new file mode 100644 --- /dev/null +++ b/doc/release-notes/2.4.2.1.md @@ -0,0 +1,214 @@ +Release notes for Agda version 2.4.2.1 +====================================== + +Pragmas and options +------------------- + +* New pragma `{-# TERMINATING #-}` replacing + `{-# NO_TERMINATION_CHECK #-}` + + Complements the existing pragma `{-# NON_TERMINATING #-}`. Skips + termination check for the associated definitions and marks them as + terminating. Thus, it is a replacement for `{-# + NO_TERMINATION_CHECK #-}` with the same semantics. + + You can no longer use pragma `{-# NO_TERMINATION_CHECK #-}` to skip + the termination check, but must label your definitions as either + `{-# TERMINATING #-}` or `{-# NON_TERMINATING #-}` instead. + + Note: `{-# OPTION --no-termination-check #-}` labels all your + definitions as `{-# TERMINATING #-}`, putting you in the danger zone + of a loop in the type checker. + +Language +-------- + +* Referring to a local variable shadowed by module opening is now an + error. Previous behavior was preferring the local over the imported + definitions. [Issue [#1266](https://github.com/agda/agda/issues/1266)] + + Note that module parameters are locals as well as variables bound by + λ, dependent function type, patterns, and let. + + Example: + + ```agda + module M where + A = Set1 + + test : (A : Set) → let open M in A + ``` + + The last `A` produces an error, since it could refer to the local + variable `A` or to the definition imported from module `M`. + +* `with` on a variable bound by a module telescope or a pattern of a + parent function is now forbidden. + [Issue [#1342](https://github.com/agda/agda/issues/1342)] + + ```agda + data Unit : Set where + unit : Unit + + id : (A : Set) → A → A + id A a = a + + module M (x : Unit) where + + dx : Unit → Unit + dx unit = x + + g : ∀ u → x ≡ dx u + g with x + g | unit = id (∀ u → unit ≡ dx u) ? + ``` + + Even though this code looks right, Agda complains about the type + expression `∀ u → unit ≡ dx u`. If you ask Agda what should go + there instead, it happily tells you that it wants `∀ u → unit ≡ dx + u`. In fact what you do not see and Agda will never show you is that + the two expressions actually differ in the invisible first argument + to `dx`, which is visible only outside module `M`. What Agda wants + is an invisible `unit` after `dx`, but all you can write is an + invisible `x` (which is inserted behind the scenes). + + To avoid those kinds of paradoxes, `with` is now outlawed on module + parameters. This should ensure that the invisible arguments are + always exactly the module parameters. + + Since a `where` block is desugared as module with pattern variables + of the parent clause as module parameters, the same strikes you for + uses of `with` on pattern variables of the parent function. + + ```agda + f : Unit → Unit + f x = unit + where + dx : Unit → Unit + dx unit = x + + g : ∀ u → x ≡ dx u + g with x + g | unit = id ((u : Unit) → unit ≡ dx u) ? + ``` + + The `with` on pattern variable `x` of the parent clause `f x = unit` + is outlawed now. + +Type checking +------------- + +* Termination check failure is now a proper error. + + We no longer continue type checking after termination check + failures. Use pragmas `{-# NON_TERMINATING #-}` and `{-# + NO_TERMINATION_CHECK #-}` near the offending definitions if you want + to do so. Or switch off the termination checker altogether with + `{-# OPTIONS --no-termination-check #-}` (at your own risk!). + +* (Since Agda 2.4.2): Termination checking `--without-K` restricts + structural descent to arguments ending in data types or `Size`. + Likewise, guardedness is only tracked when result type is data or + record type. + + ```agda + mutual + data WOne : Set where wrap : FOne → WOne + FOne = ⊥ → WOne + + noo : (X : Set) → (WOne ≡ X) → X → ⊥ + noo .WOne refl (wrap f) = noo FOne iso f + ``` + + `noo` is rejected since at type `X` the structural descent + `f < wrap f` is discounted `--without-K`. + + ```agda + data Pandora : Set where + C : ∞ ⊥ → Pandora + + loop : (A : Set) → A ≡ Pandora → A + loop .Pandora refl = C (♯ (loop ⊥ foo)) + ``` + + `loop` is rejected since guardedness is not tracked at type `A` + `--without-K`. + + See issues [#1023](https://github.com/agda/agda/issues/1023), + [#1264](https://github.com/agda/agda/issues/1264), + [#1292](https://github.com/agda/agda/issues/1292). + +Termination checking +-------------------- + +* The termination checker can now recognize simple subterms in dot + patterns. + + ```agda + data Subst : (d : Nat) → Set where + c₁ : ∀ {d} → Subst d → Subst d + c₂ : ∀ {d₁ d₂} → Subst d₁ → Subst d₂ → Subst (suc d₁ + d₂) + + postulate + comp : ∀ {d₁ d₂} → Subst d₁ → Subst d₂ → Subst (d₁ + d₂) + + lookup : ∀ d → Nat → Subst d → Set₁ + lookup d zero (c₁ ρ) = Set + lookup d (suc v) (c₁ ρ) = lookup d v ρ + lookup .(suc d₁ + d₂) v (c₂ {d₁} {d₂} ρ σ) = lookup (d₁ + d₂) v (comp ρ σ) + ``` + + The dot pattern here is actually normalized, so it is + + ```agda + suc (d₁ + d₂) + ``` + + and the corresponding recursive call argument is `(d₁ + d₂)`. In + such simple cases, Agda can now recognize that the pattern is + constructor applied to call argument, which is valid descent. + + Note however, that Agda only looks for syntactic equality when + identifying subterms, since it is not allowed to normalize terms on + the rhs during termination checking. + + Actually writing the dot pattern has no effect, this works as well, + and looks pretty magical... ;-) + + ```agda + hidden : ∀{d} → Nat → Subst d → Set₁ + hidden zero (c₁ ρ) = Set + hidden (suc v) (c₁ ρ) = hidden v ρ + hidden v (c₂ ρ σ) = hidden v (comp ρ σ) + ``` + +Tools +----- + +### LaTeX-backend + +* Fixed the issue of identifiers containing operators being typeset with + excessive math spacing. + +Bug fixes +--------- + +* Issue [#1194](https://github.com/agda/agda/issues/1194) + +* Issue [#836](https://github.com/agda/agda/issues/836): Fields and + constructors can be qualified by the record/data *type* as well as + by their record/data module. This now works also for record/data + type imported from parametrized modules: + + ```agda + module M (_ : Set₁) where + + record R : Set₁ where + field + X : Set + + open M Set using (R) -- rather than using (module R) + + X : R → Set + X = R.X + ``` diff --git a/doc/release-notes/2.4.2.2.md b/doc/release-notes/2.4.2.2.md new file mode 100644 --- /dev/null +++ b/doc/release-notes/2.4.2.2.md @@ -0,0 +1,20 @@ +Release notes for Agda version 2.4.2.2 +====================================== + +Bug fixes +--------- + +* Compilation on Windows fixed. + +* Other issues fixed (see + [bug tracker](https://github.com/agda/agda/issues)) + + [#1332](https://github.com/agda/agda/issues/1322) + + [#1353](https://github.com/agda/agda/issues/1353) + + [#1360](https://github.com/agda/agda/issues/1360) + + [#1366](https://github.com/agda/agda/issues/1366) + + [#1369](https://github.com/agda/agda/issues/1369) diff --git a/doc/release-notes/2.4.2.3.md b/doc/release-notes/2.4.2.3.md new file mode 100644 --- /dev/null +++ b/doc/release-notes/2.4.2.3.md @@ -0,0 +1,303 @@ +Release notes for Agda version 2.4.2.3 +====================================== + +Installation and infrastructure +------------------------------- + +* Added support for GHC 7.10.1. + +* Removed support for GHC 7.0.4. + +Language +-------- + +* `_ `is no longer a valid name for a definition. The following fails + now: [Issue [#1465](https://github.com/agda/agda/issues/1465)] + + ```agda + postulate _ : Set + ``` + +* Typed bindings can now contain hiding information + [Issue [#1391](https://github.com/agda/agda/issues/1391)]. This + means you can now write + + ```agda + assoc : (xs {ys zs} : List A) → ((xs ++ ys) ++ zs) ≡ (xs ++ (ys ++ zs)) + ``` + + instead of the longer + + ```agda + assoc : (xs : List A) {ys zs : List A} → ... + ``` + + It also works with irrelevance + + ```agda + .(xs {ys zs} : List A) → ... + ``` + + but of course does not make sense if there is hiding information already. + Thus, this is (still) a parse error: + + ```agda + {xs {ys zs} : List A} → ... + ``` + +* The builtins for sized types no longer need accompanying postulates. + The BUILTIN pragmas for size stuff now also declare the identifiers + they bind to. + + ```agda + {-# BUILTIN SIZEUNIV SizeUniv #-} -- SizeUniv : SizeUniv + {-# BUILTIN SIZE Size #-} -- Size : SizeUniv + {-# BUILTIN SIZELT Size<_ #-} -- Size<_ : ..Size → SizeUniv + {-# BUILTIN SIZESUC ↑_ #-} -- ↑_ : Size → Size + {-# BUILTIN SIZEINF ∞ #-} -- ∞ : Size + ``` + + `Size` and `Size<` now live in the new universe `SizeUniv`. It is + forbidden to build function spaces in this universe, in order to + prevent the malicious assumption of a size predecessor + + ```agda + pred : (i : Size) → Size< i + ``` + + [Issue [#1428](https://github.com/agda/agda/issues/1428)]. + +* Unambiguous notations (coming from syntax declarations) that resolve + to ambiguous names are now parsed unambiguously + [Issue [#1194](https://github.com/agda/agda/issues/1194)]. + +* If only some instances of an overloaded name have a given associated + notation (coming from syntax declarations), then this name can only + be resolved to the given instances of the name, not to other + instances [Issue [#1194](https://github.com/agda/agda/issues/1194)]. + + Previously, if different instances of an overloaded name had + *different* associated notations, then none of the notations could + be used. Now all of them can be used. + + Note that notation identity does not only involve the right-hand + side of the syntax declaration. For instance, the following + notations are not seen as identical, because the implicit argument + names are different: + + ```agda + module A where + + data D : Set where + c : {x y : D} → D + + syntax c {x = a} {y = b} = a ∙ b + + module B where + + data D : Set where + c : {y x : D} → D + + syntax c {y = a} {x = b} = a ∙ b + ``` + +* If an overloaded operator is in scope with at least two distinct + fixities, then it gets the default fixity + [Issue [#1436](https://github.com/agda/agda/issues/1436)]. + + Similarly, if two or more identical notations for a given overloaded + name are in scope, and these notations do not all have the + same fixity, then they get the default fixity. + +Type checking +------------- + +* Functions of varying arity can now have with-clauses and use rewrite. + + Example: + + ```agda + NPred : Nat → Set + NPred 0 = Bool + NPred (suc n) = Nat → NPred n + + const : Bool → ∀{n} → NPred n + const b {0} = b + const b {suc n} m = const b {n} + + allOdd : ∀ n → NPred n + allOdd 0 = true + allOdd (suc n) m with even m + ... | true = const false + ... | false = allOdd n + ``` + +* Function defined by copattern matching can now have `with`-clauses + and use `rewrite`. + + Example: + + ```agda + {-# OPTIONS --copatterns #-} + + record Stream (A : Set) : Set where + coinductive + constructor delay + field + force : A × Stream A + open Stream + + map : ∀{A B} → (A → B) → Stream A → Stream B + force (map f s) with force s + ... | a , as = f a , map f as + + record Bisim {A B} (R : A → B → Set) (s : Stream A) (t : Stream B) : Set where + coinductive + constructor ~delay + field + ~force : let a , as = force s + b , bs = force t + in R a b × Bisim R as bs + open Bisim + + SEq : ∀{A} (s t : Stream A) → Set + SEq = Bisim (_≡_) + + -- Slightly weird definition of symmetry to demonstrate rewrite. + + ~sym' : ∀{A} {s t : Stream A} → SEq s t → SEq t s + ~force (~sym' {s = s} {t} p) with force s | force t | ~force p + ... | a , as | b , bs | r , q rewrite r = refl , ~sym' q + ``` + +* Instances can now be defined by copattern + matching. [Issue [#1413](https://github.com/agda/agda/issues/1413)] + The following example extends the one in + [Abel, Pientka, Thibodeau, Setzer, POPL 2013, Section 2.2]: + + ```agda + {-# OPTIONS --copatterns #-} + + -- The Monad type class + + record Monad (M : Set → Set) : Set1 where + field + return : {A : Set} → A → M A + _>>=_ : {A B : Set} → M A → (A → M B) → M B + open Monad {{...}} + + -- The State newtype + + record State (S A : Set) : Set where + field + runState : S → A × S + open State + + -- State is an instance of Monad + + instance + stateMonad : {S : Set} → Monad (State S) + runState (return {{stateMonad}} a ) s = a , s -- NEW + runState (_>>=_ {{stateMonad}} m k) s₀ = -- NEW + let a , s₁ = runState m s₀ + in runState (k a) s₁ + + -- stateMonad fulfills the monad laws + + leftId : {A B S : Set}(a : A)(k : A → State S B) → + (return a >>= k) ≡ k a + leftId a k = refl + + rightId : {A B S : Set}(m : State S A) → + (m >>= return) ≡ m + rightId m = refl + + assoc : {A B C S : Set}(m : State S A)(k : A → State S B)(l : B → State S C) → + ((m >>= k) >>= l) ≡ (m >>= λ a → k a >>= l) + assoc m k l = refl + ``` + +Emacs mode +---------- + +* The new menu option `Switch to another version of Agda` tries to do + what it says. + +* Changed feature: Interactively split result. + + [ This is as before: ] + Make-case (`C-c C-c`) with no variables given tries to split on the + result to introduce projection patterns. The hole needs to be of + record type, of course. + + ```agda + test : {A B : Set} (a : A) (b : B) → A × B + test a b = ? + ``` + + Result-splitting `?` will produce the new clauses: + + ```agda + proj₁ (test a b) = ? + proj₂ (test a b) = ? + ``` + + [ This has changed: ] + If hole is of function type, `make-case` will introduce only pattern + variables (as much as it can). + + ```agda + testFun : {A B : Set} (a : A) (b : B) → A × B + testFun = ? + ``` + + Result-splitting `?` will produce the new clause: + + ```agda + testFun a b = ? + ``` + + A second invocation of `make-case` will then introduce projection + patterns. + +Error messages +-------------- + +* Agda now suggests corrections of misspelled options, e.g. + + ```agda + {-# OPTIONS + --dont-termination-check + --without-k + --senf-gurke + #-} + ``` + + Unrecognized options: + + ``` + --dont-termination-check (did you mean --no-termination-check ?) + --without-k (did you mean --without-K ?) + --senf-gurke + ``` + + Nothing close to `--senf-gurke`, I am afraid. + +Compiler backends +----------------- + +* The Epic backend has been removed + [Issue [#1481](https://github.com/agda/agda/issues/1481)]. + +Bug fixes +--------- + +* Fixed bug with `unquoteDecl` not working in instance blocks + [Issue [#1491](https://github.com/agda/agda/issues/1491)]. + +* Other issues fixed (see + [bug tracker](https://github.com/agda/agda/issues) + + [#1497](https://github.com/agda/agda/issues/1497) + + [#1500](https://github.com/agda/agda/issues/1500) diff --git a/doc/release-notes/2.4.2.4.md b/doc/release-notes/2.4.2.4.md new file mode 100644 --- /dev/null +++ b/doc/release-notes/2.4.2.4.md @@ -0,0 +1,295 @@ +Release notes for Agda version 2.4.2.4 +====================================== + +Installation and infrastructure +------------------------------- + +* Removed support for GHC 7.4.2. + +Pragmas and options +------------------- + +* Option `--copatterns` is now on by default. To switch off + parsing of copatterns, use: + + ```agda + {-# OPTIONS --no-copatterns #-} + ``` + +* Option `--rewriting` is now needed to use `REWRITE` pragmas and + rewriting during reduction. Rewriting is not `--safe`. + + To use rewriting, first specify a relation symbol `R` that will + later be used to add rewrite rules. A canonical candidate would be + propositional equality + + ```agda + {-# BUILTIN REWRITE _≡_ #-} + ``` + + but any symbol `R` of type `Δ → A → A → Set i` for some `A` and `i` + is accepted. Then symbols `q` can be added to rewriting provided + their type is of the form `Γ → R ds l r`. This will add a rewrite + rule + + ``` + Γ ⊢ l ↦ r : A[ds/Δ] + ``` + + to the signature, which fires whenever a term is an instance of `l`. + For example, if + + ```agda + plus0 : ∀ x → x + 0 ≡ x + ``` + + (ideally, there is a proof for `plus0`, but it could be a + postulate), then + + ```agda + {-# REWRITE plus0 #-} + ``` + + will prompt Agda to rewrite any well-typed term of the form `t + 0` + to `t`. + + Some caveats: Agda accepts and applies rewrite rules naively, it is + very easy to break consistency and termination of type checking. + Some examples of rewrite rules that should *not* be added: + + ```agda + refl : ∀ x → x ≡ x -- Agda loops + plus-sym : ∀ x y → x + y ≡ y + x -- Agda loops + absurd : true ≡ false -- Breaks consistency + ``` + + Adding only proven equations should at least preserve consistency, + but this is only a conjecture, so know what you are doing! Using + rewriting, you are entering into the wilderness, where you are on + your own! + +Language +-------- + +* `forall` / `∀` now parses like `λ`, i.e., the following parses now + [Issue [#1583](https://github.com/agda/agda/issues/1538)]: + + ```agda + ⊤ × ∀ (B : Set) → B → B + ``` + +* The underscore pattern `_` can now also stand for an inaccessible + pattern (dot pattern). This alleviates the need for writing `._`. + [Issue #[1605](https://github.com/agda/agda/issues/1605)] Instead of + + ```agda + transVOld : ∀{A : Set} (a b c : A) → a ≡ b → b ≡ c → a ≡ c + transVOld _ ._ ._ refl refl = refl + ``` + + one can now write + + ```agda + transVNew : ∀{A : Set} (a b c : A) → a ≡ b → b ≡ c → a ≡ c + transVNew _ _ _ refl refl = refl + ``` + + and let Agda decide where to put the dots. This was always possible + by using hidden arguments + + ```agda + transH : ∀{A : Set}{a b c : A} → a ≡ b → b ≡ c → a ≡ c + transH refl refl = refl + ``` + + which is now equivalent to + + ```agda + transHNew : ∀{A : Set}{a b c : A} → a ≡ b → b ≡ c → a ≡ c + transHNew {a = _}{b = _}{c = _} refl refl = refl + ``` + + Before, underscore `_` stood for an unnamed variable that could not + be instantiated by an inaccessible pattern. If one no wants to + prevent Agda from instantiating, one needs to use a variable name + other than underscore (however, in practice this situation seems + unlikely). + +Type checking +------------- + +* Polarity of phantom arguments to data and record types has + changed. [Issue [#1596](https://github.com/agda/agda/issues/1596)] + Polarity of size arguments is Nonvariant (both monotone and + antitone). Polarity of other arguments is Covariant (monotone). + Both were Invariant before (neither monotone nor antitone). + + The following example type-checks now: + + ```agda + open import Common.Size + + -- List should be monotone in both arguments + -- (even when `cons' is missing). + + data List (i : Size) (A : Set) : Set where + [] : List i A + + castLL : ∀{i A} → List i (List i A) → List ∞ (List ∞ A) + castLL x = x + + -- Stream should be antitone in the first and monotone in the second argument + -- (even with field `tail' missing). + + record Stream (i : Size) (A : Set) : Set where + coinductive + field + head : A + + castSS : ∀{i A} → Stream ∞ (Stream ∞ A) → Stream i (Stream i A) + castSS x = x + ``` + +* `SIZELT` lambdas must be consistent + [Issue [#1523](https://github.com/agda/agda/issues/1523), see Abel + and Pientka, ICFP 2013]. When lambda-abstracting over type (`Size< + size`) then `size` must be non-zero, for any valid instantiation of + size variables. + + - The good: + + ```agda + data Nat (i : Size) : Set where + zero : ∀ (j : Size< i) → Nat i + suc : ∀ (j : Size< i) → Nat j → Nat i + + {-# TERMINATING #-} + -- This definition is fine, the termination checker is too strict at the moment. + fix : ∀ {C : Size → Set} + → (∀ i → (∀ (j : Size< i) → Nat j -> C j) → Nat i → C i) + → ∀ i → Nat i → C i + fix t i (zero j) = t i (λ (k : Size< i) → fix t k) (zero j) + fix t i (suc j n) = t i (λ (k : Size< i) → fix t k) (suc j n) + ``` + + The `λ (k : Size< i)` is fine in both cases, as context + + ```agda + i : Size, j : Size< i + ``` + + guarantees that `i` is non-zero. + + - The bad: + + ```agda + record Stream {i : Size} (A : Set) : Set where + coinductive + constructor _∷ˢ_ + field + head : A + tail : ∀ {j : Size< i} → Stream {j} A + open Stream public + + _++ˢ_ : ∀ {i A} → List A → Stream {i} A → Stream {i} A + [] ++ˢ s = s + (a ∷ as) ++ˢ s = a ∷ˢ (as ++ˢ s) + ``` + + This fails, maybe unjustified, at + + ```agda + i : Size, s : Stream {i} A + ⊢ + a ∷ˢ (λ {j : Size< i} → as ++ˢ s) + ``` + + Fixed by defining the constructor by copattern matching: + + ```agda + record Stream {i : Size} (A : Set) : Set where + coinductive + field + head : A + tail : ∀ {j : Size< i} → Stream {j} A + open Stream public + + _∷ˢ_ : ∀ {i A} → A → Stream {i} A → Stream {↑ i} A + head (a ∷ˢ as) = a + tail (a ∷ˢ as) = as + + _++ˢ_ : ∀ {i A} → List A → Stream {i} A → Stream {i} A + [] ++ˢ s = s + (a ∷ as) ++ˢ s = a ∷ˢ (as ++ˢ s) + ``` + + - The ugly: + + ```agda + fix : ∀ {C : Size → Set} + → (∀ i → (∀ (j : Size< i) → C j) → C i) + → ∀ i → C i + fix t i = t i λ (j : Size< i) → fix t j + ``` + + For `i=0`, there is no such `j` at runtime, leading to looping + behavior. + +Interaction +----------- + +* Issue [#635](https://github.com/agda/agda/issues/635) has been + fixed. Case splitting does not spit out implicit record patterns + any more. + + ```agda + record Cont : Set₁ where + constructor _◃_ + field + Sh : Set + Pos : Sh → Set + + open Cont + + data W (C : Cont) : Set where + sup : (s : Sh C) (k : Pos C s → W C) → W C + + bogus : {C : Cont} → W C → Set + bogus w = {!w!} + ``` + + Case splitting on `w` yielded, since the fix of + Issue [#473](https://github.com/agda/agda/issues/473), + + ```agda + bogus {Sh ◃ Pos} (sup s k) = ? + ``` + + Now it gives, as expected, + + ```agda + bogus (sup s k) = ? + ``` + +Performance +----------- + +* As one result of the 21st Agda Implementor's Meeting (AIM XXI), + serialization of the standard library is 50% faster (time reduced by + a third), without using additional disk space for the interface + files. + + +Bug fixes +--------- + +Issues fixed (see [bug tracker](https://github.com/agda/agda/issues)): + +[#1546](https://github.com/agda/agda/issues/1546) (copattern matching +and with-clauses) + +[#1560](https://github.com/agda/agda/issues/1560) (positivity checker +inefficiency) + +[#1584](https://github.com/agda/agda/issues/1548) (let pattern with +trailing implicit) diff --git a/doc/release-notes/2.4.2.5.md b/doc/release-notes/2.4.2.5.md new file mode 100644 --- /dev/null +++ b/doc/release-notes/2.4.2.5.md @@ -0,0 +1,78 @@ +Release notes for Agda version 2.4.2.5 +====================================== + +Installation and infrastructure +------------------------------- + +* Added support for GHC 7.10.3. + +* Added `cpphs` Cabal flag + + Turn on/off this flag to choose cpphs/cpp as the C preprocessor. + + This flag is turn on by default. + + (This flag was added in Agda 2.4.2.1 but it was not documented) + +Pragmas and options +------------------- + +* Termination pragmas are no longer allowed inside `where` clauses + [Issue [#1137](https://github.com/agda/agda/issues/1137)]. + +Type checking +------------- + +* `with`-abstraction is more aggressive, abstracts also in types of + variables that are used in the `with`-expressions, unless they are + also used in the types of the + `with`-expressions. [Issue [#1692](https://github.com/agda/agda/issues/1692)] + + Example: + + ```agda + test : (f : (x : A) → a ≡ x) (b : A) → b ≡ a + test f b with a | f b + test f b | .b | refl = f b + ``` + + Previously, `with` would not abstract in types of variables that + appear in the `with`-expressions, in this case, both `f` and `b`, + leaving their types unchanged. Now, it tries to abstract in `f`, as + only `b` appears in the types of the `with`-expressions which are + `A` (of `a`) and `a ≡ b` (of `f b`). As a result, the type of `f` + changes to `(x : A) → b ≡ x` and the type of the goal to `b ≡ b` (as + previously). + + This also affects `rewrite`, which is implemented in terms of + `with`. + + ```agda + test : (f : (x : A) → a ≡ x) (b : A) → b ≡ a + test f b rewrite f b = f b + ``` + + As the new `with` is not fully backwards-compatible, some parts of + your Agda developments using `with` or `rewrite` might need + maintenance. + +Fixed issues +------------ + +See [bug tracker](https://github.com/agda/agda/issues) + +[#1407](https://github.com/agda/agda/issues/1497) + +[#1518](https://github.com/agda/agda/issues/1518) + +[#1670](https://github.com/agda/agda/issues/1670) + +[#1677](https://github.com/agda/agda/issues/1677) + +[#1698](https://github.com/agda/agda/issues/1698) + +[#1701](https://github.com/agda/agda/issues/1701) + +[#1710](https://github.com/agda/agda/issues/1710) + +[#1718](https://github.com/agda/agda/issues/1718) diff --git a/doc/release-notes/2.4.2.md b/doc/release-notes/2.4.2.md new file mode 100644 --- /dev/null +++ b/doc/release-notes/2.4.2.md @@ -0,0 +1,391 @@ +Release notes for Agda version 2.4.2 +==================================== + +Pragmas and options +------------------- + +* New option: `--with-K` + + This can be used to override a global `--without-K` in a file, by + adding a pragma `{-# OPTIONS --with-K #-}`. + +* New pragma `{-# NON_TERMINATING #-}` + + This is a safer version of `NO_TERMINATION_CHECK` which doesn't + treat the affected functions as terminating. This means that + `NON_TERMINATING` functions do not reduce during type checking. They + do reduce at run-time and when invoking `C-c C-n` at top-level (but + not in a hole). + +Language +-------- + +* Instance search is now more efficient and recursive (see + Issue [#938](https://github.com/agda/agda/issues/938)) (but without + termination check yet). + + A new keyword `instance` has been introduced (in the style of + `abstract` and `private`) which must now be used for every + definition/postulate that has to be taken into account during + instance resolution. For example: + + ```agda + record RawMonoid (A : Set) : Set where + field + nil : A + _++_ : A -> A -> A + + open RawMonoid {{...}} + + instance + rawMonoidList : {A : Set} -> RawMonoid (List A) + rawMonoidList = record { nil = []; _++_ = List._++_ } + + rawMonoidMaybe : {A : Set} {{m : RawMonoid A}} -> RawMonoid (Maybe A) + rawMonoidMaybe {A} = record { nil = nothing ; _++_ = catMaybe } + where + catMaybe : Maybe A -> Maybe A -> Maybe A + catMaybe nothing mb = mb + catMaybe ma nothing = ma + catMaybe (just a) (just b) = just (a ++ b) + ``` + + Moreover, each type of an instance must end in (something that reduces + to) a named type (e.g. a record, a datatype or a postulate). This + allows us to build a simple index structure + + ``` + data/record name --> possible instances + ``` + + that speeds up instance search. + + Instance search takes into account all local bindings and all global + `instance` bindings and the search is recursive. For instance, + searching for + + ```agda + ? : RawMonoid (Maybe (List A)) + ``` + + will consider the candidates {`rawMonoidList`, `rawMonoidMaybe`}, fail to + unify the first one, succeeding with the second one + + ```agda + ? = rawMonoidMaybe {A = List A} {{m = ?m}} : RawMonoid (Maybe (List A)) + ``` + + and continue with goal + + ```agda + ?m : RawMonoid (List A) + ``` + + This will then find + + ```agda + ?m = rawMonoidList {A = A} + ``` + + and putting together we have the solution. + + Be careful that there is no termination check for now, you can + easily make Agda loop by declaring the identity function as an + instance. But it shouldn’t be possible to make Agda loop by only + declaring structurally recursive instances (whatever that means). + + Additionally: + + - Uniqueness of instances is up to definitional equality (see + Issue [#899](https://github.com/agda/agda/issues/899)). + + - Instances of the following form are allowed: + + ```agda + EqSigma : {A : Set} {B : A → Set} {{EqA : Eq A}} + {{EqB : {a : A} → Eq (B a)}} + → Eq (Σ A B) + ``` + + When searching recursively for an instance of type `{a : A} → Eq + (B a)`, a lambda will automatically be introduced and instance + search will search for something of type `Eq (B a)` in the context + extended by `a : A`. When searching for an instance, the `a` + argument does not have to be implicit, but in the definition of + `EqSigma`, instance search will only be able to use `EqB` if `a` + is implicit. + + - There is no longer any attempt to solve irrelevant metas by instance + search. + + - Constructors of records and datatypes are automatically added to the + instance table. + +* You can now use `quote` in patterns. + + For instance, here is a function that unquotes a (closed) natural + number term. + + ```agda + unquoteNat : Term → Maybe Nat + unquoteNat (con (quote Nat.zero) []) = just zero + unquoteNat (con (quote Nat.suc) (arg _ n ∷ [])) = fmap suc (unquoteNat n) + unquoteNat _ = nothing + ``` + +* The builtin constructors `AGDATERMUNSUPPORTED` and + `AGDASORTUNSUPPORTED` are now translated to meta variables when + unquoting. + +* New syntactic sugar `tactic e` and `tactic e | e1 | .. | en`. + + It desugars as follows and makes it less unwieldy to call + reflection-based tactics. + + ```agda + tactic e --> quoteGoal g in unquote (e g) + tactic e | e1 | .. | en --> quoteGoal g in unquote (e g) e1 .. en + ``` + + Note that in the second form the tactic function should generate a + function from a number of new subgoals to the original goal. The + type of `e` should be `Term -> Term` in both cases. + +* New reflection builtins for literals. + + The term data type `AGDATERM` now needs an additional constructor + `AGDATERMLIT` taking a reflected literal defined as follows (with + appropriate builtin bindings for the types `Nat`, `Float`, etc). + + ```agda + data Literal : Set where + nat : Nat → Literal + float : Float → Literal + char : Char → Literal + string : String → Literal + qname : QName → Literal + + {-# BUILTIN AGDALITERAL Literal #-} + {-# BUILTIN AGDALITNAT nat #-} + {-# BUILTIN AGDALITFLOAT float #-} + {-# BUILTIN AGDALITCHAR char #-} + {-# BUILTIN AGDALITSTRING string #-} + {-# BUILTIN AGDALITQNAME qname #-} + ``` + + When quoting (`quoteGoal` or `quoteTerm`) literals will be mapped to + the `AGDATERMLIT` constructor. Previously natural number literals + were quoted to `suc`/`zero` application and other literals were + quoted to `AGDATERMUNSUPPORTED`. + +* New reflection builtins for function definitions. + + `AGDAFUNDEF` should now map to a data type defined as follows + + (with + ```agda + {-# BUILTIN QNAME QName #-} + {-# BUILTIN ARG Arg #-} + {-# BUILTIN AGDATERM Term #-} + {-# BUILTIN AGDATYPE Type #-} + {-# BUILTIN AGDALITERAL Literal #-} + ``` + ). + + ```agda + data Pattern : Set where + con : QName → List (Arg Pattern) → Pattern + dot : Pattern + var : Pattern + lit : Literal → Pattern + proj : QName → Pattern + absurd : Pattern + + {-# BUILTIN AGDAPATTERN Pattern #-} + {-# BUILTIN AGDAPATCON con #-} + {-# BUILTIN AGDAPATDOT dot #-} + {-# BUILTIN AGDAPATVAR var #-} + {-# BUILTIN AGDAPATLIT lit #-} + {-# BUILTIN AGDAPATPROJ proj #-} + {-# BUILTIN AGDAPATABSURD absurd #-} + + data Clause : Set where + clause : List (Arg Pattern) → Term → Clause + absurd-clause : List (Arg Pattern) → Clause + + {-# BUILTIN AGDACLAUSE Clause #-} + {-# BUILTIN AGDACLAUSECLAUSE clause #-} + {-# BUILTIN AGDACLAUSEABSURD absurd-clause #-} + + data FunDef : Set where + fun-def : Type → List Clause → FunDef + + {-# BUILTIN AGDAFUNDEF FunDef #-} + {-# BUILTIN AGDAFUNDEFCON fun-def #-} + ``` + +* New reflection builtins for extended (pattern-matching) lambda. + + The `AGDATERM` data type has been augmented with a constructor + + ```agda + AGDATERMEXTLAM : List AGDACLAUSE → List (ARG AGDATERM) → AGDATERM + ``` + + Absurd lambdas (`λ ()`) are quoted to extended lambdas with an + absurd clause. + +* Unquoting declarations. + + You can now define (recursive) functions by reflection using the new + `unquoteDecl` declaration + + ```agda + unquoteDecl x = e + ``` + + Here e should have type `AGDAFUNDEF` and evaluate to a closed + value. This value is then spliced in as the definition of `x`. In + the body `e`, `x` has type `QNAME` which lets you splice in + recursive definitions. + + Standard modifiers, such as fixity declarations, can be applied to `x` as + expected. + +* Quoted levels + + Universe levels are now quoted properly instead of being quoted to + `AGDASORTUNSUPPORTED`. `Setω` still gets an unsupported sort, + however. + +* Module applicants can now be operator applications. + + Example: + + ```agda + postulate + [_] : A -> B + + module M (b : B) where + + module N (a : A) = M [ a ] + ``` + + [See Issue [#1245](https://github.com/agda/agda/issues/1245)] + +* Minor change in module application + semantics. [Issue [#892](https://github.com/agda/agda/issues/892)] + + Previously re-exported functions were not redefined when + instantiating a module. For instance + + ```agda + module A where f = ... + module B (X : Set) where + open A public + module C = B Nat + ``` + + In this example `C.f` would be an alias for `A.f`, so if both `A` + and `C` were opened `f` would not be ambiguous. However, this + behaviour is not correct when `A` and `B` share some module + parameters + (Issue [#892](https://github.com/agda/agda/issues/892)). To fix this + `C` now defines its own copy of `f` (which evaluates to `A.f`), + which means that opening `A` and `C` results in an ambiguous `f`. + +Type checking +------------- + +* Recursive records need to be declared as either `inductive` or + `coinductive`. `inductive` is no longer default for recursive + records. Examples: + + ```agda + record _×_ (A B : Set) : Set where + constructor _,_ + field + fst : A + snd : B + + record Tree (A : Set) : Set where + inductive + constructor tree + field + elem : A + subtrees : List (Tree A) + + record Stream (A : Set) : Set where + coinductive + constructor _::_ + field + head : A + tail : Stream A + ``` + + If you are using old-style (musical) coinduction, a record may have + to be declared as inductive, paradoxically. + + ```agda + record Stream (A : Set) : Set where + inductive -- YES, THIS IS INTENDED ! + constructor _∷_ + field + head : A + tail : ∞ (Stream A) + ``` + + This is because the "coinduction" happens in the use of `∞` and not + in the use of `record`. + +Tools +----- + +### Emacs mode + +* A new menu option `Display` can be used to display the version of + the running Agda process. + +### LaTeX-backend + +* New experimental option `references` has been added. When specified, + i.e.: + + ```latex + \usepackage[references]{agda} + ``` + + a new command called `\AgdaRef` is provided, which lets you + reference previously typeset commands, e.g.: + + Let us postulate `\AgdaRef{apa}`. + + ```agda + \begin{code} + postulate + apa : Set + \end{code} + ``` + + Above `apa` will be typeset (highlighted) the same in the text as in + the code, provided that the LaTeX output is post-processed using + `src/data/postprocess-latex.pl`, e.g.: + + ``` + cp $(dirname $(dirname $(agda-mode locate)))/postprocess-latex.pl . + agda -i. --latex Example.lagda + cd latex/ + perl ../postprocess-latex.pl Example.tex > Example.processed + mv Example.processed Example.tex + xelatex Example.tex + ``` + + Mix-fix and Unicode should work as expected (Unicode requires + XeLaTeX/LuaLaTeX), but there are limitations: + + - Overloading identifiers should be avoided, if multiples exist + `\AgdaRef` will typeset according to the first it finds. + + - Only the current module is used, should you need to reference + identifiers in other modules then you need to specify which other + module manually, i.e. `\AgdaRef[module]{identifier}`. diff --git a/doc/release-notes/2.5.1.1.md b/doc/release-notes/2.5.1.1.md new file mode 100644 --- /dev/null +++ b/doc/release-notes/2.5.1.1.md @@ -0,0 +1,79 @@ +Release notes for Agda version 2.5.1.1 +====================================== + +Installation and infrastructure +------------------------------- + +* Added support for GHC 8.0.1. + +* Documentation is now built with Python >=3.3, as done by + [readthedocs.org](https://readthedocs.org/). + +Bug fixes +--------- + +* Fixed a serious performance problem with instance search + + Issues [#1952](https://github.com/agda/agda/issues/1952) and + [#1998](https://github.com/agda/agda/issues/1998). Also related: + [#1955](https://github.com/agda/agda/issues/1955) and + [#2025](https://github.com/agda/agda/issues/2025) + +* Interactively splitting variable with `C-c C-c` no longer introduces + new trailing patterns. This fixes + Issue [#1950](https://github.com/agda/agda/issues/1950). + + ```agda + data Ty : Set where + _⇒_ : Ty → Ty → Ty + + ⟦_⟧ : Ty → Set + ⟦ A ⇒ B ⟧ = ⟦ A ⟧ → ⟦ B ⟧ + + data Term : Ty → Set where + K : (A B : Ty) → Term (A ⇒ (B ⇒ A)) + + test : (A : Ty) (a : Term A) → ⟦ A ⟧ + test A a = {!a!} + ``` + + Before change, case splitting on `a` would give + + ```agda + test .(A ⇒ (B ⇒ A)) (K A B) x x₁ = ? + ``` + + Now, it yields + + ```agda + test .(A ⇒ (B ⇒ A)) (K A B) = ? + ``` + +* In literate TeX files, `\begin{code}` and `\end{code}` can be + preceded (resp. followed) by TeX code on the same line. This fixes + Issue [#2077](https://github.com/agda/agda/issues/2077). + +* Other issues fixed (see + [bug tracker](https://github.com/agda/agda/issues)): + + [#1951](https://github.com/agda/agda/issues/1951) (mixfix binders + not working in 'syntax') + + [#1967](https://github.com/agda/agda/issues/1967) (too eager + insteance search error) + + [#1974](https://github.com/agda/agda/issues/1974) (lost constraint + dependencies) + + [#1982](https://github.com/agda/agda/issues/1982) (internal error in + unifier) + + [#2034](https://github.com/agda/agda/issues/2034) (function type + instance goals) + +Compiler backends +----------------- + +* UHC compiler backend + + Added support for UHC 1.1.9.4. diff --git a/doc/release-notes/2.5.1.2.md b/doc/release-notes/2.5.1.2.md new file mode 100644 --- /dev/null +++ b/doc/release-notes/2.5.1.2.md @@ -0,0 +1,5 @@ +Release notes for Agda version 2.5.1.2 +====================================== + +* Fixed broken type signatures that were incorrectly accepted due to + [GHC #12784](https://ghc.haskell.org/trac/ghc/ticket/12784). diff --git a/doc/release-notes/2.5.1.md b/doc/release-notes/2.5.1.md new file mode 100644 --- /dev/null +++ b/doc/release-notes/2.5.1.md @@ -0,0 +1,1600 @@ +Release notes for Agda version 2.5.1 +==================================== + +Documentation +------------- + +* There is now an official Agda User Manual: + https://agda.readthedocs.io/ + +Installation and infrastructure +------------------------------- + +* Builtins and primitives are now defined in a new set of modules available to + all users, independent of any particular library. The modules are + + ```agda + Agda.Builtin.Bool + Agda.Builtin.Char + Agda.Builtin.Coinduction + Agda.Builtin.Equality + Agda.Builtin.Float + Agda.Builtin.FromNat + Agda.Builtin.FromNeg + Agda.Builtin.FromString + Agda.Builtin.IO + Agda.Builtin.Int + Agda.Builtin.List + Agda.Builtin.Nat + Agda.Builtin.Reflection + Agda.Builtin.Size + Agda.Builtin.Strict + Agda.Builtin.String + Agda.Builtin.TrustMe + Agda.Builtin.Unit + ``` + + The standard library reexports the primitives from the new modules. + + The `Agda.Builtin` modules are installed in the same way as + `Agda.Primitive`, but unlike `Agda.Primitive` they are not loaded + automatically. + +Pragmas and options +------------------- + +* Library management + + There is a new 'library' concept for managing include paths. A library + consists of + - a name, + - a set of libraries it depends on, and + - a set of include paths. + + A library is defined in a `.agda-lib` file using the following + format: + + ``` + name: LIBRARY-NAME -- Comment + depend: LIB1 LIB2 + LIB3 + LIB4 + include: PATH1 + PATH2 + PATH3 + ``` + + Dependencies are library names, not paths to `.agda-lib` files, and + include paths are relative to the location of the library-file. + + To be useable, a library file has to be listed (with its full path) + in `AGDA_DIR/libraries` (or `AGDA_DIR/libraries-VERSION`, for a + given Agda version). `AGDA_DIR` defaults to `~/.agda` on Unix-like + systems and `C:/Users/USERNAME/AppData/Roaming/agda` or similar on + Windows, and can be overridden by setting the `AGDA_DIR` environment + variable. + + Environment variables in the paths (of the form `$VAR` or `${VAR}`) + are expanded. The location of the libraries file used can be + overridden using the `--library-file=FILE` flag, although this is + not expected to be very useful. + + You can find out the precise location of the 'libraries' file by + calling `agda -l fjdsk Dummy.agda` and looking at the error message + (assuming you don't have a library called fjdsk installed). + + There are three ways a library gets used: + + - You supply the `--library=LIB` (or `-l LIB`) option to + Agda. This is equivalent to adding a `-iPATH` for each of the + include paths of `LIB` and its (transitive) dependencies. + + - No explicit `--library` flag is given, and the current project + root (of the Agda file that is being loaded) or one of its + parent directories contains a `.agda-lib` file defining a + library `LIB`. This library is used as if a `--librarary=LIB` + option had been given, except that it is not necessary for the + library to be listed in the `AGDA_DIR/libraries` file. + + - No explicit `--library` flag, and no `.agda-lib` file in the + project root. In this case the file `AGDA_DIR/defaults` is read + and all libraries listed are added to the path. The defaults + file should contain a list of library names, each on a separate + line. In this case the current directory is also added to the + path. + + To disable default libraries, you can give the flag + `--no-default-libraries`. + + Library names can end with a version number (for instance, + `mylib-1.2.3`). When resolving a library name (given in a `--library` + flag, or listed as a default library or library dependency) the + following rules are followed: + + - If you don't give a version number, any version will do. + + - If you give a version number an exact match is required. + + - When there are multiple matches an exact match is preferred, and + otherwise the latest matching version is chosen. + + For example, suppose you have the following libraries installed: + `mylib`, `mylib-1.0`, `otherlib-2.1`, and `otherlib-2.3`. In this + case, aside from the exact matches you can also say + `--library=otherlib` to get `otherlib-2.3`. + +* New Pragma `COMPILED_DECLARE_DATA` for binding recursively defined + Haskell data types to recursively defined Agda data types. + + If you have a Haskell type like + + ```haskell + {-# LANGUAGE GADTs #-} + + module Issue223 where + + data A where + BA :: B -> A + + data B where + AB :: A -> B + BB :: B + ``` + + You can now bind it to corresponding mutual Agda inductive data + types as follows: + + ```agda + {-# IMPORT Issue223 #-} + + data A : Set + {-# COMPILED_DECLARE_DATA A Issue223.A #-} + data B : Set + {-# COMPILED_DECLARE_DATA B Issue223.B #-} + + data A where + BA : B → A + + {-# COMPILED_DATA A Issue223.A Issue223.BA #-} + data B where + AB : A → B + BB : B + + {-# COMPILED_DATA B Issue223.B Issue223.AB Issue223.BB #-} + ``` + + This fixes Issue [#223](https://github.com/agda/agda/issues/223). + +* New pragma `HASKELL` for adding inline Haskell code (GHC backend only) + + Arbitrary Haskell code can be added to a module using the `HASKELL` + pragma. For instance, + + ```agda + {-# HASKELL + echo :: IO () + echo = getLine >>= putStrLn + #-} + + postulate echo : IO ⊤ + {-# COMPILED echo echo #-} + ``` + +* New option `--exact-split`. + + The `--exact-split` flag causes Agda to raise an error whenever a + clause in a definition by pattern matching cannot be made to hold + definitionally (i.e. as a reduction rule). Specific clauses can be + excluded from this check by means of the `{-# CATCHALL #-}` pragma. + + For instance, the following definition will be rejected as the second clause + cannot be made to hold definitionally: + + ```agda + min : Nat → Nat → Nat + min zero y = zero + min x zero = zero + min (suc x) (suc y) = suc (min x y + ``` + + Catchall clauses have to be marked as such, for instance: + + ```agda + eq : Nat → Nat → Bool + eq zero zero = true + eq (suc m) (suc n) = eq m n + {-# CATCHALL #-} + eq _ _ = false + ``` + +* New option: `--no-exact-split`. + + This option can be used to override a global `--exact-split` in a + file, by adding a pragma `{-# OPTIONS --no-exact-split #-}`. + +* New options: `--sharing` and `--no-sharing`. + + These options are used to enable/disable sharing and call-by-need + evaluation. The default is `--no-sharing`. + + Note that they cannot appear in an `OPTIONS` pragma, but have to be + given as command line arguments or added to the Agda Program Args + from Emacs with `M-x customize-group agda2`. + +* New pragma `DISPLAY`. + + ```agda + {-# DISPLAY f e1 .. en = e #-} + ``` + + This causes `f e1 .. en` to be printed in the same way as `e`, where + `ei` can bind variables used in `e`. The expressions `ei` and `e` + are scope checked, but not type checked. + + For example this can be used to print overloaded (instance) functions with + the overloaded name: + + ```agda + instance + NumNat : Num Nat + NumNat = record { ..; _+_ = natPlus } + + {-# DISPLAY natPlus a b = a + b #-} + ``` + + Limitations + + - Left-hand sides are restricted to variables, constructors, defined + functions or types, and literals. In particular, lambdas are not + allowed in left-hand sides. + + - Since `DISPLAY` pragmas are not type checked implicit argument + insertion may not work properly if the type of `f` computes to an + implicit function space after pattern matching. + +* Removed pragma `{-# ETA R #-}` + + The pragma `{-# ETA R #-}` is replaced by the `eta-equality` directive + inside record declarations. + +* New option `--no-eta-equality`. + + The `--no-eta-equality` flag disables eta rules for declared record + types. It has the same effect as `no-eta-equality` inside each + declaration of a record type `R`. + + If used with the `OPTIONS` pragma it will not affect records defined + in other modules. + +* The semantics of `{-# REWRITE r #-}` pragmas in parametrized modules + has changed (see + Issue [#1652](https://github.com/agda/agda/issues/1652)). + + Rewrite rules are no longer lifted to the top context. Instead, they + now only apply to terms in (extensions of) the module context. If + you want the old behaviour, you should put the `{-# REWRITE r #-}` + pragma outside of the module (i.e. unindent it). + +* New pragma `{-# INLINE f #-}` causes `f` to be inlined during + compilation. + +* The `STATIC` pragma is now taken into account during compilation. + + Calls to a function marked `STATIC` are normalised before + compilation. The typical use case for this is to mark the + interpreter of an embedded language as `STATIC`. + +* Option `--type-in-type` no longer implies + `--no-universe-polymorphism`, thus, it can be used with explicit + universe + levels. [Issue [#1764](https://github.com/agda/agda/issues/1764)] It + simply turns off error reporting for any level mismatch now. + Examples: + + ```agda + {-# OPTIONS --type-in-type #-} + + Type : Set + Type = Set + + data D {α} (A : Set α) : Set where + d : A → D A + + data E α β : Set β where + e : Set α → E α β + ``` + +* New `NO_POSITIVITY_CHECK` pragma to switch off the positivity checker + for data/record definitions and mutual blocks. + + The pragma must precede a data/record definition or a mutual block. + + The pragma cannot be used in `--safe` mode. + + Examples (see `Issue1614*.agda` and `Issue1760*.agda` in + `test/Succeed/`): + + 1. Skipping a single data definition. + + ```agda + {-# NO_POSITIVITY_CHECK #-} + data D : Set where + lam : (D → D) → D + ``` + + 2. Skipping a single record definition. + + ```agda + {-# NO_POSITIVITY_CHECK #-} + record U : Set where + field ap : U → U + ``` + + 3. Skipping an old-style mutual block: Somewhere within a `mutual` + block before a data/record definition. + + ```agda + mutual + data D : Set where + lam : (D → D) → D + + {-# NO_POSITIVITY_CHECK #-} + record U : Set where + field ap : U → U + ``` + + 4. Skipping an old-style mutual block: Before the `mutual` keyword. + + ```agda + {-# NO_POSITIVITY_CHECK #-} + mutual + data D : Set where + lam : (D → D) → D + + record U : Set where + field ap : U → U + ``` + + 5. Skipping a new-style mutual block: Anywhere before the + declaration or the definition of data/record in the block. + + ```agda + record U : Set + data D : Set + + record U where + field ap : U → U + + {-# NO_POSITIVITY_CHECK #-} + data D where + lam : (D → D) → D + ``` + +* Removed `--no-coverage-check` + option. [Issue [#1918](https://github.com/agda/agda/issues/1918)] + +Language +-------- + +### Operator syntax + +* The default fixity for syntax declarations has changed from -666 to 20. + +* Sections. + + Operators can be sectioned by replacing arguments with underscores. + There must not be any whitespace between these underscores and the + adjacent nameparts. Examples: + + ```agda + pred : ℕ → ℕ + pred = _∸ 1 + + T : Bool → Set + T = if_then ⊤ else ⊥ + + if : {A : Set} (b : Bool) → A → A → A + if b = if b then_else_ + ``` + + Sections are translated into lambda expressions. Examples: + + ```agda + _∸ 1 ↦ λ section → section ∸ 1 + + if_then ⊤ else ⊥ ↦ λ section → if section then ⊤ else ⊥ + + if b then_else_ ↦ λ section section₁ → + if b then section else section₁ + ``` + + Operator sections have the same fixity as the underlying operator + (except in cases like `if b then_else_`, in which the section is + "closed", but the operator is not). + + Operator sections are not supported in patterns (with the exception + of dot patterns), and notations coming from syntax declarations + cannot be sectioned. + +* A long-standing operator fixity bug has been fixed. As a consequence + some programs that used to parse no longer do. + + Previously each precedence level was (incorrectly) split up into + five separate ones, ordered as follows, with the earlier ones + binding less tightly than the later ones: + + - Non-associative operators. + + - Left associative operators. + + - Right associative operators. + + - Prefix operators. + + - Postfix operators. + + Now this problem has been addressed. It is no longer possible to mix + operators of a given precedence level but different associativity. + However, prefix and right associative operators are seen as having + the same associativity, and similarly for postfix and left + associative operators. + + Examples + -------- + + The following code is no longer accepted: + + ```agda + infixl 6 _+_ + infix 6 _∸_ + + rejected : ℕ + rejected = 1 + 0 ∸ 1 + ``` + + However, the following previously rejected code is accepted: + + ```agda + infixr 4 _,_ + infix 4 ,_ + + ,_ : {A : Set} {B : A → Set} {x : A} → B x → Σ A B + , y = _ , y + + accepted : Σ ℕ λ i → Σ ℕ λ j → Σ (i ≡ j) λ _ → Σ ℕ λ k → j ≡ k + accepted = 5 , , refl , , refl + ``` + +* The classification of notations with binders into the categories + infix, prefix, postfix or closed has + changed. [Issue [#1450](https://github.com/agda/agda/issues/1450)] + + The difference is that, when classifying the notation, only + *regular* holes are taken into account, not *binding* ones. + + Example: The notation + + ```agda + syntax m >>= (λ x → f) = x <- m , f + ``` + + was previously treated as infix, but is now treated as prefix. + +* Notation can now include wildcard binders. + + Example: `syntax Σ A (λ _ → B) = A × B` + +* If an overloaded operator is in scope with several distinct + precedence levels, then several instances of this operator will be + included in the operator grammar, possibly leading to ambiguity. + Previously the operator was given the default fixity + [Issue [#1436](https://github.com/agda/agda/issues/1436)]. + + There is an exception to this rule: If there are multiple precedences, + but at most one is explicitly declared, then only one instance will be + included in the grammar. If there are no explicitly declared + precedences, then this instance will get the default precedence, and + otherwise it will get the declared precedence. + + If multiple occurrences of an operator are "merged" in the grammar, + and they have distinct associativities, then they are treated as + being non-associative. + + The three paragraphs above also apply to identical notations (coming + from syntax declarations) for a given overloaded name. + + Examples: + + ```agda + module A where + + infixr 5 _∷_ + infixr 5 _∙_ + infixl 3 _+_ + infix 1 bind + + syntax bind c (λ x → d) = x ← c , d + + module B where + + infix 5 _∷_ + infixr 4 _∙_ + -- No fixity declaration for _+_. + infixl 2 bind + + syntax bind c d = c ∙ d + + module C where + + infixr 2 bind + + syntax bind c d = c ∙ d + + open A + open B + open C + + -- _∷_ is infix 5. + -- _∙_ has two fixities: infixr 4 and infixr 5. + -- _+_ is infixl 3. + -- A.bind's notation is infix 1. + -- B.bind and C.bind's notations are infix 2. + + -- There is one instance of "_ ∷ _" in the grammar, and one + -- instance of "_ + _". + + -- There are three instances of "_ ∙ _" in the grammar, one + -- corresponding to A._∙_, one corresponding to B._∙_, and one + -- corresponding to both B.bind and C.bind. + ``` + +### Reflection + +* The reflection framework has received a massive overhaul. + + A new type of reflected type checking computations supplants most of + the old reflection primitives. The `quoteGoal`, `quoteContext` and + tactic primitives are deprecated and will be removed in the future, + and the `unquoteDecl` and `unquote` primitives have changed + behaviour. Furthermore the following primitive functions have been + replaced by builtin type checking computations: + + ```agda + - primQNameType --> AGDATCMGETTYPE + - primQNameDefinition --> AGDATCMGETDEFINITION + - primDataConstructors --> subsumed by AGDATCMGETDEFINITION + - primDataNumberOfParameters --> subsumed by AGDATCMGETDEFINITION + ``` + + See below for details. + +* Types are no longer packaged with a sort. + + The `AGDATYPE` and `AGDATYPEEL` built-ins have been + removed. Reflected types are now simply terms. + +* Reflected definitions have more information. + + The type for reflected definitions has changed to + + ```agda + data Definition : Set where + fun-def : List Clause → Definition + data-type : Nat → List Name → Definition -- parameters and constructors + record-type : Name → Definition -- name of the data/record type + data-con : Name → Definition -- name of the constructor + axiom : Definition + prim-fun : Definition + ``` + + Correspondingly the built-ins for function, data and record + definitions (`AGDAFUNDEF`, `AGDAFUNDEFCON`, `AGDADATADEF`, + `AGDARECORDDEF`) have been removed. + +* Reflected type checking computations. + + There is a primitive `TC` monad representing type checking + computations. The `unquote`, `unquoteDecl`, and the new `unquoteDef` + all expect computations in this monad (see below). The interface to + the monad is the following + + ```agda + -- Error messages can contain embedded names and terms. + data ErrorPart : Set where + strErr : String → ErrorPart + termErr : Term → ErrorPart + nameErr : Name → ErrorPart + + {-# BUILTIN AGDAERRORPART ErrorPart #-} + {-# BUILTIN AGDAERRORPARTSTRING strErr #-} + {-# BUILTIN AGDAERRORPARTTERM termErr #-} + {-# BUILTIN AGDAERRORPARTNAME nameErr #-} + + postulate + TC : ∀ {a} → Set a → Set a + returnTC : ∀ {a} {A : Set a} → A → TC A + bindTC : ∀ {a b} {A : Set a} {B : Set b} → TC A → (A → TC B) → TC B + + -- Unify two terms, potentially solving metavariables in the process. + unify : Term → Term → TC ⊤ + + -- Throw a type error. Can be caught by catchTC. + typeError : ∀ {a} {A : Set a} → List ErrorPart → TC A + + -- Block a type checking computation on a metavariable. This will abort + -- the computation and restart it (from the beginning) when the + -- metavariable is solved. + blockOnMeta : ∀ {a} {A : Set a} → Meta → TC A + + -- Backtrack and try the second argument if the first argument throws a + -- type error. + catchTC : ∀ {a} {A : Set a} → TC A → TC A → TC A + + -- Infer the type of a given term + inferType : Term → TC Type + + -- Check a term against a given type. This may resolve implicit arguments + -- in the term, so a new refined term is returned. Can be used to create + -- new metavariables: newMeta t = checkType unknown t + checkType : Term → Type → TC Term + + -- Compute the normal form of a term. + normalise : Term → TC Term + + -- Get the current context. + getContext : TC (List (Arg Type)) + + -- Extend the current context with a variable of the given type. + extendContext : ∀ {a} {A : Set a} → Arg Type → TC A → TC A + + -- Set the current context. + inContext : ∀ {a} {A : Set a} → List (Arg Type) → TC A → TC A + + -- Quote a value, returning the corresponding Term. + quoteTC : ∀ {a} {A : Set a} → A → TC Term + + -- Unquote a Term, returning the corresponding value. + unquoteTC : ∀ {a} {A : Set a} → Term → TC A + + -- Create a fresh name. + freshName : String → TC QName + + -- Declare a new function of the given type. The function must be defined + -- later using 'defineFun'. Takes an Arg Name to allow declaring instances + -- and irrelevant functions. The Visibility of the Arg must not be hidden. + declareDef : Arg QName → Type → TC ⊤ + + -- Define a declared function. The function may have been declared using + -- 'declareDef' or with an explicit type signature in the program. + defineFun : QName → List Clause → TC ⊤ + + -- Get the type of a defined name. Replaces 'primQNameType'. + getType : QName → TC Type + + -- Get the definition of a defined name. Replaces 'primQNameDefinition'. + getDefinition : QName → TC Definition + + {-# BUILTIN AGDATCM TC #-} + {-# BUILTIN AGDATCMRETURN returnTC #-} + {-# BUILTIN AGDATCMBIND bindTC #-} + {-# BUILTIN AGDATCMUNIFY unify #-} + {-# BUILTIN AGDATCMNEWMETA newMeta #-} + {-# BUILTIN AGDATCMTYPEERROR typeError #-} + {-# BUILTIN AGDATCMBLOCKONMETA blockOnMeta #-} + {-# BUILTIN AGDATCMCATCHERROR catchTC #-} + {-# BUILTIN AGDATCMINFERTYPE inferType #-} + {-# BUILTIN AGDATCMCHECKTYPE checkType #-} + {-# BUILTIN AGDATCMNORMALISE normalise #-} + {-# BUILTIN AGDATCMGETCONTEXT getContext #-} + {-# BUILTIN AGDATCMEXTENDCONTEXT extendContext #-} + {-# BUILTIN AGDATCMINCONTEXT inContext #-} + {-# BUILTIN AGDATCMQUOTETERM quoteTC #-} + {-# BUILTIN AGDATCMUNQUOTETERM unquoteTC #-} + {-# BUILTIN AGDATCMFRESHNAME freshName #-} + {-# BUILTIN AGDATCMDECLAREDEF declareDef #-} + {-# BUILTIN AGDATCMDEFINEFUN defineFun #-} + {-# BUILTIN AGDATCMGETTYPE getType #-} + {-# BUILTIN AGDATCMGETDEFINITION getDefinition #-} + ``` + +* Builtin type for metavariables + + There is a new builtin type for metavariables used by the new reflection + framework. It is declared as follows and comes with primitive equality, + ordering and show. + + ```agda + postulate Meta : Set + {-# BUILTIN AGDAMETA Meta #-} + primitive primMetaEquality : Meta → Meta → Bool + primitive primMetaLess : Meta → Meta → Bool + primitive primShowMeta : Meta → String + ``` + + There are corresponding new constructors in the `Term` and `Literal` + data types: + + ```agda + data Term : Set where + ... + meta : Meta → List (Arg Term) → Term + + {-# BUILTIN AGDATERMMETA meta #-} + + data Literal : Set where + ... + meta : Meta → Literal + + {-# BUILTIN AGDALITMETA meta #-} + ``` + +* Builtin unit type + + The type checker needs to know about the unit type, which you can + allow by + + ```agda + record ⊤ : Set where + {-# BUILTIN UNIT ⊤ #-} + ``` + +* Changed behaviour of `unquote` + + The `unquote` primitive now expects a type checking computation + instead of a pure term. In particular `unquote e` requires + + ```agda + e : Term → TC ⊤ + ``` + + where the argument is the representation of the hole in which the + result should go. The old `unquote` behaviour (where `unquote` + expected a `Term` argument) can be recovered by + + ```agda + OLD: unquote v + NEW: unquote λ hole → unify hole v + ``` + +* Changed behaviour of `unquoteDecl` + + The `unquoteDecl` primitive now expects a type checking computation + instead of a pure function definition. It is possible to define + multiple (mutually recursive) functions at the same time. More + specifically + + ```agda + unquoteDecl x₁ .. xₙ = m + ``` + + requires `m : TC ⊤` and that `x₁ .. xₙ` are defined (using + `declareDef` and `defineFun`) after executing `m`. As before `x₁ + .. xₙ : QName` in `m`, but have their declared types outside the + `unquoteDecl`. + +* New primitive `unquoteDef` + + There is a new declaration + + ```agda + unquoteDef x₁ .. xₙ = m + ``` + + This works exactly as `unquoteDecl` (see above) with the exception + that `x₁ .. xₙ` are required to already be declared. + + The main advantage of `unquoteDef` over `unquoteDecl` is that + `unquoteDef` is allowed in mutual blocks, allowing mutually + recursion between generated definitions and hand-written + definitions. + +* The reflection interface now exposes the name hint (as a string) + for variables. As before, the actual binding structure is with + de Bruijn indices. The String value is just a hint used as a prefix + to help display the variable. The type `Abs` is a new builtin type used + for the constructors `Term.lam`, `Term.pi`, `Pattern.var` + (bultins `AGDATERMLAM`, `AGDATERMPI` and `AGDAPATVAR`). + + ```agda + data Abs (A : Set) : Set where + abs : (s : String) (x : A) → Abs A + {-# BUILTIN ABS Abs #-} + {-# BUILTIN ABSABS abs #-} + ``` + + Updated constructor types: + + ```agda + Term.lam : Hiding → Abs Term → Term + Term.pi : Arg Type → Abs Type → Term + Pattern.var : String → Pattern + ``` + +* Reflection-based macros + + Macros are functions of type `t1 → t2 → .. → Term → TC ⊤` that are + defined in a `macro` block. Macro application is guided by the type + of the macro, where `Term` arguments desugar into the `quoteTerm` + syntax and `Name` arguments into the `quote` syntax. Arguments of + any other type are preserved as-is. The last `Term` argument is the + hole term given to `unquote` computation (see above). + + For example, the macro application `f u v w` where the macro `f` has + the type `Term → Name → Bool → Term → TC ⊤` desugars into `unquote + (f (quoteTerm u) (quote v) w)` + + Limitations: + + - Macros cannot be recursive. This can be worked around by defining the + recursive function outside the macro block and have the macro call the + recursive function. + + Silly example: + + ```agda + macro + plus-to-times : Term → Term → TC ⊤ + plus-to-times (def (quote _+_) (a ∷ b ∷ [])) hole = unify hole (def (quote _*_) (a ∷ b ∷ [])) + plus-to-times v hole = unify hole v + + thm : (a b : Nat) → plus-to-times (a + b) ≡ a * b + thm a b = refl + ``` + + Macros are most useful when writing tactics, since they let you hide the + reflection machinery. For instance, suppose you have a solver + + ```agda + magic : Type → Term + ``` + + that takes a reflected goal and outputs a proof (when successful). You can + then define the following macro + + ```agda + macro + by-magic : Term → TC ⊤ + by-magic hole = + bindTC (inferType hole) λ goal → + unify hole (magic goal) + ``` + + This lets you apply the magic tactic without any syntactic noise at all: + + ```agda + thm : ¬ P ≡ NP + thm = by-magic + ``` + +### Literals and built-ins + +* Overloaded number literals. + + You can now overload natural number literals using the new builtin + `FROMNAT`: + + ```agda + {-# BUILTIN FROMNAT fromNat #-} + ``` + + The target of the builtin should be a defined name. Typically you would do + something like + + ```agda + record Number (A : Set) : Set where + field fromNat : Nat → A + + open Number {{...}} public + + {-# BUILTIN FROMNAT fromNat #-} + ``` + + This will cause number literals `n` to be desugared to `fromNat n` + before type checking. + +* Negative number literals. + + Number literals can now be negative. For floating point literals it + works as expected. For integer literals there is a new builtin + `FROMNEG` that enables negative integer literals: + + ```agda + {-# BUILTIN FROMNEG fromNeg #-} + ``` + + This causes negative literals `-n` to be desugared to `fromNeg n`. + +* Overloaded string literals. + + String literals can be overladed using the `FROMSTRING` builtin: + + ```agda + {-# BUILTIN FROMSTRING fromString #-} + ``` + + The will cause string literals `s` to be desugared to `fromString s` + before type checking. + +* Change to builtin integers. + + The `INTEGER` builtin now needs to be bound to a datatype with two + constructors that should be bound to the new builtins `INTEGERPOS` + and `INTEGERNEGSUC` as follows: + + ```agda + data Int : Set where + pos : Nat -> Int + negsuc : Nat -> Int + {-# BUILTIN INTEGER Int #-} + {-# BUILTIN INTEGERPOS pos #-} + {-# BUILTIN INTEGERNEGSUC negsuc #-} + ``` + + where `negsuc n` represents the integer `-n - 1`. For instance, `-5` + is represented as `negsuc 4`. All primitive functions on integers + except `primShowInteger` have been removed, since these can be + defined without too much trouble on the above representation using + the corresponding functions on natural numbers. + + The primitives that have been removed are + + ```agda + primIntegerPlus + primIntegerMinus + primIntegerTimes + primIntegerDiv + primIntegerMod + primIntegerEquality + primIntegerLess + primIntegerAbs + primNatToInteger + ``` + +* New primitives for strict evaluation + + ```agda + primitive + primForce : ∀ {a b} {A : Set a} {B : A → Set b} (x : A) → (∀ x → B x) → B x + primForceLemma : ∀ {a b} {A : Set a} {B : A → Set b} (x : A) (f : ∀ x → B x) → primForce x f ≡ f x + ``` + + `primForce x f` evaluates to `f x` if x is in weak head normal form, + and `primForceLemma x f` evaluates to `refl` in the same + situation. The following values are considered to be in weak head + normal form: + + - constructor applications + - literals + - lambda abstractions + - type constructor (data/record types) applications + - function types + - Set a + +### Modules + +* Modules in import directives + + When you use `using`/`hiding`/`renaming` on a name it now + automatically applies to any module of the same name, unless you + explicitly mention the module. For instance, + + ```agda + open M using (D) + ``` + + is equivalent to + + ```agda + open M using (D; module D) + ``` + + if `M` defines a module `D`. This is most useful for record and data + types where you always get a module of the same name as the type. + + With this feature there is no longer useful to be able to qualify a + constructor (or field) by the name of the data type even when it + differs from the name of the corresponding module. The follow + (weird) code used to work, but doesn't work anymore: + + ```agda + module M where + data D where + c : D + open M using (D) renaming (module D to MD) + foo : D + foo = D.c + ``` + + If you want to import only the type name and not the module you have to hide + it explicitly: + + ```agda + open M using (D) hiding (module D) + ``` + + See discussion on + Issue [#836](https://github.com/agda/agda/issues/836). + +* Private definitions of a module are no longer in scope at the Emacs + mode top-level. + + The reason for this change is that `.agdai-files` are stripped of + unused private definitions (which can yield significant performance + improvements for module-heavy code). + + To test private definitions you can create a hole at the bottom of + the module, in which private definitions will be visible. + +### Records + +* New record directives `eta-equality`/`no-eta-equality` + + The keywords `eta-equality`/`no-eta-equality` enable/disable eta + rules for the (inductive) record type being declared. + + ```agda + record Σ (A : Set) (B : A -> Set) : Set where + no-eta-equality + constructor _,_ + field + fst : A + snd : B fst + open Σ + + -- fail : ∀ {A : Set}{B : A -> Set} → (x : Σ A B) → x ≡ (fst x , snd x) + -- fail x = refl + -- + -- x != fst x , snd x of type Σ .A .B + -- when checking that the expression refl has type x ≡ (fst x , snd x) + ``` + +* Building records from modules. + + The `record { }` syntax is now extended to accept module + names as well. Fields are thus defined using the corresponding + definitions from the given module. + + For instance assuming this record type `R` and module `M`: + + ```agda + record R : Set where + field + x : X + y : Y + z : Z + + module M where + x = {! ... !} + y = {! ... !} + + r : R + r = record { M; z = {! ... !} } + ``` + + Previously one had to write `record { x = M.x; y = M.y; z = {! ... !} }`. + + More precisely this construction now supports any combination of explicit + field definitions and applied modules. + + If a field is both given explicitly and available in one of the modules, + then the explicit one takes precedence. + + If a field is available in more than one module then this is ambiguous + and therefore rejected. As a consequence the order of assignments does + not matter. + + The modules can be both applied to arguments and have import directives + such as `hiding`, `using`, and `renaming`. In particular this construct + subsumes the record update construction. + + Here is an example of record update: + + ```agda + -- Record update. Same as: record r { y = {! ... !} } + r2 : R + r2 = record { R r; y = {! ... !} } + ``` + + A contrived example showing the use of `hiding`/`renaming`: + + ```agda + module M2 (a : A) where + w = {! ... !} + z = {! ... !} + + r3 : A → R + r3 a = record { M hiding (y); M2 a renaming (w to y) } + ``` + +* Record patterns are now accepted. + + Examples: + + ```agda + swap : {A B : Set} (p : A × B) → B × A + swap record{ proj₁ = a; proj₂ = b } = record{ proj₁ = b; proj₂ = a } + + thd3 : ... + thd3 record{ proj₂ = record { proj₂ = c }} = c + ``` + +* Record modules now properly hide all their parameters + [Issue [#1759](https://github.com/agda/agda/issues/1759)] + + Previously parameters to parent modules were not hidden in the record + module, resulting in different behaviour between + + ```agda + module M (A : Set) where + record R (B : Set) : Set where + ``` + + and + + ```agda + module M where + record R (A B : Set) : Set where + ``` + + where in the former case, `A` would be an explicit argument to the module + `M.R`, but implicit in the latter case. Now `A` is implicit in both cases. + +### Instance search + +* Performance has been improved, recursive instance search which was + previously exponential in the depth is now only quadratic. + +* Constructors of records and datatypes are not anymore automatically + considered as instances, you have to do so explicitely, for + instance: + + ```agda + -- only [b] is an instance of D + data D : Set where + a : D + instance + b : D + c : D + + -- the constructor is now an instance + record tt : Set where + instance constructor tt + ``` + +* Lambda-bound variables are no longer automatically considered + instances. + + Lambda-bound variables need to be bound as instance arguments to be + considered for instance search. For example, + + ```agda + _==_ : {A : Set} {{_ : Eq A}} → A → A → Bool + + fails : {A : Set} → Eq A → A → Bool + fails eqA x = x == x + + works : {A : Set} {{_ : Eq A}} → A → Bool + works x = x == x + ``` + +* Let-bound variables are no longer automatically considered + instances. + + To make a let-bound variable available as an instance it needs to be + declared with the `instance` keyword, just like top-level + instances. For example, + + ```agda + mkEq : {A : Set} → (A → A → Bool) → Eq A + + fails : {A : Set} → (A → A → Bool) → A → Bool + fails eq x = let eqA = mkEq eq in x == x + + works : {A : Set} → (A → A → Bool) → A → Bool + works eq x = let instance eqA = mkEq eq in x == x + ``` + +* Record fields can be declared instances. + + For example, + + ```agda + record EqSet : Set₁ where + field + set : Set + instance eq : Eq set + ``` + + This causes the projection function `eq : (E : EqSet) → Eq (set E)` + to be considered for instance search. + +* Instance search can now find arguments in variable types (but such + candidates can only be lambda-bound variables, they can’t be + declared as instances) + + ```agda + module _ {A : Set} (P : A → Set) where + + postulate + bla : {x : A} {{_ : P x}} → Set → Set + + -- Works, the instance argument is found in the context + test : {x : A} {{_ : P x}} → Set → Set + test B = bla B + + -- Still forbidden, because [P] could be instantiated later to anything + instance + postulate + forbidden : {x : A} → P x + ``` + +* Instance search now refuses to solve constraints with unconstrained + metavariables, since this can lead to non-termination. + + See [Issue [#1532](https://github.com/agda/agda/issues/1523)] for an + example. + +* Top-level instances are now only considered if they are in + scope. [Issue [#1913](https://github.com/agda/agda/issues/1913)] + + Note that lambda-bound instances need not be in scope. + +### Other changes + +* Unicode ellipsis character is allowed for the ellipsis token `...` + in `with` expressions. + +* `Prop` is no longer a reserved word. + +Type checking +------------- + +* Large indices. + + Force constructor arguments no longer count towards the size of a datatype. + For instance, the definition of equality below is accepted. + + ```agda + data _≡_ {a} {A : Set a} : A → A → Set where + refl : ∀ x → x ≡ x + ``` + + This gets rid of the asymmetry that the version of equality which indexes + only on the second argument could be small, but not the version above which + indexes on both arguments. + +* Detection of datatypes that satisfy K (i.e. sets) + + Agda will now try to detect datatypes that satisfy K when + `--without-K` is enabled. A datatype satisfies K when it follows + these three rules: + + - The types of all non-recursive constructor arguments should satisfy K. + + - All recursive constructor arguments should be first-order. + + - The types of all indices should satisfy K. + + For example, the types `Nat`, `List Nat`, and `x ≡ x` (where `x : + Nat`) are all recognized by Agda as satisfying K. + +* New unifier for case splitting + + The unifier used by Agda for case splitting has been completely + rewritten. The new unifier takes a much more type-directed approach + in order to avoid the problems in issues + [#1406](https://github.com/agda/agda/issues/1406), + [#1408](https://github.com/agda/agda/issues/1408), + [#1427](https://github.com/agda/agda/issues/1427), and + [#1435](https://github.com/agda/agda/issues/1435). + + The new unifier also has eta-equality for record types + built-in. This should avoid unnecessary case splitting on record + constructors and improve the performance of Agda on code that + contains deeply nested record patterns (see issues + [#473](https://github.com/agda/agda/issues/473), + [#635](https://github.com/agda/agda/issues/635), + [#1575](https://github.com/agda/agda/issues/1575), + [#1603](https://github.com/agda/agda/issues/1603), + [#1613](https://github.com/agda/agda/issues/1613), and + [#1645](https://github.com/agda/agda/issues/1645)). + + In some cases, the locations of the dot patterns computed by the + unifier did not correspond to the locations given by the user (see + Issue [#1608](https://github.com/agda/agda/issues/1608)). This has + now been fixed by adding an extra step after case splitting that + checks whether the user-written patterns are compatible with the + computed ones. + + In some rare cases, the new unifier is still too restrictive when + `--without-K` is enabled because it cannot generalize over the + datatype indices (yet). For example, the following code is rejected: + + ```agda + data Bar : Set₁ where + bar : Bar + baz : (A : Set) → Bar + + data Foo : Bar → Set where + foo : Foo bar + + test : foo ≡ foo → Set₁ + test refl = Set + ``` + +* The aggressive behaviour of `with` introduced in 2.4.2.5 has been + rolled back + [Issue [#1692](https://github.com/agda/agda/issues/1692)]. With no + longer abstracts in the types of variables appearing in the + with-expressions. [Issue [#745](https://github.com/agda/agda/issues/745)] + + This means that the following example no longer works: + + ```agda + fails : (f : (x : A) → a ≡ x) (b : A) → b ≡ a + fails f b with a | f b + fails f b | .b | refl = f b + ``` + + The `with` no longer abstracts the type of `f` over `a`, since `f` + appears in the second with-expression `f b`. You can use a nested + `with` to make this example work. + + This example does work again: + + ```agda + test : ∀{A : Set}{a : A}{f : A → A} (p : f a ≡ a) → f (f a) ≡ a + test p rewrite p = p + ``` + + After `rewrite p` the goal has changed to `f a ≡ a`, but the type + of `p` has not been rewritten, thus, the final `p` solves the goal. + + The following, which worked in 2.4.2.5, no longer works: + + ```agda + fails : (f : (x : A) → a ≡ x) (b : A) → b ≡ a + fails f b rewrite f b = f b + ``` + + The rewrite with `f b : a ≡ b` is not applied to `f` as + the latter is part of the rewrite expression `f b`. Thus, + the type of `f` remains untouched, and the changed goal + `b ≡ b` is not solved by `f b`. + +* When using `rewrite` on a term `eq` of type `lhs ≡ rhs`, the `lhs` + is no longer abstracted in `rhs` + [Issue [#520](https://github.com/agda/agda/issues/520)]. This means + that + + ```agda + f pats rewrite eq = body + ``` + + is more than syntactic sugar for + + ```agda + f pats with lhs | eq + f pats | _ | refl = body + ``` + + In particular, the following application of `rewrite` is now + possible + + ```agda + id : Bool → Bool + id true = true + id false = false + + is-id : ∀ x → x ≡ id x + is-id true = refl + is-id false = refl + + postulate + P : Bool → Set + b : Bool + p : P (id b) + + proof : P b + proof rewrite is-id b = p + ``` + + Previously, this was desugared to + + ```agda + proof with b | is-id b + proof | _ | refl = p + ``` + + which did not type check as `refl` does not have type `b ≡ id b`. + Now, Agda gets the task of checking `refl : _ ≡ id b` leading to + instantiation of `_` to `id b`. + +Compiler backends +----------------- + +* Major Bug Fixes: + + - Function clauses with different arities are now always compiled + correctly by the GHC/UHC + backends. (Issue [#727](https://github.com/agda/agda/issues/727)) + +* Co-patterns + + - The GHC/UHC backends now support co-patterns. (Issues + [#1567](https://github.com/agda/agda/issues/1567), + [#1632](https://github.com/agda/agda/issues/1632)) + +* Optimizations + + - Builtin naturals are now represented as arbitrary-precision + Integers. See the user manual, section + "Agda Compilers -> Optimizations" for details. + +* GHC Haskell backend (MAlonzo) + + - Pragmas + + Since builtin naturals are compiled to `Integer` you can no longer + give a `{-# COMPILED_DATA #-}` pragma for `Nat`. The same goes for + builtin booleans, integers, floats, characters and strings which + are now hard-wired to appropriate Haskell types. + +* UHC compiler backend + + A new backend targeting the Utrecht Haskell Compiler (UHC) is + available. It targets the UHC Core language, and it's design is + inspired by the Epic backend. See the user manual, section "Agda + Compilers -> UHC Backend" for installation instructions. + + - FFI + + The UHC backend has a FFI to Haskell similar to MAlonzo's. The + target Haskell code also needs to be compilable using UHC, which + does not support the Haskell base library version 4.*. + + FFI pragmas for the UHC backend are not checked in any way. If the + pragmas are wrong, bad things will happen. + + - Imports + + Additional Haskell modules can be brought into scope with the + `IMPORT_UHC` pragma: + + ```agda + {-# IMPORT_UHC Data.Char #-} + ``` + + The Haskell modules `UHC.Base` and `UHC.Agda.Builtins` are always in + scope and don't need to be imported explicitly. + + - Datatypes + + Agda datatypes can be bound to Haskell datatypes as follows: + + Haskell: + ```haskell + data HsData a = HsCon1 | HsCon2 (HsData a) + ``` + + Agda: + ```agda + data AgdaData (A : Set) : Set where + AgdaCon1 : AgdaData A + AgdaCon2 : AgdaData A -> AgdaData A + {-# COMPILED_DATA_UHC AgdaData HsData HsCon1 HsCon2 #-} + ``` + + The mapping has to cover all constructors of the used Haskell + datatype, else runtime behavior is undefined! + + There are special reserved names to bind Agda datatypes to certain + Haskell datatypes. For example, this binds an Agda datatype to + Haskell's list datatype: + + Agda: + ```agda + data AgdaList (A : Set) : Set where + Nil : AgdaList A + Cons : A -> AgdaList A -> AgdaList A + {-# COMPILED_DATA_UHC AgdaList __LIST__ __NIL__ __CONS__ #-} + ``` + + The following "magic" datatypes are available: + + ``` + HS Datatype | Datatype Pragma | HS Constructor | Constructor Pragma + () __UNIT__ () __UNIT__ + List __LIST__ (:) __CONS__ + [] __NIL__ + Bool __BOOL__ True __TRUE__ + False __FALSE__ + ``` + + - Functions + + Agda postulates can be bound to Haskell functions. Similar as in + MAlonzo, all arguments of type `Set` need to be dropped before + calling Haskell functions. An example calling the return function: + + Agda: + ```agda + postulate hs-return : {A : Set} -> A -> IO A + {-# COMPILED_UHC hs-return (\_ -> UHC.Agda.Builtins.primReturn) #-} + ``` + +Emacs mode and interaction +-------------------------- + +* Module contents (`C-c C-o`) now also works for + records. [See Issue [#1926](https://github.com/agda/agda/issues/1926) ] + If you have an inferable expression of record type in an interaction + point, you can invoke `C-c C-o` to see its fields and types. + Example + + ```agda + record R : Set where + field f : A + + test : R → R + test r = {!r!} -- C-c C-o here + ``` + +* Less aggressive error notification. + + Previously Emacs could jump to the position of an error even if the + type-checking process was not initiated in the current buffer. Now + this no longer happens: If the type-checking process was initiated + in another buffer, then the cursor is moved to the position of the + error in the buffer visiting the file (if any) and in every window + displaying the file, but focus should not change from one file to + another. + + In the cases where focus does change from one file to another, one + can now use the go-back functionality to return to the previous + position. + +* Removed the `agda-include-dirs` customization parameter. + + Use `agda-program-args` with `-iDIR` or `-lLIB` instead, or add + libraries to `~/.agda/defaults` + (`C:/Users/USERNAME/AppData/Roaming/agda/defaults` or similar on + Windows). See Library management, above, for more information. + +Tools +----- + +### LaTeX-backend + +* The default font has been changed to XITS (which is part of TeX Live): + + http://www.ctan.org/tex-archive/fonts/xits/ + + This font is more complete with respect to Unicode. + +### agda-ghc-names + +* New tool: The command + + ``` + agda-ghc-names fixprof .prof + ``` + + converts `*.prof` files obtained from profiling runs of + MAlonzo-compiled code to `*.agdaIdents.prof`, with the original Agda + identifiers replacing the MAlonzo-generated Haskell identifiers. + + For usage and more details, see `src/agda-ghc-names/README.txt`. + +Highlighting and textual backends +--------------------------------- + +* Names in import directives are now highlighted and are clickable. + [Issue [#1714](https://github.com/agda/agda/issues/1714)] This leads + also to nicer printing in the LaTeX and html backends. + +Fixed issues +------------ + +See +[bug tracker (milestone 2.5.1)](https://github.com/agda/agda/issues?q=milestone%3A2.5.1+is%3Aclosed) diff --git a/doc/release-notes/2.5.2.md b/doc/release-notes/2.5.2.md new file mode 100644 --- /dev/null +++ b/doc/release-notes/2.5.2.md @@ -0,0 +1,1184 @@ +Release notes for Agda version 2.5.2 +==================================== + +Installation and infrastructure +------------------------------- + +* Modular support for literate programming + + Literate programming support has been moved out of the lexer and into the + `Agda.Syntax.Parser.Literate` module. + + Files ending in `.lagda` are still interpreted as literate TeX. + The extension `.lagda.tex` may now also be used for literate TeX files. + + Support for more literate code formats and extensions can be added + modularly. + + By default, `.lagda.*` files are opened in the Emacs mode + corresponding to their last extension. One may switch to and from + Agda mode manually. + +* reStructuredText + + Literate Agda code can now be written in reStructuredText format, using + the `.lagda.rst` extension. + + As a general rule, Agda will parse code following a line ending in `::`, + as long as that line does not start with `..`. The module name must + match the path of the file in the documentation, and must be given + explicitly. Several files have been converted already, for instance: + + - `language/mixfix-operators.lagda.rst` + - `tools/compilers.lagda.rst` + + Note that: + + - Code blocks inside an rST comment block will be type-checked by Agda, + but not rendered in the documentation. + - Code blocks delimited by `.. code-block:: agda` will be rendered in + the final documenation, but not type-checked by Agda. + - All lines inside a codeblock must be further indented than the first line + of the code block. + - Indentation must be consistent between code blocks. In other + words, the file as a whole must be a valid Agda file if all the + literate text is replaced by white space. + +* Documentation testing + + All documentation files in the `doc/user-manual` directory that end + in `.lagda.rst` can be typechecked by running `make + user-manual-test`, and also as part of the general test suite. + +* Support installation through Stack + + The Agda sources now also include a configuration for the stack install tool + (tested through continuous integration). + + It should hence be possible to repeatably build any future Agda version + (including unreleased commits) from source by checking out that version and + running `stack install` from the checkout directory. + By using repeatable builds, this should keep selecting the same dependencies + in the face of new releases on Hackage. + + For further motivation, see + Issue [#2005](https://github.com/agda/agda/issues/2005). + +* Removed the `--test` command-line option + + This option ran the internal test-suite. This test-suite was + implemented using Cabal supports for + test-suites. [Issue [#2083](https://github.com/agda/agda/issues/2083)]. + +* The `--no-default-libraries` flag has been split into two flags + [Issue [#1937](https://github.com/agda/agda/issues/1937)] + + - `--no-default-libraries`: Ignore the defaults file but still look for local + `.agda-lib` files + - `--no-libraries`: Don't use any `.agda-lib` files (the previous behaviour + of `--no-default-libraries`). + +* If `agda` was built inside `git` repository, then the `--version` flag + will display the hash of the commit used, and whether the tree was + `-dirty` (i.e. there were uncommited changes in the working directory). + Otherwise, only the version number is shown. + +Language +-------- + +* Dot patterns are now optional + + Consider the following program + + ```agda + data Vec (A : Set) : Nat → Set where + [] : Vec A zero + cons : ∀ n → A → Vec A n → Vec A (suc n) + + vmap : ∀ {A B} n → (A → B) → Vec A n → Vec B n + vmap .zero f [] = [] + vmap .(suc m) f (cons m x xs) = cons m (f x) (vmap m f xs) + ``` + + If we don't care about the dot patterns they can (and could previously) be + replaced by wildcards: + + ```agda + vmap : ∀ {A B} n → (A → B) → Vec A n → Vec B n + vmap _ f [] = [] + vmap _ f (cons m x xs) = cons m (f x) (vmap m f xs) + ``` + + Now it is also allowed to give a variable pattern in place of the dot + pattern. In this case the variable will be bound to the value of the dot + pattern. For our example: + + ```agda + vmap : ∀ {A B} n → (A → B) → Vec A n → Vec B n + vmap n f [] = [] + vmap n f (cons m x xs) = cons m (f x) (vmap m f xs) + ``` + + In the first clause `n` reduces to `zero` and in the second clause + `n` reduces to `suc m`. + +* Module parameters can now be refined by pattern matching + + Previously, pattern matches that would refine a variable outside the + current left-hand side was disallowed. For instance, the following + would give an error, since matching on the vector would + instantiate `n`. + + ```agda + module _ {A : Set} {n : Nat} where + f : Vec A n → Vec A n + f [] = [] + f (x ∷ xs) = x ∷ xs + ``` + + Now this is no longer disallowed. Instead `n` is bound to the + appropriate value in each clause. + +* With-abstraction now abstracts also in module parameters + + The change that allows pattern matching to refine module parameters also + allows with-abstraction to abstract in them. For instance, + + ```agda + module _ (n : Nat) (xs : Vec Nat (n + n)) where + f : Nat + f with n + n + f | nn = ? -- xs : Vec Nat nn + ``` + + Note: Any function argument or lambda-bound variable bound outside a given + function counts as a module parameter. + + To prevent abstraction in a parameter you can hide it inside a definition. In + the above example, + + ```agda + module _ (n : Nat) (xs : Vec Nat (n + n)) where + + ys : Vec Nat (n + n) + ys = xs + + f : Nat + f with n + n + f | nn = ? -- xs : Vec Nat nn, ys : Vec Nat (n + n) + ``` + +* As-patterns [Issue [#78](https://github.com/agda/agda/issues/78)]. + + As-patterns (`@`-patterns) are finally working and can be used to name a + pattern. The name has the same scope as normal pattern variables (i.e. the + right-hand side, where clause, and dot patterns). The name reduces to the + value of the named pattern. For example:: + + ```agda + module _ {A : Set} (_<_ : A → A → Bool) where + merge : List A → List A → List A + merge xs [] = xs + merge [] ys = ys + merge xs@(x ∷ xs₁) ys@(y ∷ ys₁) = + if x < y then x ∷ merge xs₁ ys + else y ∷ merge xs ys₁ + ``` + +* Idiom brackets. + + There is new syntactic sugar for idiom brackets: + + `(| e a1 .. an |)` expands to + + `pure e <*> a1 <*> .. <*> an` + + The desugaring takes place before scope checking and only requires names + `pure` and `_<*>_` in scope. Idiom brackets work well with operators, for + instance + + `(| if a then b else c |)` desugars to + + `pure if_then_else_ <*> a <*> b <*> c` + + Limitations: + + - The top-level application inside idiom brackets cannot include + implicit applications, so `(| foo {x = e} a b |)` is illegal. In + the case `e` is pure you can write `(| (foo {x = e}) a b |)` + which desugars to + + `pure (foo {x = e}) <*> a <*> b` + + - Binding syntax and operator sections cannot appear immediately inside + idiom brackets. + +* Layout for pattern matching lambdas. + + You can now write pattern matching lambdas using the syntax + + ```agda + λ where false → true + true → false + ``` + + avoiding the need for explicit curly braces and semicolons. + +* Overloaded projections + [Issue [#1944](https://github.com/agda/agda/issues/1944)]. + + Ambiguous projections are no longer a scope error. Instead they get + resolved based on the type of the record value they are + eliminating. This corresponds to constructors, which can be + overloaded and get disambiguated based on the type they are + introducing. Example: + + ```agda + module _ (A : Set) (a : A) where + + record R B : Set where + field f : B + open R public + + record S B : Set where + field f : B + open S public + ``` + + Exporting `f` twice from both `R` and `S` is now allowed. Then, + + ```agda + r : R A + f r = a + + s : S A + f s = f r + ``` + + disambiguates to: + + ```agda + r : R A + R.f r = a + + s : S A + S.f s = R.f r + ``` + + If the type of the projection is known, it can also be disambiguated + unapplied. + + ```agda + unapplied : R A -> A + unapplied = f + ``` + +* Postfix projections + [Issue [#1963](https://github.com/agda/agda/issues/1963)]. + + Agda now supports a postfix syntax for projection application. + This style is more in harmony with copatterns. For example: + + ```agda + record Stream (A : Set) : Set where + coinductive + field head : A + tail : Stream A + + open Stream + + repeat : ∀{A} (a : A) → Stream A + repeat a .head = a + repeat a .tail = repeat a + + zipWith : ∀{A B C} (f : A → B → C) (s : Stream A) (t : Stream B) → Stream C + zipWith f s t .head = f (s .head) (t .head) + zipWith f s t .tail = zipWith f (s .tail) (t .tail) + + module Fib (Nat : Set) (zero one : Nat) (plus : Nat → Nat → Nat) where + + {-# TERMINATING #-} + fib : Stream Nat + fib .head = zero + fib .tail .head = one + fib .tail .tail = zipWith plus fib (fib .tail) + ``` + + The thing we eliminate with projection now is visibly the head, + i.e., the left-most expression of the sequence (e.g. `repeat` in + `repeat a .tail`). + + The syntax overlaps with dot patterns, but for type correct left + hand sides there is no confusion: Dot patterns eliminate function + types, while (postfix) projection patterns eliminate record types. + + By default, Agda prints system-generated projections (such as by + eta-expansion or case splitting) prefix. This can be changed with + the new option: + + ```agda + {-# OPTIONS --postfix-projections #-} + ``` + + Result splitting in extended lambdas (aka pattern lambdas) always + produces postfix projections, as prefix projection pattern do not + work here: a prefix projection needs to go left of the head, but the + head is omitted in extended lambdas. + + ```agda + dup : ∀{A : Set}(a : A) → A × A + dup = λ{ a → ? } + ``` + + Result splitting (`C-c C-c RET`) here will yield: + + ```agda + dup = λ{ a .proj₁ → ? ; a .proj₂ → ? } + ``` + +* Projection parameters + [Issue [#1954](https://github.com/agda/agda/issues/1954)]. + + When copying a module, projection parameters will now stay hidden + arguments, even if the module parameters are visible. + This matches the situation we had for constructors since long. + Example: + + ```agda + module P (A : Set) where + record R : Set where + field f : A + + open module Q A = P A + ``` + + Parameter `A` is now hidden in `R.f`: + + ```agda + test : ∀{A} → R A → A + test r = R.f r + ``` + + Note that a module parameter that corresponds to the record value + argument of a projection will not be hidden. + + ```agda + module M (A : Set) (r : R A) where + open R A r public + + test' : ∀{A} → R A → A + test' r = M.f r + ``` + +* Eager insertion of implicit arguments + [Issue [#2001](https://github.com/agda/agda/issues/2001)] + + Implicit arguments are now (again) eagerly inserted in left-hand sides. The + previous behaviour of inserting implicits for where blocks, but not + right-hand sides was not type safe. + +* Module applications can now be eta expanded/contracted without + changing their behaviour + [Issue #[1985](https://github.com/agda/agda/issues/1985)] + + Previously definitions exported using `open public` got the + incorrect type for underapplied module applications. + + Example: + + ```agda + module A where + postulate A : Set + + module B (X : Set) where + open A public + + module C₁ = B + module C₂ (X : Set) = B X + ``` + + Here both `C₁.A` and `C₂.A` have type `(X : Set) → Set`. + +* Polarity pragmas. + + Polarity pragmas can be attached to postulates. The polarities express + how the postulate's arguments are used. The following polarities + are available: + + `_`: Unused. + + `++`: Strictly positive. + + `+`: Positive. + + `-`: Negative. + + `*`: Unknown/mixed. + + Polarity pragmas have the form + + ``` + {-# POLARITY name #-} + ``` + + and can be given wherever fixity declarations can be given. The + listed polarities apply to the given postulate's arguments + (explicit/implicit/instance), from left to right. Polarities + currently cannot be given for module parameters. If the postulate + takes n arguments (excluding module parameters), then the number of + polarities given must be between 0 and n (inclusive). + + Polarity pragmas make it possible to use postulated type formers in + recursive types in the following way: + + ```agda + postulate + ∥_∥ : Set → Set + + {-# POLARITY ∥_∥ ++ #-} + + data D : Set where + c : ∥ D ∥ → D + ``` + + Note that one can use postulates that may seem benign, together with + polarity pragmas, to prove that the empty type is inhabited: + + ```agda + postulate + _⇒_ : Set → Set → Set + lambda : {A B : Set} → (A → B) → A ⇒ B + apply : {A B : Set} → A ⇒ B → A → B + + {-# POLARITY _⇒_ ++ #-} + + data ⊥ : Set where + + data D : Set where + c : D ⇒ ⊥ → D + + not-inhabited : D → ⊥ + not-inhabited (c f) = apply f (c f) + + inhabited : D + inhabited = c (lambda not-inhabited) + + bad : ⊥ + bad = not-inhabited inhabited + ``` + + Polarity pragmas are not allowed in safe mode. + +* Declarations in a `where`-block are now + private. [Issue [#2101](https://github.com/agda/agda/issues/2101)] + This means that + + ```agda + f ps = body where + decls + ``` + + is now equivalent to + + ```agda + f ps = body where + private + decls + ``` + + This changes little, since the `decls` were anyway not in scope + outside `body`. However, it makes a difference for abstract + definitions, because private type signatures can see through + abstract definitions. Consider: + + ```agda + record Wrap (A : Set) : Set where + field unwrap : A + + postulate + P : ∀{A : Set} → A → Set + + abstract + + unnamedWhere : (A : Set) → Set + unnamedWhere A = A + where -- the following definitions are private! + B : Set + B = Wrap A + + postulate + b : B + test : P (Wrap.unwrap b) -- succeeds + ``` + + The `abstract` is inherited in `where`-blocks from the parent (here: + function `unnamedWhere`). Thus, the definition of `B` is opaque and + the type equation `B = Wrap A` cannot be used to check type + signatures, not even of abstract definitions. Thus, checking the + type `P (Wrap.unwrap b)` would fail. However, if `test` is + private, abstract definitions are translucent in its type, and + checking succeeds. With the implemented change, all + `where`-definitions are private, in this case `B`, `b`, and `test`, + and the example succeeds. + + Nothing changes for the named forms of `where`, + + ```agda + module M where + module _ where + ``` + + For instance, this still fails: + + ```agda + abstract + + unnamedWhere : (A : Set) → Set + unnamedWhere A = A + module M where + B : Set + B = Wrap A + + postulate + b : B + test : P (Wrap.unwrap b) -- fails + ``` + +* Private anonymous modules now work as expected + [Issue [#2199](https://github.com/agda/agda/issues/2199)] + + Previously the `private` was ignored for anonymous modules causing + its definitions to be visible outside the module containing the + anonymous module. This is no longer the case. For instance, + + ```agda + module M where + private + module _ (A : Set) where + Id : Set + Id = A + + foo : Set → Set + foo = Id + + open M + + bar : Set → Set + bar = Id -- Id is no longer in scope here + ``` + +* Pattern synonyms are now expanded on left hand sides of DISPLAY + pragmas [Issue [#2132](https://github.com/agda/agda/issues/2132)]. + Example: + + ```agda + data D : Set where + C c : D + g : D → D + + pattern C′ = C + + {-# DISPLAY C′ = C′ #-} + {-# DISPLAY g C′ = c #-} + ``` + + This now behaves as: + + ```agda + {-# DISPLAY C = C′ #-} + {-# DISPLAY g C = c #-} + ``` + + Expected error for + + ```agda + test : C ≡ g C + test = refl + ``` + + is thus: + + ``` + C′ != c of type D + ``` + +* The built-in floats have new semantics to fix inconsistencies + and to improve cross-platform portability. + + - Float equality has been split into two primitives. + ``primFloatEquality`` is designed to establish + decidable propositional equality while + ``primFloatNumericalEquality`` is intended for numerical + computations. They behave as follows: + + ``` + primFloatEquality NaN NaN = True + primFloatEquality 0.0 -0.0 = False + + primFloatNumericalEquality NaN NaN = False + primFloatNumericalEquality 0.0 -0.0 = True + ``` + + This change fixes an inconsistency, see [Issue [#2169](https://github.com/agda/agda/issues/2169)]. + For further detail see the [user manual](http://agda.readthedocs.io/en/v2.5.2/language/built-ins.html#floats). + + - Floats now have only one `NaN` value. This is necessary + for proper Float support in the JavaScript backend, + as JavaScript (and some other platforms) only support + one `NaN` value. + + - The primitive function `primFloatLess` was renamed + `primFloatNumericalLess`. + +* Added new primitives to built-in floats: + + - `primFloatNegate : Float → Float` + [Issue [#2194](https://github.com/agda/agda/issues/2194)] + + - Trigonometric primitives + [Issue [#2200](https://github.com/agda/agda/issues/2200)]: + + ```agda + primCos : Float → Float + primTan : Float → Float + primASin : Float → Float + primACos : Float → Float + primATan : Float → Float + primATan2 : Float → Float → Float + ``` + +* Anonymous declarations + [Issue [#1465](https://github.com/agda/agda/issues/1465)]. + + A module can contain an arbitrary number of declarations + named `_` which will scoped-checked and type-checked but + won't be made available in the scope (nor exported). They + cannot introduce arguments on the LHS (but one can use + lambda-abstractions on the RHS) and they cannot be defined + by recursion. + + ```agda + _ : Set → Set + _ = λ x → x + ``` + +### Rewriting + +* The REWRITE pragma can now handle several names. E.g.: + ```agda + {-# REWRITE eq1 eq2 #-} + ``` + +### Reflection + +* You can now use macros in reflected terms + [Issue [#2130](https://github.com/agda/agda/issues/2130)]. + + For instance, given a macro + + ```agda + macro + some-tactic : Term → TC ⊤ + some-tactic = ... + ``` + + the term `def (quote some-tactic) []` represents a call to the + macro. This makes it a lot easier to compose tactics. + +* The reflection machinery now uses normalisation less often: + + * Macros no longer normalise the (automatically quoted) term + arguments. + + * The TC primitives `inferType`, `checkType` and `quoteTC` no longer + normalise their arguments. + + * The following deprecated constructions may also have been changed: + `quoteGoal`, `quoteTerm`, `quoteContext` and `tactic`. + +* New TC primitive: `withNormalisation`. + + To recover the old normalising behaviour of `inferType`, `checkType`, + `quoteTC` and `getContext`, you can wrap them inside a call to + `withNormalisation true`: + + ```agda + withNormalisation : ∀ {a} {A : Set a} → Bool → TC A → TC A + ``` + +* New TC primitive: `reduce`. + + ```agda + reduce : Term → TC Term + ``` + + Reduces its argument to weak head normal form. + +* Added new TC primitive: `isMacro` + [Issue [#2182](https://github.com/agda/agda/issues/2182)] + + ```agda + isMacro : Name → TC Bool + ``` + + Returns `true` if the name refers to a macro, otherwise `false`. + +* The `record-type` constructor now has an extra argument containing + information about the record type's fields: + ```agda + data Definition : Set where + … + record-type : (c : Name) (fs : List (Arg Name)) → Definition + … + ``` + +Type checking +------------- + +* Files with open metas can be imported now + [Issue [#964](https://github.com/agda/agda/issues/964)]. This + should make simultaneous interactive development on several modules + more pleasant. + + Requires option: `--allow-unsolved-metas` + + Internally, before serialization, open metas are turned into postulates named + + ``` + unsolved#meta. + ``` + + where `` is the internal meta variable number. + +* The performance of the compile-time evaluator has been greatly improved. + + - Fixed a memory leak in evaluator + (Issue [#2147](https://github.com/agda/agda/issues/2147)). + + - Reduction speed improved by an order of magnitude and is now + comparable to the performance of GHCi. Still call-by-name though. + +* The detection of types that satisfy K added in Agda 2.5.1 has been + rolled back (see + Issue [#2003](https://github.com/agda/agda/issues/2003)). + +* Eta-equality for record types is now only on after the positivity + checker has confirmed it is safe to have it. Eta-equality for + unguarded inductive records previously lead to looping of the type + checker. + [See Issue [#2197](https://github.com/agda/agda/issues/2197)] + + ```agda + record R : Set where + inductive + field r : R + + loops : R + loops = ? + ``` + + As a consequence of this change, the following example does not + type-check any more: + + ```agda + mutual + record ⊤ : Set where + + test : ∀ {x y : ⊤} → x ≡ y + test = refl + ``` + + It fails because the positivity checker is only run after the mutual + block, thus, eta-equality for `⊤` is not available when checking + test. + + One can declare eta-equality explicitly, though, to make this + example work. + + ```agda + mutual + record ⊤ : Set where + eta-equality + + test : ∀ {x y : ⊤} → x ≡ y + test = refl + ``` + +* Records with instance fields are now eta expanded before instance search. + + For instance, assuming `Eq` and `Ord` with boolean functions `_==_` and `_<_` + respectively, + + ```agda + record EqAndOrd (A : Set) : Set where + field {{eq}} : Eq A + {{ord}} : Ord A + + + leq : {A : Set} {{_ : EqAndOrd A}} → A → A → Bool + leq x y = x == y || x < y + ``` + + Here the `EqAndOrd` record is automatically unpacked before instance search, + revealing the component `Eq` and `Ord` instances. + + This can be used to simulate superclass dependencies. + +* Overlappable record instance fields. + + Instance fields in records can be marked as overlappable using the new + `overlap` keyword: + + ```agda + record Ord (A : Set) : Set where + field + _<_ : A → A → Bool + overlap {{eqA}} : Eq A + ``` + + When instance search finds multiple candidates for a given instance goal and + they are **all** overlappable it will pick the left-most candidate instead of + refusing to solve the instance goal. + + This can be use to solve the problem arising from shared "superclass" + dependencies. For instance, if you have, in addition to `Ord` above, a `Num` + record that also has an `Eq` field and want to write a function requiring + both `Ord` and `Num`, any `Eq` constraint will be solved by the `Eq` instance + from whichever argument that comes first. + + ```agda + record Num (A : Set) : Set where + field + fromNat : Nat → A + overlap {{eqA}} : Eq A + + lessOrEqualFive : {A : Set} {{NumA : Num A}} {{OrdA : Ord A}} → A → Bool + lessOrEqualFive x = x == fromNat 5 || x < fromNat 5 + ``` + + In this example the call to `_==_` will use the `eqA` field from `NumA` + rather than the one from `OrdA`. Note that these may well be different. + +* Instance fields can be left out of copattern matches + [Issue [#2288](https://github.com/agda/agda/issues/2288)] + + Missing cases for instance fields (marked `{{` `}}`) in copattern matches + will be solved using instance search. This makes defining instances with + superclass fields much nicer. For instance, we can define `Nat` instances of + `Eq`, `Ord` and `Num` from above as follows: + + ```agda + instance + EqNat : Eq Nat + _==_ {{EqNat}} n m = eqNat n m + + OrdNat : Ord Nat + _<_ {{OrdNat}} n m = lessNat n m + + NumNat : Num Nat + fromNat {{NumNat}} n = n + ``` + + The `eqA` fields of `Ord` and `Num` are filled in using instance search (with + `EqNat` in this case). + +* Limited instance search depth + [Issue [#2269](https://github.com/agda/agda/issues/2269)] + + To prevent instance search from looping on bad instances + (see [Issue #1743](https://github.com/agda/agda/issues/1743)) the search + depth of instance search is now limited. The maximum depth can be set with + the `--instance-search-depth` flag and the default value is `500`. + +Emacs mode +---------- + +* New command `C-u C-u C-c C-n`: Use `show` to display the result of + normalisation. + + Calling `C-u C-u C-c C-n` on an expression `e` (in a hole or at top level) + normalises `show e` and prints the resulting string, or an error message if + the expression does not normalise to a literal string. + + This is useful when working with complex data structures for which you have + defined a nice `Show` instance. + + Note that the name `show` is hardwired into the command. + +* Changed feature: Interactively split result. + + Make-case (`C-c C-c`) with no variables will now *either* introduce + function arguments *or* do a copattern split (or fail). + + This is as before: + + ```agda + test : {A B : Set} (a : A) (b : B) → A × B + test a b = ? + + -- expected: + -- proj₁ (test a b) = {!!} + -- proj₂ (test a b) = {!!} + + testFun : {A B : Set} (a : A) (b : B) → A × B + testFun = ? + + -- expected: + -- testFun a b = {!!} + ``` + + This is has changed: + + ```agda + record FunRec A : Set where + field funField : A → A + open FunRec + + testFunRec : ∀{A} → FunRec A + testFunRec = ? + + -- expected (since 2016-05-03): + -- funField testFunRec = {!!} + + -- used to be: + -- funField testFunRec x = {!!} + ``` + +* Changed feature: Split on hidden variables. + + Make-case (`C-c C-c`) will no longer split on the given hidden + variables, but only make them visible. (Splitting can then be + performed in a second go.) + + ```agda + test : ∀{N M : Nat} → Nat → Nat → Nat + test N M = {!.N N .M!} + ``` + + Invoking splitting will result in: + + ```agda + test {N} {M} zero M₁ = ? + test {N} {M} (suc N₁) M₁ = ? + ``` + + The hidden `.N` and `.M` have been brought into scope, the + visible `N` has been split upon. + +* Non-fatal errors/warnings. + + Non-fatal errors and warnings are now displayed in the info buffer + and do not interrupt the typechecking of the file. + + Currently termination errors, unsolved metavariables, unsolved + constraints, positivity errors, deprecated BUILTINs, and empty + REWRITING pragmas are non-fatal errors. + +* Highlighting for positivity check failures + + Negative occurences of a datatype in its definition are now + highlighted in a way similar to termination errors. + +* The abbrev for codata was replaced by an abbrev for code + environments. + + If you type `c C-x '` (on a suitably standard setup), then Emacs + will insert the following text: + + ```agda + \begin{code} \end{code}. + ``` + +* The LaTeX backend can now be invoked from the Emacs mode. + + Using the compilation command (`C-c C-x C-c`). + + The flag `--latex-dir` can be used to set the output directory (by + default: `latex`). Note that if this directory is a relative path, + then it is interpreted relative to the "project root". (When the + LaTeX backend is invoked from the command line the path is + interpreted relative to the current working directory.) Example: If + the module `A.B.C` is located in the file `/foo/A/B/C.agda`, then + the project root is `/foo/`, and the default output directory is + `/foo/latex/`. + +* The compilation command (`C-c C-x C-c`) now by default asks for a + backend. + + To avoid this question, set the customisation variable + `agda2-backend` to an appropriate value. + +* The command `agda2-measure-load-time` no longer "touches" the file, + and the optional argument `DONT-TOUCH` has been removed. + +* New command `C-u (C-u) C-c C-s`: Simplify or normalise the solution `C-c C-s` produces + + When writing examples, it is nice to have the hole filled in with + a normalised version of the solution. Calling `C-c C-s` on + + ```agda + _ : reverse (0 ∷ 1 ∷ []) ≡ ? + _ = refl + ``` + + used to yield the non informative `reverse (0 ∷ 1 ∷ [])` when we would + have hopped to get `1 ∷ 0 ∷ []` instead. We can now control finely the + degree to which the solution is simplified. + +* Changed feature: Solving the hole at point + + Calling `C-c C-s` inside a specific goal does not solve *all* the goals + already instantiated internally anymore: it only solves the one at hand + (if possible). + +* New bindings: All the blackboard bold letters are now available + [Pull Request [#2305](https://github.com/agda/agda/pull/2305)] + + The Agda input method only bound a handful of the blackboard bold letters + but programmers were actually using more than these. They are now all + available: lowercase and uppercase. Some previous bindings had to be + modified for consistency. The naming scheme is as follows: + + * `\bx` for lowercase blackboard bold + * `\bX` for uppercase blackboard bold + * `\bGx` for lowercase greek blackboard bold (similar to `\Gx` for + greeks) + * `\bGX` for uppercase greek blackboard bold (similar to `\GX` for + uppercase greeks) + +* Replaced binding for go back + + Use `M-,` (instead of `M-*`) for go back in Emacs ≥ 25.1 (and + continue using `M-*` with previous versions of Emacs). + +Compiler backends +----------------- + +* JS compiler backend + + The JavaScript backend has been (partially) rewritten. The + JavaScript backend now supports most Agda features, notably + copatterns can now be compiled to JavaScript. Furthermore, the + existing optimizations from the other backends now apply to the + JavaScript backend as well. + +* GHC, JS and UHC compiler backends + + Added new primitives to built-in floats + [Issues [#2194](https://github.com/agda/agda/issues/2194) and + [#2200](https://github.com/agda/agda/issues/2200)]: + + ```agda + primFloatNegate : Float → Float + primCos : Float → Float + primTan : Float → Float + primASin : Float → Float + primACos : Float → Float + primATan : Float → Float + primATan2 : Float → Float → Float + ``` + +LaTeX backend +------------- + +* Code blocks are now (by default) surrounded by vertical space. + [Issue [#2198](https://github.com/agda/agda/issues/2198)] + + Use `\AgdaNoSpaceAroundCode{}` to avoid this vertical space, and + `\AgdaSpaceAroundCode{}` to reenable it. + + Note that, if `\AgdaNoSpaceAroundCode{}` is used, then empty lines + before or after a code block will not necessarily lead to empty + lines in the generated document. However, empty lines *inside* the + code block do (by default) lead to empty lines in the output. + + If you prefer the previous behaviour, then you can use the `agda.sty` + file that came with the previous version of Agda. + +* `\AgdaHide{...}` now eats trailing spaces (using `\ignorespaces`). + +* New environments: `AgdaAlign`, `AgdaSuppressSpace` and + `AgdaMultiCode`. + + Sometimes one might want to break up a code block into multiple + pieces, but keep code in different blocks aligned with respect to + each other. Then one can use the `AgdaAlign` environment. Example + usage: + ```latex + \begin{AgdaAlign} + \begin{code} + code + code (more code) + \end{code} + Explanation... + \begin{code} + aligned with "code" + code (aligned with (more code)) + \end{code} + \end{AgdaAlign} + ``` + Note that `AgdaAlign` environments should not be nested. + + Sometimes one might also want to hide code in the middle of a code + block. This can be accomplished in the following way: + ```latex + \begin{AgdaAlign} + \begin{code} + visible + \end{code} + \AgdaHide{ + \begin{code} + hidden + \end{code}} + \begin{code} + visible + \end{code} + \end{AgdaAlign} + ``` + However, the result may be ugly: extra space is perhaps inserted + around the code blocks. + + The `AgdaSuppressSpace` environment ensures that extra space is only + inserted before the first code block, and after the last one (but + not if `\AgdaNoSpaceAroundCode{}` is used). + + The environment takes one argument, the number of wrapped code + blocks (excluding hidden ones). Example usage: + ```latex + \begin{AgdaAlign} + \begin{code} + code + more code + \end{code} + Explanation... + \begin{AgdaSuppressSpace}{2} + \begin{code} + aligned with "code" + aligned with "more code" + \end{code} + \AgdaHide{ + \begin{code} + hidden code + \end{code}} + \begin{code} + also aligned with "more code" + \end{code} + \end{AgdaSuppressSpace} + \end{AgdaAlign} + ``` + + Note that `AgdaSuppressSpace` environments should not be nested. + + There is also a combined environment, `AgdaMultiCode`, that combines + the effects of `AgdaAlign` and `AgdaSuppressSpace`. + +Tools +----- + +### agda-ghc-names + +The `agda-ghc-names` now has its own repository at + + https://github.com/agda/agda-ghc-names + +and is no longer distributed with Agda. diff --git a/doc/release-notes/2.5.3.md b/doc/release-notes/2.5.3.md new file mode 100644 --- /dev/null +++ b/doc/release-notes/2.5.3.md @@ -0,0 +1,822 @@ +Release notes for Agda version 2.5.3 +==================================== + +Installation and infrastructure +------------------------------- + +* Added support for GHC 8.0.2 and 8.2.1. + +* Removed support for GHC 7.6.3. + +* Markdown support for literate Agda + \[PR [#2357](https://github.com/agda/agda/pull/2357)]. + + Files ending in `.lagda.md` will be parsed as literate Markdown files. + + + Code blocks start with ```` ``` ```` or ```` ```agda ```` in its own line, and end with + ```` ``` ````, also in its own line. + + Code blocks which should be type-checked by Agda but should not be visible + when the Markdown is rendered may be enclosed in HTML comment delimiters + (``). + + Code blocks which should be ignored by Agda, but rendered in the final + document may be indented by four spaces. + + Note that inline code fragments are not supported due to the difficulty of + interpreting their indentation level with respect to the rest of the file. + +Language +-------- + +### Pattern matching + +* Dot patterns. + + The dot in front of an inaccessible pattern can now be skipped if the + pattern consists entirely of constructors or literals. For example: + ```agda + open import Agda.Builtin.Bool + + data D : Bool → Set where + c : D true + + f : (x : Bool) → D x → Bool + f true c = true + + ``` + Before this change, you had to write `f .true c = true`. + +* With-clause patterns can be replaced by _ + [Issue [#2363](https://github.com/agda/agda/issues/2363)]. + Example: + ```agda + test : Nat → Set + test zero with zero + test _ | _ = Nat + test (suc x) with zero + test _ | _ = Nat + ``` + We do not have to spell out the pattern of the parent clause + (`zero` / `suc x`) in the with-clause if we do not need the + pattern variables. Note that `x` is not in scope in the + with-clause! + + A more elaborate example, which cannot be reduced to + an ellipsis `...`: + ```agda + record R : Set where + coinductive -- disallow matching + field f : Bool + n : Nat + + data P (r : R) : Nat → Set where + fTrue : R.f r ≡ true → P r zero + nSuc : P r (suc (R.n r)) + + data Q : (b : Bool) (n : Nat) → Set where + true! : Q true zero + suc! : ∀{b n} → Q b (suc n) + + test : (r : R) {n : Nat} (p : P r n) → Q (R.f r) n + test r nSuc = suc! + test r (fTrue p) with R.f r + test _ (fTrue ()) | false + test _ _ | true = true! -- underscore instead of (isTrue _) + ``` + +* Pattern matching lambdas (also known as extended lambdas) can now be + nullary, mirroring the behaviour for ordinary function definitions. + [Issue [#2671](https://github.com/agda/agda/issues/2671)] + + This is useful for case splitting on the result inside an + expression: given + ```agda + record _×_ (A B : Set) : Set where + field + π₁ : A + π₂ : B + open _×_ + ``` + one may case split on the result (C-c C-c RET) in a hole + ```agda + λ { → {!!}} + ``` + of type A × B to produce + ```agda + λ { .π₁ → {!!} ; .π₂ → {!!}} + ``` + +* Records with a field of an empty type are now recognized as empty by Agda. + In particular, they can be matched against with an absurd pattern (). + For example: + ```agda + data ⊥ : Set where + + record Empty : Set where + field absurdity : ⊥ + + magic : Empty → ⊥ + magic () + ``` + +* Injective pragmas. + + Injective pragmas can be used to mark a definition as injective for the + pattern matching unifier. This can be used as a version of + `--injective-type-constructors` that only applies to specific datatypes. + For example: + ```agda + open import Agda.Builtin.Equality + data Fin : Nat → Set where + zero : {n : Nat} → Fin (suc n) + suc : {n : Nat} → Fin n → Fin (suc n) + + {-# INJECTIVE Fin #-} + + Fin-injective : {m n : Nat} → Fin m ≡ Fin n → m ≡ n + Fin-injective refl = refl + ``` + Aside from datatypes, this pragma can also be used to mark other definitions + as being injective (for example postulates). + +* Metavariables can no longer be instantiated during case splitting. This means + Agda will refuse to split instead of taking the first constructor it finds. + For example: + ```agda + open import Agda.Builtin.Nat + + data Vec (A : Set) : Nat → Set where + nil : Vec A 0 + cons : {n : Nat} → A → Vec A n → Vec A (suc n) + + foo : Vec Nat _ → Nat + foo x = {!x!} + ``` + In Agda 2.5.2, case splitting on `x` produced the single clause + `foo nil = {!!}`, but now Agda refuses to split. + +### Reflection + +* New TC primitive: `debugPrint`. + + ```agda + debugPrint : String → Nat → List ErrorPart → TC ⊤ + ``` + + This maps to the internal function `reportSDoc`. Debug output is enabled with + the `-v` flag at the command line, or in an `OPTIONS` pragma. For instance, + giving `-v a.b.c:10` enables printing from `debugPrint "a.b.c.d" 10 msg`. In the + Emacs mode, debug output ends up in the `*Agda debug*` buffer. + +### Built-ins + +* BUILTIN REFL is now superfluous, subsumed by BUILTIN EQUALITY + [Issue [#2389](https://github.com/agda/agda/issues/2389)]. + +* BUILTIN EQUALITY is now more liberal + [Issue [#2386](https://github.com/agda/agda/issues/2386)]. + It accepts, among others, the following new definitions of equality: + ```agda + -- Non-universe polymorphic: + data _≡_ {A : Set} (x : A) : A → Set where + refl : x ≡ x + + -- ... with explicit argument to refl; + data _≡_ {A : Set} : (x y : A) → Set where + refl : {x : A} → x ≡ x + + -- ... even visible + data _≡_ {A : Set} : (x y : A) → Set where + refl : (x : A) → x ≡ x + + -- Equality in a different universe than domain: + -- (also with explicit argument to refl) + data _≡_ {a} {A : Set a} (x : A) : A → Set where + refl : x ≡ x + + ``` + The standard definition is still: + ```agda + -- Equality in same universe as domain: + data _≡_ {a} {A : Set a} (x : A) : A → Set a where + refl : x ≡ x + ``` + +### Miscellaneous + +* Rule change for omitted top-level module headers. + [Issue [#1077](https://github.com/agda/agda/issues/1077)] + + If your file is named `Bla.agda`, then the following content + is rejected. + ```agda + foo = Set + module Bla where + bar = Set + ``` + Before the fix of this issue, Agda would add the missing module + header `module Bla where` at the top of the file. + However, in this particular case it is more likely the user + put the declaration `foo = Set` before the module start in error. + Now you get the error + ``` + Illegal declaration(s) before top-level module + ``` + if the following conditions are met: + + 1. There is at least one non-import declaration or non-toplevel pragma + before the start of the first module. + + 2. The module has the same name as the file. + + 3. The module is the only module at this level + (may have submodules, of course). + + If you should see this error, insert a top-level module + before the illegal declarations, or move them inside the + existing module. + +Emacs mode +---------- + +* New warnings: + + - Unreachable clauses give rise to a simple warning. They are + highlighted in gray. + + - Incomplete patterns are non-fatal warnings: it is possible + to keep interacting with the file (the reduction will simply + be stuck on arguments not matching any pattern). + The definition with incomplete patterns are highlighted in + wheat. + +* Clauses which do not hold definitionally are now highlighted in white smoke. + +* Fewer commands have the side effect that the buffer is saved. + +* Aborting commands. + + Now one can (try to) abort an Agda command by using `C-c C-x C-a` or + a menu entry. The effect is similar to that of restarting Agda (`C-c + C-x C-r`), but some state is preserved, which could mean that it + takes less time to reload the module. + + Warning: If a command is aborted while it is writing data to disk + (for instance `.agdai` files or Haskell files generated by the GHC + backend), then the resulting files may be corrupted. Note also that + external commands (like GHC) are not aborted, and their output may + continue to be sent to the Emacs mode. + +* New bindings for the Agda input method: + + - All the bold digits are now available. The naming scheme is `\Bx` for digit `x`. + + - Typing `\:` you can now get a whole slew of colons. + + (The Agda input method originally only bound the standard unicode colon, + which looks deceptively like the normal colon.) + +* Case splitting now preserves underscores. + [Issue [#819](https://github.com/agda/agda/issues/819)] + ```agda + data ⊥ : Set where + + test : {A B : Set} → A → ⊥ → B + test _ x = {! x !} + ``` + Splitting on `x` yields + ```agda + test _ () + ``` + +* Interactively expanding ellipsis. + [Issue [#2589](https://github.com/agda/agda/issues/2589)] + An ellipsis in a with-clause can be expanded by splitting on "variable" "." (dot). + ```agda + test0 : Nat → Nat + test0 x with zero + ... | q = {! . !} -- C-c C-c + ``` + Splitting on dot here yields: + ```agda + test0 x | q = ? + ``` + +* New command to check an expression against the type of the hole + it is in and see what it elaborates to. + [Issue [#2700](https://github.com/agda/agda/issues/2700)] + This is useful to determine e.g. what solution typeclass resolution yields. + The command is bound to `C-c C-;` and respects the `C-u` modifier. + + ```agda + record Pointed (A : Set) : Set where + field point : A + + it : ∀ {A : Set} {{x : A}} → A + it {{x}} = x + + instance _ = record { point = 3 - 4 } + + _ : Pointed Nat + _ = {! it !} -- C-u C-u C-c C-; + ``` + yields + ```agda + Goal: Pointed Nat + Elaborates to: record { point = 0 } + ``` + +* If `agda2-give` is called with a prefix, then giving is forced, + i.e., the safety checks are skipped, + including positivity, termination, and double type-checking. + [Issue [#2730](https://github.com/agda/agda/issues/2730)] + + Invoke forced giving with key sequence `C-u C-c C-SPC`. + + +Library management +------------------ + +* The `name` field in an `.agda-lib` file is now optional. + [Issue [#2708](https://github.com/agda/agda/issues/2708)] + + This feature is convenient if you just want to specify the dependencies + and include pathes for your local project in an `.agda-lib` file. + + Naturally, libraries without names cannot be depended on. + + +Compiler backends +----------------- + +* Unified compiler pragmas + + The compiler pragmas (`COMPILED`, `COMPILED_DATA`, etc.) have been unified across + backends into two new pragmas: + + ``` + {-# COMPILE #-} + {-# FOREIGN #-} + ``` + + The old pragmas still work, but will emit a warning if used. They will be + removed completely in Agda 2.6. + + The translation of old pragmas into new ones is as follows: + + Old | New + --- | --- + `{-# COMPILED f e #-}` | `{-# COMPILE GHC f = e #-}` + `{-# COMPILED_TYPE A T #-}` | `{-# COMPILE GHC A = type T #-}` + `{-# COMPILED_DATA A D C1 .. CN #-}` | `{-# COMPILE GHC A = data D (C1 \| .. \| CN) #-}` + `{-# COMPILED_DECLARE_DATA #-}` | obsolete, removed + `{-# COMPILED_EXPORT f g #-}` | `{-# COMPILE GHC f as g #-}` + `{-# IMPORT M #-}` | `{-# FOREIGN GHC import qualified M #-}` + `{-# HASKELL code #-}` | `{-# FOREIGN GHC code #-}` + `{-# COMPILED_UHC f e #-}` | `{-# COMPILE UHC f = e #-}` + `{-# COMPILED_DATA_UHC A D C1 .. CN #-}` | `{-# COMPILE UHC A = data D (C1 \| .. \| CN) #-}` + `{-# IMPORT_UHC M #-}` | `{-# FOREIGN UHC __IMPORT__ M #-}` + `{-# COMPILED_JS f e #-}` | `{-# COMPILE JS f = e #-}` + +* GHC Haskell backend + + The COMPILED pragma (and the corresponding COMPILE GHC pragma) is now also + allowed for functions. This makes it possible to have both an Agda + implementation and a native Haskell runtime implementation. + + The GHC file header pragmas `LANGUAGE`, `OPTIONS_GHC`, and `INCLUDE` + inside a `FOREIGN GHC` pragma are recognized and printed correctly + at the top of the generated Haskell file. + [Issue [#2712](https://github.com/agda/agda/issues/2712)] + + +* UHC compiler backend + + The UHC backend has been moved to its own repository + [https://github.com/agda/agda-uhc] and is no longer part of the Agda + distribution. + +* Haskell imports are no longer transitively inherited from imported modules. + + The (now deprecated) IMPORT and IMPORT_UHC pragmas no longer cause import + statements in modules importing the module containing the pragma. + + The same is true for the corresponding FOREIGN pragmas. + +* Support for stand-alone backends. + + There is a new API in `Agda.Compiler.Backend` for creating stand-alone + backends using Agda as a library. This allows prospective backend writers to + experiment with new backends without having to change the Agda code base. + +HTML backend +------------ + +* Anchors for identifiers (excluding bound variables) are now the + identifiers themselves rather than just the file position + [Issue [#2604](https://github.com/agda/agda/issues/2604)]. + + Symbolic anchors look like + ```html + + + ``` + while other anchors just give the character position in the file: + ```html + + ``` + + Top-level module names do not get a symbolic anchor, since the position of + a top-level module is defined to be the beginning of the file. + + Example: + + ```agda + module Issue2604 where -- Character position anchor + + test1 : Set₁ -- Issue2604.html#test1 + test1 = bla + where + bla = Set -- Character position anchor + + test2 : Set₁ -- Issue2604.html#test2 + test2 = bla + where + bla = Set -- Character position anchor + + test3 : Set₁ -- Issue2604.html#test3 + test3 = bla + module M where -- Issue2604.html#M + bla = Set -- Issue2604.html#M.bla + + module NamedModule where -- Issue2604.html#NamedModule + test4 : Set₁ -- Issue2604.html#NamedModule.test4 + test4 = M.bla + + module _ where -- Character position anchor + test5 : Set₁ -- Character position anchor + test5 = M.bla + ``` + +* Some generated HTML files now have different file names [Issue + [#2725](https://github.com/agda/agda/issues/2725)]. + + Agda now uses an encoding that amounts to first converting the + module names to UTF-8, and then percent-encoding the resulting + bytes. For instance, HTML for the module `Σ` is placed in + `%CE%A3.html`. + +LaTeX backend +------------- + +* The LaTeX backend now handles indentation in a different way [Issue + [#1832](https://github.com/agda/agda/issues/1832)]. + + A constraint on the indentation of the first token *t* on a line is + determined as follows: + * Let *T* be the set containing every previous token (in any code + block) that is either the initial token on its line or preceded by + at least one whitespace character. + * Let *S* be the set containing all tokens in *T* that are not + *shadowed* by other tokens in *T*. A token *t₁* is shadowed by + *t₂* if *t₂* is further down than *t₁* and does not start to the + right of *t₁*. + * Let *L* be the set containing all tokens in *S* that start to the + left of *t*, and *E* be the set containing all tokens in *S* that + start in the same column as *t*. + * The constraint is that *t* must be indented further than every + token in *L*, and aligned with every token in *E*. + + Note that if any token in *L* or *E* belongs to a previous code + block, then the constraint may not be satisfied unless (say) the + `AgdaAlign` environment is used in an appropriate way. + + If custom settings are used, for instance if `\AgdaIndent` is + redefined, then the constraint discussed above may not be satisfied. + (Note that the meaning of the `\AgdaIndent` command's argument has + changed, and that the command is now used in a different way in the + generated LaTeX files.) + + Examples: + * Here `C` is indented further than `B`: + + ```agda + postulate + A B + C : Set + ``` + + * Here `C` is not (necessarily) indented further than `B`, because + `X` shadows `B`: + + ```agda + postulate + A B : Set + X + C : Set + ``` + + The new rule is inspired by, but not identical to, the one used by + lhs2TeX's poly mode (see Section 8.4 of the [manual for lhs2TeX + version 1.17](https://www.andres-loeh.de/lhs2tex/Guide2-1.17.pdf)). + +* Some spacing issues + [[#2353](https://github.com/agda/agda/issues/2353), + [#2441](https://github.com/agda/agda/issues/2441), + [#2733](https://github.com/agda/agda/issues/2733), + [#2740](https://github.com/agda/agda/issues/2740)] have been fixed. + +* The user can now control the typesetting of (certain) individual tokens + by redefining the `\AgdaFormat` command. Example: + ```latex + \usepackage{ifthen} + + % Insert extra space before some tokens. + \DeclareRobustCommand{\AgdaFormat}[2]{% + \ifthenelse{ + \equal{#1}{≡⟨} \OR + \equal{#1}{≡⟨⟩} \OR + \equal{#1}{∎} + }{\ }{}#2} + ``` + Note the use of `\DeclareRobustCommand`. The first argument to + `\AgdaFormat` is the token, and the second argument the thing to + be typeset. + +* One can now instruct the agda package not to select any fonts. + + If the `nofontsetup` option is used, then some font packages are + loaded, but specific fonts are not selected: + ```latex + \usepackage[nofontsetup]{agda} + ``` + +* The height of empty lines is now configurable + [[#2734](https://github.com/agda/agda/issues/2734)]. + + The height is controlled by the length `\AgdaEmptySkip`, which by + default is `\baselineskip`. + +* The alignment feature regards the string `+̲`, containing `+` and a + combining character, as having length two. However, it seems more + reasonable to treat it as having length one, as it occupies a single + column, if displayed "properly" using a monospace font. The new flag + `--count-clusters` is an attempt at fixing this. When this flag is + enabled the backend counts ["extended grapheme + clusters"](http://www.unicode.org/reports/tr29/#Grapheme_Cluster_Boundaries) + rather than code points. + + Note that this fix is not perfect: a single extended grapheme + cluster might be displayed in different ways by different programs, + and might, in some cases, occupy more than one column. Here are some + examples of extended grapheme clusters, all of which are treated as + a single character by the alignment algorithm: + ``` + │ │ + │+̲│ + │Ö̂│ + │நி│ + │ᄀힰᇹ│ + │ᄀᄀᄀᄀᄀᄀힰᇹᇹᇹᇹᇹᇹ│ + │ │ + ``` + + Note also that the layout machinery does not count extended grapheme + clusters, but code points. The following code is syntactically + correct, but if `--count-clusters` is used, then the LaTeX backend + does not align the two `field` keywords: + ```agda + record +̲ : Set₁ where field A : Set + field B : Set + ``` + + The `--count-clusters` flag is not enabled in all builds of Agda, + because the implementation depends on the + [ICU](http://site.icu-project.org) library, the installation of + which could cause extra trouble for some users. The presence of this + flag is controlled by the Cabal flag `enable-cluster-counting`. + +* A faster variant of the LaTeX backend: QuickLaTeX. + + When this variant of the backend is used the top-level module is not + type-checked, only scope-checked. This implies that some + highlighting information is not available. For instance, overloaded + constructors are not resolved. + + QuickLaTeX can be invoked from the Emacs mode, or using `agda + --latex --only-scope-checking`. If the module has already been + type-checked successfully, then this information is reused; in this + case QuickLaTeX behaves like the regular LaTeX backend. + + The `--only-scope-checking` flag can also be used independently, but + it is perhaps unclear what purpose that would serve. (The flag can + currently not be combined with `--html`, `--dependency-graph` or + `--vim`.) The flag is not allowed in safe mode. + +Pragmas and options +------------------- + +* The `--safe` option is now a valid pragma. + + This makes it possible to declare a module as being part of the safe + subset of the language by stating `{-# OPTIONS --safe #-}` at the top + of the corresponding file. Incompatibilities between the `--safe` option + and other options or language constructs are non-fatal errors. + +* The `--no-main` option is now a valid pragma. + + One can now suppress the compiler warning about a missing main function by + putting + ```agda + {-# OPTIONS --no-main #-} + ``` + on top of the file. + +* New command-line option and pragma `--warning=MODE` (or `-W MODE`) for + setting the warning mode. Current options are + - `warn` for displaying warnings (default) + - `error` for turning warnings into errors + - `ignore` for not displaying warnings + +List of fixed issues +-------------------- + +For 2.5.3, the following issues have been fixed +(see [bug tracker](https://github.com/agda/agda/issues)): + + - [#142](https://github.com/agda/agda/issues/142): Inherited dot patterns in with functions are not checked + - [#623](https://github.com/agda/agda/issues/623): Error message points to importing module rather than imported module + - [#657](https://github.com/agda/agda/issues/657): Yet another display form problem + - [#668](https://github.com/agda/agda/issues/668): Ability to stop, or restart, typechecking somehow + - [#705](https://github.com/agda/agda/issues/705): confusing error message for ambiguous datatype module name + - [#719](https://github.com/agda/agda/issues/719): Error message for duplicate module definition points to external module instead of internal module + - [#776](https://github.com/agda/agda/issues/776): Unsolvable constraints should give error + - [#819](https://github.com/agda/agda/issues/819): Case-splitting doesn't preserve underscores + - [#883](https://github.com/agda/agda/issues/883): Rewrite loses type information + - [#899](https://github.com/agda/agda/issues/899): Instance search fails if there are several definitionally equal values in scope + - [#1077](https://github.com/agda/agda/issues/1077): problem with module syntax, with parametric module import + - [#1126](https://github.com/agda/agda/issues/1126): Port optimizations from the Epic backend + - [#1175](https://github.com/agda/agda/issues/1175): Internal Error in Auto + - [#1544](https://github.com/agda/agda/issues/1544): Positivity polymorphism needed for compositional positivity analysis + - [#1611](https://github.com/agda/agda/issues/1611): Interactive splitting instantiates meta + - [#1664](https://github.com/agda/agda/issues/1664): Add Reflection primitives to expose precedence and fixity + - [#1817](https://github.com/agda/agda/issues/1817): Solvable size constraints reported as unsolvable + - [#1832](https://github.com/agda/agda/issues/1832): Insufficient indentation in LaTeX-rendered Agda code + - [#1834](https://github.com/agda/agda/issues/1834): Copattern matching: order of clauses should not matter here + - [#1886](https://github.com/agda/agda/issues/1886): Second copies of telescopes not checked? + - [#1899](https://github.com/agda/agda/issues/1899): Positivity checker does not treat datatypes and record types in the same way + - [#1975](https://github.com/agda/agda/issues/1975): Type-incorrect instantiated overloaded constructor accepted in pattern + - [#1976](https://github.com/agda/agda/issues/1976): Type-incorrect instantiated projection accepted in pattern + - [#2035](https://github.com/agda/agda/issues/2035): Matching on string causes solver to fail with internal error + - [#2146](https://github.com/agda/agda/issues/2146): Unicode syntax for instance arguments + - [#2217](https://github.com/agda/agda/issues/2217): Abort Agda without losing state + - [#2229](https://github.com/agda/agda/issues/2229): Absence or presence of top-level module header affects scope + - [#2253](https://github.com/agda/agda/issues/2253): Wrong scope error for abstract constructors + - [#2261](https://github.com/agda/agda/issues/2261): Internal error in Auto/CaseSplit.hs:284 + - [#2270](https://github.com/agda/agda/issues/2270): Printer does not use sections. + - [#2329](https://github.com/agda/agda/issues/2329): Size solver does not use type `Size< i` to gain the necessary information + - [#2354](https://github.com/agda/agda/issues/2354): Interaction between instance search, size solver, and ordinary constraint solver. + - [#2355](https://github.com/agda/agda/issues/2355): Literate Agda parser does not recognize TeX comments + - [#2360](https://github.com/agda/agda/issues/2360): With clause stripping chokes on ambiguous projection + - [#2362](https://github.com/agda/agda/issues/2362): Printing of parent patterns when with-clause does not match + - [#2363](https://github.com/agda/agda/issues/2363): Allow underscore in with-clause patterns + - [#2366](https://github.com/agda/agda/issues/2366): With-clause patterns renamed in error message + - [#2368](https://github.com/agda/agda/issues/2368): Internal error after refining a tactic @ MetaVars.hs:267 + - [#2371](https://github.com/agda/agda/issues/2371): Shadowed module parameter crashes interaction + - [#2372](https://github.com/agda/agda/issues/2372): problems when instances are declared with inferred types + - [#2374](https://github.com/agda/agda/issues/2374): Ambiguous projection pattern could be disambiguated by visibility + - [#2376](https://github.com/agda/agda/issues/2376): Termination checking interacts badly with eta-contraction + - [#2377](https://github.com/agda/agda/issues/2377): open public is useless before module header + - [#2381](https://github.com/agda/agda/issues/2381): Search (`C-c C-z`) panics on pattern synonyms + - [#2386](https://github.com/agda/agda/issues/2386): Relax requirements of BUILTIN EQUALITY + - [#2389](https://github.com/agda/agda/issues/2389): BUILTIN REFL not needed + - [#2400](https://github.com/agda/agda/issues/2400): LaTeX backend error on LaTeX comments + - [#2402](https://github.com/agda/agda/issues/2402): Parameters not dropped when reporting incomplete patterns + - [#2403](https://github.com/agda/agda/issues/2403): Termination checker should reduce arguments in structural order check + - [#2405](https://github.com/agda/agda/issues/2405): instance search failing in parameterized module + - [#2408](https://github.com/agda/agda/issues/2408): DLub sorts are not serialized + - [#2412](https://github.com/agda/agda/issues/2412): Problem with checking with sized types + - [#2413](https://github.com/agda/agda/issues/2413): Agda crashes on x@y pattern + - [#2415](https://github.com/agda/agda/issues/2415): Size solver reports "inconsistent upper bound" even though there is a solution + - [#2416](https://github.com/agda/agda/issues/2416): Cannot give size as computed by solver + - [#2422](https://github.com/agda/agda/issues/2422): Overloaded inherited projections don't resolve + - [#2423](https://github.com/agda/agda/issues/2423): Inherited projection on lhs + - [#2426](https://github.com/agda/agda/issues/2426): On just warning about missing cases + - [#2429](https://github.com/agda/agda/issues/2429): Irrelevant lambda should be accepted when relevant lambda is expected + - [#2430](https://github.com/agda/agda/issues/2430): Another regression related to parameter refinement? + - [#2433](https://github.com/agda/agda/issues/2433): rebindLocalRewriteRules re-adds global rewrite rules + - [#2434](https://github.com/agda/agda/issues/2434): Exact split analysis is too strict when matching on eta record constructor + - [#2441](https://github.com/agda/agda/issues/2441): Incorrect alignement in latex using the new ACM format + - [#2444](https://github.com/agda/agda/issues/2444): Generalising compiler pragmas + - [#2445](https://github.com/agda/agda/issues/2445): The LaTeX backend is slow + - [#2447](https://github.com/agda/agda/issues/2447): Cache loaded interfaces even if a type error is encountered + - [#2449](https://github.com/agda/agda/issues/2449): Agda depends on additional C library icu + - [#2451](https://github.com/agda/agda/issues/2451): Agda panics when attempting to rewrite a typeclass Eq + - [#2456](https://github.com/agda/agda/issues/2456): Internal error when postulating instance + - [#2458](https://github.com/agda/agda/issues/2458): Regression: Agda-2.5.3 loops where Agda-2.5.2 passes + - [#2462](https://github.com/agda/agda/issues/2462): Overloaded postfix projection does not resolve + - [#2464](https://github.com/agda/agda/issues/2464): Eta contraction for irrelevant functions breaks subject reduction + - [#2466](https://github.com/agda/agda/issues/2466): Case split to make hidden variable visible does not work + - [#2467](https://github.com/agda/agda/issues/2467): REWRITE without BUILTIN REWRITE crashes + - [#2469](https://github.com/agda/agda/issues/2469): "Partial" pattern match causes segfault at runtime + - [#2472](https://github.com/agda/agda/issues/2472): Regression related to the auto command + - [#2477](https://github.com/agda/agda/issues/2477): Sized data type analysis brittle, does not reduce size + - [#2478](https://github.com/agda/agda/issues/2478): Multiply defined labels on the user manual (pdf) + - [#2479](https://github.com/agda/agda/issues/2479): "Occurs check" error in generated Haskell code + - [#2480](https://github.com/agda/agda/issues/2480): Agda accepts incorrect (?) code, subject reduction broken + - [#2482](https://github.com/agda/agda/issues/2482): Wrong counting of data parameters with new-style mutual blocks + - [#2483](https://github.com/agda/agda/issues/2483): Files are sometimes truncated to a size of 201 bytes + - [#2486](https://github.com/agda/agda/issues/2486): Imports via FOREIGN are not transitively inherited anymore + - [#2488](https://github.com/agda/agda/issues/2488): Instance search inhibits holes for instance fields + - [#2493](https://github.com/agda/agda/issues/2493): Regression: Agda seems to loop when expression is given + - [#2494](https://github.com/agda/agda/issues/2494): Instance fields sometimes have incorrect goal types + - [#2495](https://github.com/agda/agda/issues/2495): Regression: termination checker of Agda-2.5.3 seemingly loops where Agda-2.5.2 passes + - [#2500](https://github.com/agda/agda/issues/2500): Adding fields to a record can cause Agda to reject previous definitions + - [#2510](https://github.com/agda/agda/issues/2510): Wrong error with --no-pattern-matching + - [#2517](https://github.com/agda/agda/issues/2517): "Not a variable error" + - [#2518](https://github.com/agda/agda/issues/2518): CopatternReductions in TreeLess + - [#2523](https://github.com/agda/agda/issues/2523): The documentation of `--without-K` is outdated + - [#2529](https://github.com/agda/agda/issues/2529): Unable to install Agda on Windows. + - [#2537](https://github.com/agda/agda/issues/2537): case splitting with 'with' creates {_} instead of replicating the arguments it found. + - [#2538](https://github.com/agda/agda/issues/2538): Internal error when parsing as-pattern + - [#2543](https://github.com/agda/agda/issues/2543): Case splitting with ellipsis produces spurious parentheses + - [#2545](https://github.com/agda/agda/issues/2545): Race condition in api tests + - [#2549](https://github.com/agda/agda/issues/2549): Rewrite rule for higher path constructor does not fire + - [#2550](https://github.com/agda/agda/issues/2550): Internal error in Agda.TypeChecking.Substitute + - [#2552](https://github.com/agda/agda/issues/2552): Let bindings in module telescopes crash Agda.Interaction.BasicOps + - [#2553](https://github.com/agda/agda/issues/2553): Internal error in Agda.TypeChecking.CheckInternal + - [#2554](https://github.com/agda/agda/issues/2554): More flexible size-assignment in successor style + - [#2555](https://github.com/agda/agda/issues/2555): Why does the positivity checker care about non-recursive occurrences? + - [#2558](https://github.com/agda/agda/issues/2558): Internal error in Warshall Solver + - [#2560](https://github.com/agda/agda/issues/2560): Internal Error in Reduce.Fast + - [#2564](https://github.com/agda/agda/issues/2564): Non-exact-split highlighting makes other highlighting disappear + - [#2568](https://github.com/agda/agda/issues/2568): agda2-infer-type-maybe-toplevel (in hole) does not respect "single-solution" requirement of instance resolution + - [#2571](https://github.com/agda/agda/issues/2571): Record pattern translation does not eta contract + - [#2573](https://github.com/agda/agda/issues/2573): Rewrite rules fail depending on unrelated changes + - [#2574](https://github.com/agda/agda/issues/2574): No link attached to module without toplevel name + - [#2575](https://github.com/agda/agda/issues/2575): Internal error, related to caching + - [#2577](https://github.com/agda/agda/issues/2577): deBruijn fail for higher order instance problem + - [#2578](https://github.com/agda/agda/issues/2578): Catch-all clause face used incorrectly for parent with pattern + - [#2579](https://github.com/agda/agda/issues/2579): Import statements with module instantiation should not trigger an error message + - [#2580](https://github.com/agda/agda/issues/2580): Implicit absurd match is NonVariant, explicit not + - [#2583](https://github.com/agda/agda/issues/2583): Wrong de Bruijn index introduced by absurd pattern + - [#2584](https://github.com/agda/agda/issues/2584): Duplicate warning printing + - [#2585](https://github.com/agda/agda/issues/2585): Definition by copatterns not modulo eta + - [#2586](https://github.com/agda/agda/issues/2586): "λ where" with single absurd clause not parsed + - [#2588](https://github.com/agda/agda/issues/2588): `agda --latex` produces invalid LaTeX when there are block comments + - [#2592](https://github.com/agda/agda/issues/2592): Internal Error in Agda/TypeChecking/Serialise/Instances/Common.hs + - [#2597](https://github.com/agda/agda/issues/2597): Inline record definitions confuse the reflection API + - [#2602](https://github.com/agda/agda/issues/2602): Debug output messes up AgdaInfo buffer + - [#2603](https://github.com/agda/agda/issues/2603): Internal error in MetaVars.hs + - [#2604](https://github.com/agda/agda/issues/2604): Use QNames as anchors in generated HTML + - [#2605](https://github.com/agda/agda/issues/2605): HTML backend generates anchors for whitespace + - [#2606](https://github.com/agda/agda/issues/2606): Check that LHS of a rewrite rule doesn't reduce is too strict + - [#2612](https://github.com/agda/agda/issues/2612): `exact-split` documentation is outdated and incomplete + - [#2613](https://github.com/agda/agda/issues/2613): Parametrised modules, with-abstraction and termination + - [#2620](https://github.com/agda/agda/issues/2620): Internal error in auto. + - [#2621](https://github.com/agda/agda/issues/2621): Case splitting instantiates meta + - [#2626](https://github.com/agda/agda/issues/2626): triggered internal error with sized types in MetaVars module + - [#2629](https://github.com/agda/agda/issues/2629): Exact splitting should not complain about absurd clauses + - [#2631](https://github.com/agda/agda/issues/2631): docs for auto aren't clear on how to use flags/options + - [#2632](https://github.com/agda/agda/issues/2632): some flags to auto dont seem to work in current agda 2.5.2 + - [#2637](https://github.com/agda/agda/issues/2637): Internal error in Agda.TypeChecking.Pretty, possibly related to sized types + - [#2639](https://github.com/agda/agda/issues/2639): Performance regression, possibly related to the size solver + - [#2641](https://github.com/agda/agda/issues/2641): Required instance of FromNat when compiling imported files + - [#2642](https://github.com/agda/agda/issues/2642): Records with duplicate fields + - [#2644](https://github.com/agda/agda/issues/2644): Wrong substitution in expandRecordVar + - [#2645](https://github.com/agda/agda/issues/2645): Agda accepts postulated fields in a record + - [#2646](https://github.com/agda/agda/issues/2646): Only warn if fixities for undefined symbols are given + - [#2649](https://github.com/agda/agda/issues/2649): Empty list of "previous definition" in duplicate definition error + - [#2652](https://github.com/agda/agda/issues/2652): Added a new variant of the colon to the Agda input method + - [#2653](https://github.com/agda/agda/issues/2653): agda-mode: "cannot refine" inside instance argument even though term to be refined typechecks there + - [#2654](https://github.com/agda/agda/issues/2654): Internal error on result splitting without --postfix-projections + - [#2664](https://github.com/agda/agda/issues/2664): Segmentation fault with compiled programs using mutual record + - [#2665](https://github.com/agda/agda/issues/2665): Documentation: Record update syntax in wrong location + - [#2666](https://github.com/agda/agda/issues/2666): Internal error at Agda/Syntax/Abstract/Name.hs:113 + - [#2667](https://github.com/agda/agda/issues/2667): Panic error on unbound variable. + - [#2669](https://github.com/agda/agda/issues/2669): Interaction: incorrect field variable name generation + - [#2671](https://github.com/agda/agda/issues/2671): Feature request: nullary pattern matching lambdas + - [#2679](https://github.com/agda/agda/issues/2679): Internal error at "Typechecking/Abstract.hs:133" and "TypeChecking/Telescope.hs:68" + - [#2682](https://github.com/agda/agda/issues/2682): What are the rules for projections of abstract records? + - [#2684](https://github.com/agda/agda/issues/2684): Bad error message for abstract constructor + - [#2686](https://github.com/agda/agda/issues/2686): Abstract constructors should be ignored when resolving overloading + - [#2690](https://github.com/agda/agda/issues/2690): [regression?] Agda engages in deep search instead of immediately failing + - [#2700](https://github.com/agda/agda/issues/2700): Add a command to check against goal type (and normalise) + - [#2703](https://github.com/agda/agda/issues/2703): Regression: Internal error for underapplied indexed constructor + - [#2705](https://github.com/agda/agda/issues/2705): The GHC backend might diverge in infinite file creation + - [#2708](https://github.com/agda/agda/issues/2708): Why is the `name` field in .agda-lib files mandatory? + - [#2710](https://github.com/agda/agda/issues/2710): Type checker hangs + - [#2712](https://github.com/agda/agda/issues/2712): Compiler Pragma for headers + - [#2714](https://github.com/agda/agda/issues/2714): Option --no-main should be allowed as file-local option + - [#2717](https://github.com/agda/agda/issues/2717): internal error at DisplayForm.hs:197 + - [#2718](https://github.com/agda/agda/issues/2718): Interactive 'give' doesn't insert enough parenthesis + - [#2721](https://github.com/agda/agda/issues/2721): Without-K doesn't prevent heterogeneous conflict between literals + - [#2723](https://github.com/agda/agda/issues/2723): Unreachable clauses in definition by copattern matching trip clause compiler + - [#2725](https://github.com/agda/agda/issues/2725): File names for generated HTML files + - [#2726](https://github.com/agda/agda/issues/2726): Old regression related to with + - [#2727](https://github.com/agda/agda/issues/2727): Internal errors related to rewrite + - [#2729](https://github.com/agda/agda/issues/2729): Regression: case splitting uses variable name variants instead of the unused original names + - [#2730](https://github.com/agda/agda/issues/2730): Command to give in spite of termination errors + - [#2731](https://github.com/agda/agda/issues/2731): Agda fails to build with happy 1.19.6 + - [#2733](https://github.com/agda/agda/issues/2733): Avoid some uses of \AgdaIndent? + - [#2734](https://github.com/agda/agda/issues/2734): Make height of empty lines configurable + - [#2736](https://github.com/agda/agda/issues/2736): Segfault using Alex 3.2.2 and cpphs + - [#2740](https://github.com/agda/agda/issues/2740): Indenting every line of code should be a no-op diff --git a/doc/release-notes/2.5.4.1.md b/doc/release-notes/2.5.4.1.md new file mode 100644 --- /dev/null +++ b/doc/release-notes/2.5.4.1.md @@ -0,0 +1,16 @@ +Release notes for Agda version 2.5.4.1 +====================================== + +Installation and infrastructure +------------------------------- + +* Generated the interface file for the `Sigma.agda` built-in when + installing Agda + [Issue [#3128](https://github.com/agda/agda/issues/3128)]. + +Emacs mode +---------- + +* Light highlighting is no longer applied continuously, but only when + the file is saved [Issue + [#3119](https://github.com/agda/agda/issues/3119)]. diff --git a/doc/release-notes/2.5.4.2.md b/doc/release-notes/2.5.4.2.md new file mode 100644 --- /dev/null +++ b/doc/release-notes/2.5.4.2.md @@ -0,0 +1,23 @@ +Release notes for Agda version 2.5.4.2 +====================================== + +Installation and infrastructure +------------------------------- + +* Fixed installation with some old versions of `cabal-install` + [Issue [#3225](https://github.com/agda/agda/issues/3225)]. + +* Using `cpp` instead of `cpphs` as the default preprocessor + [Issue [#3223](https://github.com/agda/agda/issues/3223)]. + +* Added support for GHC 8.4.4. + +Other closed issues +-------------------- + +For 2.5.4.2 the following issues have also been closed +(see [bug tracker](https://github.com/agda/agda/issues)): + + - [#3177](https://github.com/agda/agda/issues/3177): Slow typechecking with unsolved instance constraint + - [#3199](https://github.com/agda/agda/issues/3199): Panics when serialising absolute paths + - [#3312](https://github.com/agda/agda/issues/3312): Crash in Substitute.hs diff --git a/doc/release-notes/2.5.4.md b/doc/release-notes/2.5.4.md new file mode 100644 --- /dev/null +++ b/doc/release-notes/2.5.4.md @@ -0,0 +1,859 @@ +Release notes for Agda version 2.5.4 +==================================== + +Installation and infrastructure +------------------------------- + +* Added support for GHC 8.2.2 and GHC 8.4.3. + + Note that GHC 8.4.* requires `cabal-install` ≥ 2.2.0.0. + +* Removed support for GHC 7.8.4. + +* Included user manual in PDF format in `doc/user-manual.pdf`. + +Language +-------- + +* Call-by-need reduction. + + Compile-time weak-head evaluation is now call-by-need, but each weak-head + reduction has a local heap, so sharing is not maintained between different + reductions. + + The reduction machine has been rewritten from scratch and should be faster + than the old one in all cases, even those not exploiting laziness. + +* Compile-time inlining. + + Simple definitions (that don't do any pattern matching) marked as INLINE are + now also inlined at compile time, whereas before they were only inlined by + the compiler backends. Inlining only triggers in function bodies and not in + type signatures, to preserve goal types as far as possible. + +* Automatic inlining. + + Definitions satisfying the following criteria are now automatically inlined + (can be disabled using the new NOINLINE pragma): + + - No pattern matching. + - Uses each argument at most once. + - Does not use all its arguments. + + Automatic inlining can be turned off using the flag `--no-auto-inline`. This + can be useful when debugging tactics that may be affected by whether or not + a particular definition is being inlined. + +### Syntax + +* Do-notation. + + There is now builtin do-notation syntax. This means that `do` is a reserved + keyword and cannot be used as an identifier. + + Do-blocks support lets and pattern matching binds. If the pattern in a bind + is non-exhaustive the other patterns need to be handled in a `where`-clause + (see example below). + + Example: + + ```agda + filter : {A : Set} → (A → Bool) → List A → List A + filter p xs = do + x ← xs + true ← return (p x) + where false → [] + return x + ``` + + Do-blocks desugar to `_>>=_` and `_>>_` before scope checking, so whatever + definitions of these two functions are in scope of the do-block will be used. + + More precisely: + + - Simple bind + + ```agda + do x ← m + m' + ``` + desugars to `m >>= λ x → m'`. + + - Pattern bind + + ```agda + do p ← m where pᵢ → mᵢ + m' + ``` + desugars to `m >>= λ { p → m'; pᵢ → mᵢ }`, where `pᵢ → mᵢ` is an arbitrary + sequence of clauses and follows the usual layout rules for `where`. If `p` + is exhaustive the `where` clause can be omitted. + + - Non-binding operation + + ```agda + do m + m' + ``` + desugars to `m >> m'`. + + - Let + + ```agda + do let ds + m + ``` + desugars to `let ds in m`, where `ds` is an arbitrary sequence of valid let-declarations. + + - The last statement in the do block must be a plain expression (no let or bind). + + Bind statements can use either `←` or `<-`. Neither of these are reserved, so + code outside do-blocks can use identifiers with these names, but inside a + do-block they would need to be used qualified or under different names. + +* Infix let declarations. [Issue [#917](https://github.com/agda/agda/issues/917)] + + Let declarations can now be defined in infix (or mixfix) style. For instance: + + ```agda + f : Nat → Nat + f n = let _!_ : Nat → Nat → Nat + x ! y = 2 * x + y + in n ! n + ``` + +* Overloaded pattern synonyms. [Issue [#2787](https://github.com/agda/agda/issues/2787)] + + Pattern synonyms can now be overloaded if all candidates have the same + *shape*. Two pattern synonym definitions have the same shape if they are + equal up to variable and constructor names. Shapes are checked at resolution + time. + + For instance, the following is accepted: + + ```agda + open import Agda.Builtin.Nat + + data List (A : Set) : Set where + lnil : List A + lcons : A → List A → List A + + data Vec (A : Set) : Nat → Set where + vnil : Vec A 0 + vcons : ∀ {n} → A → Vec A n → Vec A (suc n) + + pattern [] = lnil + pattern [] = vnil + + pattern _∷_ x xs = lcons x xs + pattern _∷_ y ys = vcons y ys + + lmap : ∀ {A B} → (A → B) → List A → List B + lmap f [] = [] + lmap f (x ∷ xs) = f x ∷ lmap f xs + + vmap : ∀ {A B n} → (A → B) → Vec A n → Vec B n + vmap f [] = [] + vmap f (x ∷ xs) = f x ∷ vmap f xs + ``` + +* If the file has no top-level module header, the first module + cannot have the same name as the file. + [Issues [#2808](https://github.com/agda/agda/issues/2808) + and [#1077](https://github.com/agda/agda/issues/1077)] + + This means that the following file `File.agda` is rejected: + ```agda + -- no module header + postulate A : Set + module File where -- inner module with the same name as the file + ``` + Agda reports `Illegal declarations(s) before top-level module` + at the `postulate`. + This is to avoid confusing scope errors in similar situations. + + If a top-level module header is inserted manually, the file is accepted: + + ```agda + module _ where -- user written module header + postulate A : Set + module File where -- inner module with the same name as the file, ok + ``` + +### Pattern matching + +* Forced constructor patterns. + + Constructor patterns can now be dotted to indicate that Agda should not case + split on them but rather their value is forced by the type of the other + patterns. The difference between this and a regular dot pattern is that + forced constructor patterns can still bind variables in their arguments. + For example, + + ```agda + open import Agda.Builtin.Nat + + data Vec (A : Set) : Nat → Set where + nil : Vec A zero + cons : (n : Nat) → A → Vec A n → Vec A (suc n) + + append : {A : Set} (m n : Nat) → Vec A m → Vec A n → Vec A (m + n) + append .zero n nil ys = ys + append (.suc m) n (cons .m x xs) ys = cons (m + n) x (append m n xs ys) + ``` + +* Inferring the type of a function based on its patterns + + Agda no longer infers the type of a function based on the patterns used in + its definition. [Issue [#2834](https://github.com/agda/agda/issues/2834)] + + This means that the following Agda program is no longer accepted: + ```agda + open import Agda.Builtin.Nat + + f : _ → _ + f zero = zero + f (suc n) = n + ``` + Agda now requires the type of the argument of `f` to be given explicitly. + +* Improved constraint solving for pattern matching functions + + Constraint solving for functions where each right-hand side has a distinct + rigid head has been extended to also cover the case where some clauses return + an argument of the function. A typical example is append on lists: + + ```agda + _++_ : {A : Set} → List A → List A → List A + [] ++ ys = ys + (x ∷ xs) ++ ys = x ∷ (xs ++ ys) + ``` + + Agda can now solve constraints like `?X ++ ys == 1 ∷ ys` when `ys` is a + neutral term. + +* Record expressions translated to copatterns + + Definitions of the form + + ```agda + f ps = record { f₁ = e₁; ..; fₙ = eₙ } + ``` + + are translated internally to use copatterns: + + ```agda + f ps .f₁ = e₁ + ... + f ps .fₙ = eₙ + ``` + + This means that `f ps` does not reduce, but thanks to η-equality the two + definitions are equivalent. + + The change should lead to fewer big record expressions showing up in goal + types, and potentially significant performance improvement in some cases. + + This may have a minor impact on with-abstraction and code using `--rewriting` + since η-equality is not used in these cases. + +* When using `with`, it is now allowed to replace any pattern from the parent + clause by a variable in the with clause. For example: + + ```agda + f : List ℕ → List ℕ + f [] = [] + f (x ∷ xs) with x ≤? 10 + f xs | p = {!!} + ``` + + In the with clause, `xs` is treated as a let-bound variable with value + `.x ∷ .xs` (where `.x : ℕ` and `.xs : List ℕ` are out of scope) and + `p : Dec (.x ≤ 10)`. + + Since with-abstraction may change the type of variables, instantiations + of variables in the with clause are type checked again after with-abstraction. + +### Builtins + +* Added support for built-in 64-bit machine words. + + These are defined in `Agda.Builtin.Word` and come with two primitive + operations to convert to and from natural numbers. + + ```agda + Word64 : Set + primWord64ToNat : Word64 → Nat + primWord64FromNat : Nat → Word64 + ``` + + Converting to a natural number is the trivial embedding, and converting from a natural number + gives you the remainder modulo 2^64. The proofs of these theorems are not + primitive, but can be defined in a library using `primTrustMe`. + + Basic arithmetic operations can be defined on `Word64` by converting to + natural numbers, peforming the corresponding operation, and then converting + back. The compiler will optimise these to use 64-bit arithmetic. For + instance, + + ```agda + addWord : Word64 → Word64 → Word64 + addWord a b = primWord64FromNat (primWord64ToNat a + primWord64ToNat b) + + subWord : Word64 → Word64 → Word64 + subWord a b = primWord64FromNat (primWord64ToNat a + 18446744073709551616 - primWord64ToNat b) + ``` + + These compiles (in the GHC backend) to addition and subtraction on + `Data.Word.Word64`. + +* New primitive primFloatLess and changed semantics of primFloatNumericalLess. + + `primFloatNumericalLess` now uses standard IEEE `<`, so for instance + `NaN < x = x < NaN = false`. + + On the other hand `primFloatLess` provides a total order on `Float`, with + `-Inf < NaN < -1.0 < -0.0 < 0.0 < 1.0 < Inf`. + +* The `SIZEINF` builtin is now given the name `∞` in + `Agda.Builtin.Size` [Issue + [#2931](https://github.com/agda/agda/issues/2931)]. + + Previously it was given the name `ω`. + +### Reflection + +* New TC primitive: `declarePostulate`. [Issue + [#2782](https://github.com/agda/agda/issues/2782)] + + ```agda + declarePostulate : Arg Name → Type → TC ⊤ + ``` + + This can be used to declare new postulates. The Visibility of the + Arg must not be hidden. This feature fails when executed with + `--safe` flag from command-line. + +Pragmas and options +------------------- + +* The `--caching` option is ON by default and is also a valid pragma. + Caching can (sometimes) speed up re-typechecking in `--interaction` + mode by reusing the result of the previous typechecking for the + prefix of the file that has not changed (with a granularity at the + level of declarations/mutual blocks). + + It can be turned off by passing ```--no-caching``` to ```agda``` or + with the following at the top of your file. + + ```agda + {-# OPTIONS --no-caching #-} + ``` + +* The `--sharing` and `--no-sharing` options have been deprecated and do + nothing. + + Compile-time evaluation is now always call-by-need. + +* BUILTIN pragmas can now appear before the top-level module header + and in parametrized modules. + [Issue [#2824](https://github.com/agda/agda/issues/2824)] + ```agda + {-# OPTIONS --rewriting #-} + open import Agda.Builtin.Equality + {-# BUILTIN REWRITE _≡_ #-} -- here + module TopLevel (A : Set) where + {-# BUILTIN REWRITE _≡_ #-} -- or here + ``` + Note that it is still the case that built-ins cannot be bound if + they depend on module parameters from an enclosing module. For + instance, the following is illegal: + ```agda + module _ {a} {A : Set a} where + data _≡_ (x : A) : A → Set a where + refl : x ≡ x + {-# BUILTIN EQUALITY _≡_ #-} + ``` + +* Builtin `NIL` and `CONS` have been merged with `LIST`. + + When binding the `LIST` builtin, `NIL` and `CONS` are bound to + the appropriate constructors automatically. This means that instead + of writing + + ```agda + {-# BUILTIN LIST List #-} + {-# BUILTIN NIL [] #-} + {-# BUILTIN CONS _∷_ #-} + ``` + + you just write + + ```agda + {-# BUILTIN LIST List #-} + ``` + + Attempting to bind `NIL` or `CONS` results in a warning and has otherwise no + effect. + +* The `--no-unicode` pragma prevents Agda from introducing unicode characters + when pretty printing a term. Lambda, Arrows and Forall quantifiers are all + replaced by their ascii only version. Instead of resorting to subscript + suffixes, Agda uses ascii digit characters. + +* New option `--inversion-max-depth=N`. + + The depth is used to avoid looping due to inverting pattern matching for + unsatisfiable constraints [Issue [#431](https://github.com/agda/agda/issues/431)]. + This option is only expected to be necessary in pathological cases. + +* New option `--no-print-pattern-synonyms`. + + This disables the use of pattern synonyms in output from Agda. + See [Issue [#2902](https://github.com/agda/agda/issues/2902)] for situations + where this might be desirable. + +* New fine-grained control over the warning machinery: ability to (en/dis)able + warnings on a one-by-one basis. + +* The command line option `--help` now takes an optional argument which + allows the user to request more specific usage information about particular + topics. The only one added so far is `warning`. + +* New pragma NOINLINE. + + ```agda + {-# NOINLINE f #-} + ``` + + Disables automatic inlining of `f`. + +* New pragma WARNING_ON_USAGE + + ``` + {-# WARNING_ON_USAGE QName Message #} + ``` + + Prints Message whenever QName is used. + +Emacs mode +---------- + +* Banana brackets have been added to the Agda input method. + ``` + \(( #x2985 LEFT WHITE PARENTHESIS + \)) #x2986 RIGHT WHITE PARENTHESIS + ``` + +* Result splitting will introduce the trailing hidden arguments, + if there is nothing else todo + [Issue [#2871](https://github.com/agda/agda/issues/2871)]. + Example: + ```agda + data Fun (A : Set) : Set where + mkFun : (A → A) → Fun A + + test : {A : Set} → Fun A + test = ? + + ``` + Splitting on the result here (`C-c C-c RET`) will append + `{A}` to the left hand side. + ```agda + test {A} = ? + ``` + +* Light highlighting is performed dynamically, even if the file is not + loaded [Issue [#2794](https://github.com/agda/agda/issues/2794)]. + + This light highlighting is based on the token stream generated by + Agda's lexer: the code is only highlighted if the file is lexically + correct. If the Agda backend is not busy with something else, then + the code is highlighted automatically in certain situations: + + * When the file is saved. + + * When Emacs has been idle, continuously, for a certain period of + time (by default 0.2 s) after the last modification of the file, + and the file has not been saved (or marked as being unmodified). + This functionality can be turned off, and the time period can be + customised. + +* Highlighting of comments is no longer handled by Font Lock mode + [Issue [#2794](https://github.com/agda/agda/issues/2794)]. + +* The Emacs mode's syntax table has been changed. + + Previously `_` was treated as punctuation. Now it is treated in the + same way as most other characters: if the standard syntax table + assigns it the syntax class "whitespace", "open parenthesis" or + "close parenthesis", then it gets that syntax class, and otherwise + it gets the syntax class "word constituent". + +Compiler backends +----------------- + +* The GHC backend now automatically compiles BUILTIN LIST to Haskell lists. + + This means that it's no longer necessary to give a COMPILE GHC pragma for the + builtin list type. Indeed, doing so has no effect on the compilation and + results in a warning. + +* The GHC backend performance improvements. + + Generated Haskell code now contains approximate type signatures, which lets + GHC get rid of many of the `unsafeCoerce`s. This leads to performance + improvements of up to 50% of compiled code. + +* The GHC backend now compiles the `INFINITY`, `SHARP` and `FLAT` + builtins in a different way [Issue + [#2909](https://github.com/agda/agda/issues/2909)]. + + Previously these were compiled to (basically) nothing. Now the + `INFINITY` builtin is compiled to `Infinity`, available from + `MAlonzo.RTE`: + + ```haskell + data Inf a = Sharp { flat :: a } + type Infinity level a = Inf a + ``` + + The `SHARP` builtin is compiled to `Sharp`, and the `FLAT` builtin + is (by default) compiled to a corresponding destructor. + + Note that code that interacts with Haskell libraries may have to be + updated. As an example, here is one way to print colists of + characters using the Haskell function `putStr`: + + ```agda + open import Agda.Builtin.Char + open import Agda.Builtin.Coinduction + open import Agda.Builtin.IO + open import Agda.Builtin.Unit + + data Colist {a} (A : Set a) : Set a where + [] : Colist A + _∷_ : A → ∞ (Colist A) → Colist A + + {-# FOREIGN GHC + data Colist a = Nil | Cons a (MAlonzo.RTE.Inf (Colist a)) + type Colist' l a = Colist a + + fromColist :: Colist a -> [a] + fromColist Nil = [] + fromColist (Cons x xs) = x : fromColist (MAlonzo.RTE.flat xs) + #-} + + {-# COMPILE GHC Colist = data Colist' (Nil | Cons) #-} + + postulate + putStr : Colist Char → IO ⊤ + + {-# COMPILE GHC putStr = putStr . fromColist #-} + ``` + +* `COMPILE GHC` pragmas have been included for the size primitives + [Issue [#2879](https://github.com/agda/agda/issues/2879)]. + +LaTeX backend +------------- + +* The `code` environment can now take arguments [Issues + [#2744](https://github.com/agda/agda/issues/2744) and + [#2453](https://github.com/agda/agda/issues/2453)]. + + Everything from \begin{code} to the end of the line is preserved in + the generated LaTeX code, and not treated as Agda code. + + The default implementation of the `code` environment recognises one + optional argument, `hide`, which can be used for code that should be + type-checked, but not typeset: + ```latex + \begin{code}[hide] + open import Module + \end{code} + ``` + + The `AgdaHide` macro has not been removed, but has been deprecated + in favour of `[hide]`. + +* The `AgdaSuppressSpace` and `AgdaMultiCode` environments no longer + take an argument. + + Instead some documents need to be compiled multiple times. + +* The `--count-clusters` flag can now be given in `OPTIONS` pragmas. + +* The `nofontsetup` option to the LaTeX package `agda` was broken, and + has (hopefully) been fixed + [Issue [#2773](https://github.com/agda/agda/issues/2773)]. + + Fewer packages than before are loaded when `nofontsetup` is used, + see `agda.sty` for details. Furthermore, if LuaLaTeX or XeLaTeX are + not used, then the font encoding is no longer changed. + +* The new option `noinputencodingsetup` instructs the LaTeX package + `agda` to not change the input encoding, and to not load the `ucs` + package. + +* Underscores are now typeset using `\AgdaUnderscore{}`. + + The default implementation is `\_` (the command that was previously + generated for underscores). Note that it is possible to override + this implementation. + +* OtherAspects (unsolved meta variables, catchall clauses, etc.) are + now correctly highlighted in the LaTeX backend (and the HTML one). + [Issue [#2474](https://github.com/agda/agda/issues/2474)] + +* `postprocess-latex.pl` does not add extra spaces around tagged `\Agda*{}` + commands anymore. + +HTML backend +------------ + +* An identifier (excluding bound variables), + gets the identifier itself as an anchor, + _in addition_ to the file position + [Issue [#2756](https://github.com/agda/agda/issues/2756)]. + In Agda 2.5.3, the identifier anchor would _replace_ the file position anchor + [Issue [#2604](https://github.com/agda/agda/issues/2604)]. + + Symbolic anchors look like + ```html + + + ``` + while file position anchors just give the character position in the file: + ```html + + ``` + + Top-level module names do not get a symbolic anchor, since the position of + a top-level module is defined to be the beginning of the file. + + Example: + + ```agda + module Issue2604 where -- Character position anchor + + test1 : Set₁ -- Issue2604.html#test1 + test1 = bla + where + bla = Set -- Only character position anchor + + test2 : Set₁ -- Issue2604.html#test2 + test2 = bla + where + bla = Set -- Only character position anchor + + test3 : Set₁ -- Issue2604.html#test3 + test3 = bla + module M where -- Issue2604.html#M + bla = Set -- Issue2604.html#M.bla + + module NamedModule where -- Issue2604.html#NamedModule + test4 : Set₁ -- Issue2604.html#NamedModule.test4 + test4 = M.bla + + module _ where -- Only character position anchor + test5 : Set₁ -- Only character position anchor + test5 = M.bla + ``` + +List of closed issues +--------------------- + +For 2.5.4, the following issues have been closed +(see [bug tracker](https://github.com/agda/agda/issues)): + + - [#351](https://github.com/agda/agda/issues/351): Constraint solving for irrelevant metas + - [#421](https://github.com/agda/agda/issues/421): Higher order positivity + - [#431](https://github.com/agda/agda/issues/431): Constructor-headed function makes type-checker diverge + - [#437](https://github.com/agda/agda/issues/437): Detect when something cannot be a function type + - [#488](https://github.com/agda/agda/issues/488): Refining on user defined syntax mixes up the order of the subgoals + - [#681](https://github.com/agda/agda/issues/681): Lack of visual state indicators in new Emacs mode + - [#689](https://github.com/agda/agda/issues/689): Contradictory constraints should yield error + - [#708](https://github.com/agda/agda/issues/708): Coverage checker not taking literal patterns into account properly + - [#875](https://github.com/agda/agda/issues/875): Nonstrict irrelevance violated by implicit inference + - [#964](https://github.com/agda/agda/issues/964): Allow unsolved metas in imported files + - [#987](https://github.com/agda/agda/issues/987): --html anchors could be more informative + - [#1054](https://github.com/agda/agda/issues/1054): Inlined Agda code in LaTeX backend + - [#1131](https://github.com/agda/agda/issues/1131): Infix definitions not allowed in let definitions + - [#1169](https://github.com/agda/agda/issues/1169): Auto fails with non-terminating function + - [#1268](https://github.com/agda/agda/issues/1268): Hard to print type of variable if the type starts with an instance argument + - [#1384](https://github.com/agda/agda/issues/1384): Order of constructor arguments matters for coverage checker + - [#1425](https://github.com/agda/agda/issues/1425): Instances with relevant recursive instance arguments are not considered in irrelevant positions + - [#1548](https://github.com/agda/agda/issues/1548): Confusing error about ambiguous definition with parametrized modules + - [#1884](https://github.com/agda/agda/issues/1884): what is the format of the libraries and defaults files + - [#1906](https://github.com/agda/agda/issues/1906): Possible performance problem + - [#2056](https://github.com/agda/agda/issues/2056): Cannot instantiate meta to solution...: Pattern checking done too early in where block + - [#2067](https://github.com/agda/agda/issues/2067): Display forms in parameterised module too general + - [#2183](https://github.com/agda/agda/issues/2183): Allow splitting on dotted variables + - [#2226](https://github.com/agda/agda/issues/2226): open {{...}} gets hiding wrong + - [#2255](https://github.com/agda/agda/issues/2255): Performance issue with deeply-nested lambdas + - [#2306](https://github.com/agda/agda/issues/2306): Commands in the emacs-mode get confused if we add question marks to the file + - [#2384](https://github.com/agda/agda/issues/2384): More fine-grained blocking in constraint solver + - [#2401](https://github.com/agda/agda/issues/2401): LaTeX backend error + - [#2404](https://github.com/agda/agda/issues/2404): checkType doesn't accept a type-checking definition checked with the same type + - [#2420](https://github.com/agda/agda/issues/2420): Failed to solve level constraints in record type with hole + - [#2421](https://github.com/agda/agda/issues/2421): After emacs starts up, Agda does not process file without restart of Agda + - [#2436](https://github.com/agda/agda/issues/2436): Agda allows coinductive records with eta-equality + - [#2450](https://github.com/agda/agda/issues/2450): Irrelevant variables are pruned too eagerly + - [#2474](https://github.com/agda/agda/issues/2474): The LaTeX and HTML backends do not highlight (all) unsolved metas + - [#2484](https://github.com/agda/agda/issues/2484): Regression related to sized types + - [#2526](https://github.com/agda/agda/issues/2526): Better documentation of record modules + - [#2536](https://github.com/agda/agda/issues/2536): UTF8 parsed incorrectly for literate agda files + - [#2565](https://github.com/agda/agda/issues/2565): Options for the interaction action give to keep the overloaded literals and sections? + - [#2576](https://github.com/agda/agda/issues/2576): Shadowing data decl by data sig produces Missing type signature error + - [#2594](https://github.com/agda/agda/issues/2594): Valid partial cover rejected: "Cannot split on argument of non-datatype" + - [#2600](https://github.com/agda/agda/issues/2600): Stack complains about Agda.cabal + - [#2607](https://github.com/agda/agda/issues/2607): Instance search confused when an instance argument is sourced from a record + - [#2617](https://github.com/agda/agda/issues/2617): Installation instructions + - [#2623](https://github.com/agda/agda/issues/2623): Incorrect indentation when \AgdaHide is used + - [#2634](https://github.com/agda/agda/issues/2634): Fixity declaration ignored in definitions in record + - [#2636](https://github.com/agda/agda/issues/2636): The positivity checker complains when a new definition is added in the same where clause + - [#2640](https://github.com/agda/agda/issues/2640): Unifier dots the relevant pattern variables when it should dot the irrelevant ones + - [#2668](https://github.com/agda/agda/issues/2668): Changing the visibility of a module parameter breaks `with` + - [#2728](https://github.com/agda/agda/issues/2728): Bad interaction between caching and the warning machinery + - [#2738](https://github.com/agda/agda/issues/2738): Update Stackage LTS from 9.1 to version supporting Alex 3.2.3 + - [#2744](https://github.com/agda/agda/issues/2744): It should be possible to give arguments to the code environment + - [#2745](https://github.com/agda/agda/issues/2745): Broken build with GHC 7.8.4 due to (new) version 1.2.2.0 of hashtables + - [#2749](https://github.com/agda/agda/issues/2749): Add --no-unicode cli option to Agda + - [#2751](https://github.com/agda/agda/issues/2751): Unsolved constraints, but no highlighting + - [#2752](https://github.com/agda/agda/issues/2752): Mutual blocks inside instance blocks + - [#2753](https://github.com/agda/agda/issues/2753): Unsolved constraint, related to instance arguments and sized types + - [#2756](https://github.com/agda/agda/issues/2756): HTML backend generates broken links + - [#2758](https://github.com/agda/agda/issues/2758): Relevant meta is instantiated with irrelevant solution + - [#2759](https://github.com/agda/agda/issues/2759): Empty mutual blocks should be warning rather than error + - [#2762](https://github.com/agda/agda/issues/2762): Automatically generate DISPLAY pragmas to fold pattern synonyms + - [#2763](https://github.com/agda/agda/issues/2763): Internal Error at "src/full/Agda/TypeChecking/Abstract.hs:138" + - [#2765](https://github.com/agda/agda/issues/2765): Inferred level expressions are often "reversed" + - [#2769](https://github.com/agda/agda/issues/2769): Agda prints ill-formed expression, record argument dropped + - [#2771](https://github.com/agda/agda/issues/2771): Erroneous 'with' error message + - [#2773](https://github.com/agda/agda/issues/2773): The nofontsetup option does not work as advertised + - [#2775](https://github.com/agda/agda/issues/2775): Irrelevance to be taken into account in 'with' abstraction. + - [#2776](https://github.com/agda/agda/issues/2776): Dotted variable in inferred type + - [#2780](https://github.com/agda/agda/issues/2780): Improve level constraint solving for groups of inequality constraints + - [#2782](https://github.com/agda/agda/issues/2782): Extending Agda reflection to introduce postulates + - [#2785](https://github.com/agda/agda/issues/2785): internal error @ ConcreteToAbstract.hs:721 + - [#2787](https://github.com/agda/agda/issues/2787): Overloaded pattern synonyms + - [#2792](https://github.com/agda/agda/issues/2792): Safe modules can sometimes not be imported from unsafe modules + - [#2794](https://github.com/agda/agda/issues/2794): Using \texttt{-} destroys code coloring in literate file + - [#2796](https://github.com/agda/agda/issues/2796): Overloaded (inherited) projection resolution fails with parametrized record + - [#2798](https://github.com/agda/agda/issues/2798): The LaTeX backend ignores the "operator" aspect + - [#2802](https://github.com/agda/agda/issues/2802): Printing of overloaded functions broken due to eager normalization of projections + - [#2803](https://github.com/agda/agda/issues/2803): Case splitting loses names of hidden arguments + - [#2808](https://github.com/agda/agda/issues/2808): Confusing error when inserting declaration before top-level module + - [#2810](https://github.com/agda/agda/issues/2810): Make `--caching` a pragma option + - [#2811](https://github.com/agda/agda/issues/2811): OPTION --caching allowed in file (Issue #2810) + - [#2819](https://github.com/agda/agda/issues/2819): Forcing analysis doesn't consider relevance + - [#2821](https://github.com/agda/agda/issues/2821): BUILTIN BOOL gremlin + - [#2824](https://github.com/agda/agda/issues/2824): Allow {-# BUILTIN #-} in preamble and in parametrized modules + - [#2826](https://github.com/agda/agda/issues/2826): Case splitting on earlier variable uses duplicate variable name + - [#2827](https://github.com/agda/agda/issues/2827): Variables off in with-clauses. Parameter refinement? + - [#2831](https://github.com/agda/agda/issues/2831): NO_POSITIVITY_CHECK pragma can be written before a mutual block without data or record types + - [#2832](https://github.com/agda/agda/issues/2832): BUILTIN NIL and CONS are not needed + - [#2834](https://github.com/agda/agda/issues/2834): Disambiguation of type based on pattern leads to non-unique meta solution + - [#2836](https://github.com/agda/agda/issues/2836): The Emacs mode does not handle .lagda.tex files + - [#2840](https://github.com/agda/agda/issues/2840): Internal error in positivity with modules/datatype definitions + - [#2841](https://github.com/agda/agda/issues/2841): Opting out of idiom brackets + - [#2844](https://github.com/agda/agda/issues/2844): Root documentation URL redirects to version 2.5.2 + - [#2849](https://github.com/agda/agda/issues/2849): Internal error at absurd pattern followed by `rewrite` + - [#2854](https://github.com/agda/agda/issues/2854): Agda worries about possibly empty type of sizes even when no builtins for size are active + - [#2855](https://github.com/agda/agda/issues/2855): Single-clause definition is both unreachable and incomplete + - [#2856](https://github.com/agda/agda/issues/2856): Panic: unbound variable + - [#2859](https://github.com/agda/agda/issues/2859): Error "pattern variable shadows constructor" caused by parameter refinement + - [#2862](https://github.com/agda/agda/issues/2862): inconsistency from a mutual datatype declaration and module definition + - [#2867](https://github.com/agda/agda/issues/2867): Give does not insert parenthesis for module parameters + - [#2868](https://github.com/agda/agda/issues/2868): With --postfix-projections, record fields are printed preceded by a dot when working within the record + - [#2870](https://github.com/agda/agda/issues/2870): Lexical error for \- (hyphen) + - [#2871](https://github.com/agda/agda/issues/2871): Introduce just trailing hidden arguments by result splitting + - [#2873](https://github.com/agda/agda/issues/2873): Refinement problem in presence of overloaded constructors + - [#2874](https://github.com/agda/agda/issues/2874): Internal error in src/full/Agda/TypeChecking/Coverage/Match.hs:312 + - [#2878](https://github.com/agda/agda/issues/2878): Support for GHC 8.4.1 + - [#2879](https://github.com/agda/agda/issues/2879): Include COMPILE GHC pragmas for size primitives + - [#2881](https://github.com/agda/agda/issues/2881): Internal error in BasicOps + - [#2883](https://github.com/agda/agda/issues/2883): "internal error in TypeChecking/Substitute.hs:379" + - [#2884](https://github.com/agda/agda/issues/2884): Missing PDF user manual in the tarball + - [#2888](https://github.com/agda/agda/issues/2888): Internal error caused by new forcing translation + - [#2894](https://github.com/agda/agda/issues/2894): Unifier tries to eta expand non-eta record + - [#2896](https://github.com/agda/agda/issues/2896): Unifier throws away pattern + - [#2897](https://github.com/agda/agda/issues/2897): Internal error for local modules with refined parameters + - [#2904](https://github.com/agda/agda/issues/2904): No tab completion for GHCNoMain + - [#2906](https://github.com/agda/agda/issues/2906): Confusing "cannot be translated to a Haskell type" error message + - [#2908](https://github.com/agda/agda/issues/2908): primForce is compiled away + - [#2909](https://github.com/agda/agda/issues/2909): Agda uses newtypes incorrectly, causing wellformed programs to loop + - [#2911](https://github.com/agda/agda/issues/2911): Inferring missing instance clause panics in refined context + - [#2912](https://github.com/agda/agda/issues/2912): Add fine-grained control over the displayed warnings + - [#2914](https://github.com/agda/agda/issues/2914): Slicing ignores as pragma? + - [#2916](https://github.com/agda/agda/issues/2916): The GHC backend generates code with an incorrect number of constructor arguments + - [#2917](https://github.com/agda/agda/issues/2917): Very slow due to unsolved size? + - [#2919](https://github.com/agda/agda/issues/2919): Internal error in Agda.TypeChecking.Forcing + - [#2921](https://github.com/agda/agda/issues/2921): COMPILE data for data types with erased constructor arguments + - [#2923](https://github.com/agda/agda/issues/2923): Word.agda not included as builtin + - [#2925](https://github.com/agda/agda/issues/2925): Allow adding the same rewrite rules multiple times + - [#2927](https://github.com/agda/agda/issues/2927): Panic related to sized types + - [#2928](https://github.com/agda/agda/issues/2928): Internal error in Agda.TypeChecking.Rules.LHS + - [#2931](https://github.com/agda/agda/issues/2931): Rename Agda.Builtin.Size.ω to ∞? + - [#2941](https://github.com/agda/agda/issues/2941): "coinductive" record inconsistent + - [#2944](https://github.com/agda/agda/issues/2944): Regression, seemingly related to record expressions + - [#2945](https://github.com/agda/agda/issues/2945): Inversion warning in code that used to be accepted + - [#2947](https://github.com/agda/agda/issues/2947): Internal error in Agda.TypeChecking.Forcing + - [#2952](https://github.com/agda/agda/issues/2952): Wrong compilation of pattern matching to Haskell + - [#2953](https://github.com/agda/agda/issues/2953): Generated Haskell code does not typecheck + - [#2954](https://github.com/agda/agda/issues/2954): Pattern matching on string gives unexpected unreachable clause + - [#2957](https://github.com/agda/agda/issues/2957): Support for async 2.2.1 + - [#2958](https://github.com/agda/agda/issues/2958): `as` names being duplicated in buffer after `with` + - [#2959](https://github.com/agda/agda/issues/2959): Repeating a successful command after revert + reload fails with caching enabled + - [#2960](https://github.com/agda/agda/issues/2960): Uncommenting indented lines doesn't work + - [#2963](https://github.com/agda/agda/issues/2963): Extended lambdas bypass positivity checking in records + - [#2966](https://github.com/agda/agda/issues/2966): Internal error in Auto + - [#2968](https://github.com/agda/agda/issues/2968): Bad Interaction with copatterns and eta?, leads to ill-typed terms in error messages. + - [#2971](https://github.com/agda/agda/issues/2971): Copattern split with `--no-irrelevant-projections` panics + - [#2974](https://github.com/agda/agda/issues/2974): Copatterns break canonicity + - [#2975](https://github.com/agda/agda/issues/2975): Termination checker runs too early for definitions inside record (or: positivity checker runs too late) + - [#2976](https://github.com/agda/agda/issues/2976): Emacs mode reports errors in connection with highlighting comments + - [#2978](https://github.com/agda/agda/issues/2978): Double solving of meta + - [#2985](https://github.com/agda/agda/issues/2985): The termination checker accepts non-terminating code + - [#2989](https://github.com/agda/agda/issues/2989): Internal error when checking record match in let expr + - [#2990](https://github.com/agda/agda/issues/2990): Performance regression related to the abstract machine + - [#2994](https://github.com/agda/agda/issues/2994): Solution accepted in hole is subsequently rejected on reload + - [#2996](https://github.com/agda/agda/issues/2996): Internal error with -v tc.cover:20 + - [#2997](https://github.com/agda/agda/issues/2997): Internal error in Agda.TypeChecking.Rules.LHS + - [#2998](https://github.com/agda/agda/issues/2998): Regression: With clause pattern x is not an instance of its parent pattern "eta expansion of x" + - [#3002](https://github.com/agda/agda/issues/3002): Spurious 1 after simplification + - [#3004](https://github.com/agda/agda/issues/3004): Agda hangs on extended lambda + - [#3007](https://github.com/agda/agda/issues/3007): Internal error in Parser + - [#3012](https://github.com/agda/agda/issues/3012): Internal Error at : "src/full/Agda/TypeChecking/Reduce/Fast.hs:1030" + - [#3014](https://github.com/agda/agda/issues/3014): Internal error in Rules.LHS + - [#3020](https://github.com/agda/agda/issues/3020): Missing highlighting in record modules + - [#3023](https://github.com/agda/agda/issues/3023): Support for GHC 8.4.2 + - [#3024](https://github.com/agda/agda/issues/3024): Postfix projection patterns not highlighted correctly with agda --latex + - [#3030](https://github.com/agda/agda/issues/3030): [ warning ] user defined warnings + - [#3031](https://github.com/agda/agda/issues/3031): Eta failure for record meta with irrelevant fields + - [#3033](https://github.com/agda/agda/issues/3033): Giving and solving don't insert parenthesis for applications in dot pattern + - [#3044](https://github.com/agda/agda/issues/3044): Internal error in src/full/Agda/TypeChecking/Substitute/Class.hs:209 + - [#3045](https://github.com/agda/agda/issues/3045): GHC backend generates type without enough arguments + - [#3046](https://github.com/agda/agda/issues/3046): do-notation causes parse errors in subsequent where clauses + - [#3049](https://github.com/agda/agda/issues/3049): Positivity unsoundness + - [#3050](https://github.com/agda/agda/issues/3050): We revert back to call-by-name during positivity checking + - [#3051](https://github.com/agda/agda/issues/3051): Pattern synonyms should be allowed in mutual blocks + - [#3052](https://github.com/agda/agda/issues/3052): Another recent inference change + - [#3062](https://github.com/agda/agda/issues/3062): Literal match does not respect first-match semantics + - [#3063](https://github.com/agda/agda/issues/3063): Internal error in Agda.TypeChecking.Forcing + - [#3064](https://github.com/agda/agda/issues/3064): Coverage checker bogus on literals combined with copatterns + - [#3065](https://github.com/agda/agda/issues/3065): Internal error in coverage checker triggered by literal dot pattern + - [#3067](https://github.com/agda/agda/issues/3067): checking hangs on invalid program + - [#3072](https://github.com/agda/agda/issues/3072): invalid section printing + - [#3074](https://github.com/agda/agda/issues/3074): Wrong hiding causes internal error in LHS checker + - [#3075](https://github.com/agda/agda/issues/3075): Automatic inlining and tactics + - [#3078](https://github.com/agda/agda/issues/3078): Error building with GHC 7.10.2: Missing transformers library + - [#3079](https://github.com/agda/agda/issues/3079): Wrong parameter hiding for instance open + - [#3080](https://github.com/agda/agda/issues/3080): Case splitting prints out-of-scope pattern synonyms + - [#3082](https://github.com/agda/agda/issues/3082): Emacs mode regression: a ? inserted before existing hole hijacks its interaction point + - [#3083](https://github.com/agda/agda/issues/3083): Wrong hiding in module application + - [#3084](https://github.com/agda/agda/issues/3084): Changes to mode line do not take effect immediately + - [#3085](https://github.com/agda/agda/issues/3085): Postpone checking a pattern let binding when type is blocked + - [#3090](https://github.com/agda/agda/issues/3090): Internal error in parser when using parentheses in BUILTIN pragma + - [#3096](https://github.com/agda/agda/issues/3096): Support GHC 8.4.3 diff --git a/doc/release-notes/2.6.0.1.md b/doc/release-notes/2.6.0.1.md new file mode 100644 --- /dev/null +++ b/doc/release-notes/2.6.0.1.md @@ -0,0 +1,22 @@ +Release notes for Agda version 2.6.0.1 +====================================== + +Installation and infrastructure +------------------------------- + +* Added support for GHC 8.6.5. + +List of all closed issues +------------------------- + +For 2.6.0.1, the following issues have been closed +(see [bug tracker](https://github.com/agda/agda/issues)): + + - [#3685](https://github.com/agda/agda/issues/3685): Support GHC 8.6.5 + - [#3692](https://github.com/agda/agda/issues/3692): Omission of absurd patterns in automatically added absurd clauses causes too optimistic polarity. + - [#3694](https://github.com/agda/agda/issues/3694): Importing Agda.Builtin.Size in one module affects another module + - [#3696](https://github.com/agda/agda/issues/3696): Make `AgdaAny` polykinded? + - [#3697](https://github.com/agda/agda/issues/3697): Panic when checking non-Setω data definitions with --type-in-type + - [#3701](https://github.com/agda/agda/issues/3701): [ re agda/agda-stdlib#710 ] toNat for machine words is injective + - [#3731](https://github.com/agda/agda/issues/3731): GHC backend thinks that a constructor called 'main' is the main program + - [#3742](https://github.com/agda/agda/issues/3742): Strange error message for code that combines mutual and abstract diff --git a/doc/release-notes/2.6.0.md b/doc/release-notes/2.6.0.md new file mode 100644 --- /dev/null +++ b/doc/release-notes/2.6.0.md @@ -0,0 +1,849 @@ +Release notes for Agda version 2.6.0 +==================================== + +Highlights +---------- + +* Added support for [Cubical + Agda](https://agda.readthedocs.io/en/v2.6.0/language/cubical.html) + which adds new features such as univalence and higher inductive + types to Agda. + +* Added support for ML-style [automatic generalization of + variables](https://agda.readthedocs.io/en/v2.6.0/language/generalization-of-declared-variables.html). + +* Added a new sort ``Prop`` of [definitionally proof-irrelevant + propositions](https://agda.readthedocs.io/en/v2.6.0/language/prop.html). + +* The implementation of [instance + search](https://agda.readthedocs.io/en/v2.6.0/language/instance-arguments.html) + got a major overhaul and no longer supports overlapping instances + (unless enabled by a flag). + +Installation and infrastructure +------------------------------- + +* Added support for GHC 8.6.4. + +* Interface files for all builtin and primitive files are now + re-generated each time Agda is installed. + +Syntax +------ + +* Agda now supports implicit generalization of declared + variables. Variables to be generalized can declared with the new + keyword `variable`. For example: + + ```agda + postulate + Con : Set + + variable + Γ Δ θ : Con + ``` + + Declared variables are automatically generalized in type signatures, + module telescopes and data type and record parameters and indices: + + ```agda + postulate + Sub : Con → Con → Set + + id : Sub Γ Γ + -- -- equivalent to + -- id : {Γ : Con} → Sub Γ Γ + + _∘_ : Sub Θ Δ → Sub Γ Θ → Sub Γ Δ + -- -- equivalent to + -- _∘_ : {Γ Δ Θ : Con} → Sub Θ Δ → Sub Γ Θ → Sub Γ Δ + ``` + + See the [user manual](https://agda.readthedocs.io/en/v2.6.0/language/generalization-of-declared-variables.html) + for more details. + +* Data type and record definitions separated from their type signatures can no + longer repeat the types of the parameters, but can bind implicit parameters + by name [Issue [#1886](https://github.com/agda/agda/issues/1886)]. + + This is now allowed + ```agda + data D {a b} (A : Set a) (B : Set b) : Set (a ⊔ lsuc b) + data D {b = b} A B where + mkD : (A → Set b) → D A B + ``` + but this is not + ```agda + data I (A : Set) : Set + data I (A : Set) where + ``` + +* The label used for named implicit arguments can now be different from the + name of the bound variable [Issue [#952](https://github.com/agda/agda/issues/952)]. + + Example, + ```agda + id₁ : {A = X : Set} → X → X + id₁ x = x + + id₂ : ∀ {B = X} → X → X + id₂ {B = X} x = id₁ {A = X} x + + test : Nat + test = id₁ {A = Nat} 5 + id₂ {B = Nat} 6 + ``` + Only implicit and instance arguments can have a label and either or both of + the label and bound variable can be `_`. Labeled bindings with a type + signature can only bind a single variable. For instance, the type `Set` has + to be repeated here: + ```agda + const : {A = X : Set} {B = Y : Set} → X → Y → X + const x _ = x + ``` + +* The rules for parsing of patterns have changed slightly [Issue + [#3400](https://github.com/agda/agda/issues/3400)]. + + Now projections are treated similarly to constructors: In a pattern + name parts coming from projections can only be used as part of + projections, constructors or pattern synonyms. They cannot be used + as variables, or as part of the name of the defined value. + + Examples: + + * The following code used to be syntactically ambiguous, but is now + parsed, because A can no longer be used as a variable: + ```agda + record R : Set₂ where + field + _A : Set₁ + + open R + + r : R + r A = Set + ``` + + * On the other hand the following code is no longer parsed: + ```agda + record R : Set₁ where + field + ⟨_+_⟩ : Set + + open R + + + : Set → Set + + A = A + ``` + + +Type checking +------------- + +* Agda now supports a cubical mode which adds new features from + [Cubical Type Theory](https://arxiv.org/abs/1611.02108), including + univalence and higher inductive types. Option `--cubical` enables + the cubical mode, and cubical primitives are defined in the module + `Agda.Primitive.Cubical`. See the [user + manual](https://agda.readthedocs.io/en/v2.6.0/language/cubical.html) + for more info. + +* Agda now supports the new sort ``Prop`` of [definitionally + proof-irrelevant propositions](https://hal.inria.fr/hal-01859964). + Option `--prop` enables the `Prop` universe but is off by default. + Option `--no-prop` disables the `Prop` universe. See the [user + manual](https://agda.readthedocs.io/en/v2.6.0/language/prop.html) + for more details. + + In the absense of `Prop`, the sort `Set` is the lowest sort, thus, + the sort annotation `: Set` can be ommitted if the sort is + constrained to be weakly below `Set`. For instance: + + ```agda + {-# OPTIONS --no-prop #-} + + data Wrap A : Set where + wrap : A → Wrap A + ``` + + In contrast, when `--prop` is enabled the sort of `A` could be + either `Set` or `Prop` so this code no longer typechecks. + +* Agda now allows omitting absurd clauses in case one of the pattern + variable inhabits an obviously empty type + [Issue [#1086](https://github.com/agda/agda/issues/1086)]. + For example: + ```agda + f : Fin 1 → Nat + f zero = 0 + -- f (suc ()) -- this clause is no longer required + ``` + Absurd clauses are still required in case deep pattern matching is + needed to expose the absurd variable, or if there are no non-absurd + clauses. + + Due to the changes to the coverage checker required for this new + feature, Agda will now sometimes construct a different case tree when + there are multiple valid splitting orders. In some cases this may + impact the constraints that Agda is able to solve (for example, see + [#673](https://github.com/agda/agda-stdlib/pull/673) on the + standard library). + +* Since Agda 2.5.3, the hiding is considered part of the name in the + insertion of implicit arguments. Until Agda 2.5.2, the following + code was rejected: + ```agda + test : {{X : Set}} {X : Set} → Set + test {X = X} = X + ``` + The rationale was that named argument `X` is given with the wrong hiding. + The new rationale is that the hiding is considered part of the name, + distinguishing `{{X}}` from `{X}`. + This language change was accidential and has not been documented in + the 2.5.3 release notes. + +* Agda no longer allows case splitting on irrelevant arguments of + record types (see Issue + [#3056](https://github.com/agda/agda/issues/3056)). + +* Metavariables in module telescopes are now sometimes frozen later + [Issue [#1063](https://github.com/agda/agda/issues/1063)]. + + Metavariables created in the types of module parameters used to be + frozen right after the module's first mutual block had been + type-checked (unless, perhaps, if the module itself was contained in + a mutual block). Now they are instead frozen at the end of the + module (with a similar caveat regarding an outer mutual block). + +* When `--without-K` is enabled, Agda no longer allows datatypes with + large indices. For example, the following definition of equality is + now forbidden when `--without-K` is enabled: + ```agda + data _≡₀_ {ℓ} {A : Set ℓ} (x : A) : A → Set where + refl : x ≡₀ x + ``` + +* The termination checker now also looks for recursive calls in the type of definitions. + This fixes an issue where Agda allowed very dependent types + [Issue [#1556](https://github.com/agda/agda/issues/1556)]. + + This change affects induction-induction, e.g. + ```agda + mutual + data Cxt : Set where + ε : Cxt + _,_ : (Γ : Cxt) (A : Ty Γ) → Cxt + + data Ty : (Γ : Cxt) → Set where + u : ∀ Γ → Ty Γ + Π : ∀ Γ (A : Ty Γ) (B : Ty (Γ , A)) → Ty Γ + + mutual + f : Cxt → Cxt + f ε = ε + f (Γ , T) = (f Γ , g Γ T) + + g : ∀ Γ → Ty Γ → Ty (f Γ) + g Γ (u .Γ) = u (f Γ) + g Γ (Π .Γ A B) = Π (f Γ) (g Γ A) (g (Γ , A) B) + + ``` + The type of `g` contains a call `g Γ _ --> f Γ` which is now taken + into account during termination checking. + +Instance search +--------------- + +* Instance argument resolution now also applies when there are + unconstrained metavariables in the type of the argument. For + example, if there is a single instance `eqBool : Eq Bool` in scope, + then an instance argument `{{eq : Eq _}}` will be solved to + `eqBool`, setting the value of the metavariable `_` to `Bool` in the + process. + +* By default, Agda no longer allows overlapping instances. Two + instances are defined to overlap if they could both solve the + instance goal when given appropriate solutions for their recursive + (instance) arguments. Agda used to choose between undecidable + instances based on the result of recursive instance search, but this + lead to an exponential slowdown in instance resolution. Overlapping + instances can be enabled with the flag `--overlapping-instances`. + +* Explicit arguments are no longer automatically turned into instance + arguments for the purpose of recursive instance search. Instead, + explicit arguments are left unresolved and will thus never be used + for instance search. + + If an instance is declared which has explicit arguments, Agda will + raise a warning that this instance will never be considered by + instance search. + +* Instance arguments that are already solved by conversion checking + are no longer ignored by instance search. Thus the constructor of + the unit type must now be explicitly be declared as an instance in + order to be considered by instance search: + ```agda + record ⊤ : Set where + instance constructor tt + ``` + +* Instances are now (correctly) required to be in scope to be eligible + (see Issue [#1913](https://github.com/agda/agda/issues/1913) + and Issue [#2489](https://github.com/agda/agda/issues/2489) + ). + This means that you can no longer import instances from parameterised modules by + ```agda + import Some.Module Arg₁ Arg2 + ``` + without opening or naming the module. + +Reflection +---------- + +* New TC primitive `noConstraints` [Issue + [#2351](https://github.com/agda/agda/issues/2351)]: + + ```agda + noConstraints : ∀ {a} {A : Set a} → TC A → TC A + ``` + + The computation `noConstraints m` fails if `m` gives rise to new, + unsolved + ["blocking"](https://github.com/agda/agda/blob/4900ef5fc61776381f3a5e9c94ef776375e9e1f1/src/full/Agda/TypeChecking/Monad/Constraints.hs#L160-L174) + constraints. + +* New TC primitive `runSpeculative` [Issue + [#3346](https://github.com/agda/agda/issues/3346)]: + + ``` + runSpeculative : ∀ {a} {A : Set a} → TC (Σ A λ _ → Bool) → TC A + ``` + + The computation `runSpeculative m` runs `m` and either keeps the new + TC state (if the second component is `true`) or resets to the old TC + state (if it is `false`). + + +Interaction and error reporting +------------------------------- + +* A new command `agda2-elaborate-give` (C-c C-m) normalizes a goal input + (it respects the C-u prefixes), type checks, and inserts the normalized + term into the goal. + +* 'Solve constraints' (C-c C-s) now turns unsolved metavariables into new + interaction holes (see Issue [#2273](https://github.com/agda/agda/issues/2273)). + +* Out-of-scope identifiers are no longer prefixed by a '.' dot [Issue + [#3127](https://github.com/agda/agda/issues/3127)]. This notation + could be confused with dot patterns, postfix projections, and + irrelevance. Now Agda will do its best to make up fresh names for + out-of-scope identifiers that do not conflict with any existing + names. In addition, these names are marked as "(out of scope)" when + printing the context. + + The change affects the printing of terms, e.g. in error messages and + interaction, and the parsing of out-of-scope variables for + case splitting (`C-c C-c` in emacs). + +* Shadowed local variables are now assigned fresh names in error + messages and interactive goals [Issue + [#572](https://github.com/agda/agda/issues/572)]. For example, + consider the following piece of code: + ```agda + postulate P : Set -> Set + + test : (B : Set) -> P B -> P B + test = λ p p -> {!!} + ``` + When asking for the goal type, Agda will now print the following: + ``` + Goal: P p₁ + ———————————————————————————————————————————————————————————— + p : P p₁ + p = p₁ : Set (not in scope) + ``` + Shadowed top-level identifiers are printed using the qualified name, + for example in + ```agda + module M where + + postulate A : Set + + test : Set → A + test A = {!!} + ``` + Agda will now show the goal type as + ``` + Goal: M.A + ———————————————————————————————————————————————————————————— + A : Set + ``` + +* When case splitting (`C-c C-c` in emacs), Agda will now filter out + impossible cases (i.e. ones where at least one of the variables + could be replaced by an absurd pattern `()`). If all the clauses + produced by a case split are impossible, Agda will not filter out + any of them. + +Pragmas and options +------------------- + +* Consistency checking of options used. + + Agda now checks that options used in imported modules are consistent + with each other, e.g. a module using `--safe`, `--without-K`, + `--no-universe-polymorphism` or `--no-sized-types` may only import + modules with the same option, and modules using `--cubical` or + `--prop` must in turn use the same option. If an interface file has + been generated using different options compared to the current ones, + Agda will now re-typecheck the file. + [Issue [#2487](https://github.com/agda/agda/issues/2487)]. + +* New option `--cubical` to enable Cubical Agda. + +* New option `--prop` to enable the ``Prop`` sort, and `--no-prop` to + disable it (default). + +* New options `--guardedness` and `--no-guardedness` [Issue + [#1209](https://github.com/agda/agda/issues/1209)]. + + Constructor-based guarded corecursion is now only (meant to be) + allowed if the `--guardedness` option is active. This option is + active by default. The combination of constructor-based guarded + corecursion and sized types is not allowed if `--safe` is used, + and activating `--safe` turns off both `--guardedness` and + `--sized-types` (because this combination is known to be + inconsistent in the current implementation). If you want to use + either constructor-based guarded corecursion or sized types in + safe mode, then you can use `--safe --guardedness` or `--safe + --sized-types` respectively (in this order). + + The option `--no-guardedness` turns off constructor-based guarded + corecursion. + +* Option `--irrelevant-projections` is now off by default and + not considered `--safe` any longer. + Reason: There are consistency issues that may be systemic + [Issue [#2170](https://github.com/agda/agda/issues/2170)]. + +* New option `--no-syntactic-equality` disables the syntactic equality + shortcut used by the conversion checker. This will slow down + typechecking in most cases, but makes the performance more + predictable and stable under minor changes. + +* New option `--overlapping-instances` enables overlapping instances + by performing recursive instance search during pruning of instance + candidates (this used to be the default behaviour). Overlapping + instances can be disabled with `--no-overlapping-instances` + (default). + +* Option (and experimental feature) + `--guardedness-preserving-type-constructors` + has been removed. + [Issue [#3180](https://github.com/agda/agda/issues/3180)]. + +* Deprecated options `--sharing` and `--no-sharing` now raise an error. + +* New primitive `primErase`. It takes a proof of equality and returns a proof of + the same equality. `primErase eq` reduces to `refl` on the diagonal. `trustMe` + is not a primitive anymore, it is implemented using `primErase`. + + The primitive is declared in `Agda.Builtin.Equality.Erase`. + +* The `REWRITE` builtin is now bound to the builtin equality type from + `Agda.Builtin.Equality` in `Agda.Builtin.Equality.Rewrite` [Issue + [#3318](https://github.com/agda/agda/issues/3318)]. + +* New primitives `primCharToNatInjective` and `primStringToListInjective` + internalising the fact that `primCharToNat` and `primStringtoList` are + injective functions. They are respectively bound in `Agda.Builtin.Char.Properties` + and `Agda.Builtin.String.Properties`. + +* The option `--only-scope-checking` is now allowed together with `--safe`. + +* The option `--ignore-interfaces` no longer ignores the interfaces of + builtin and primitive modules. For experts, there is the option + `--ignore-all-interfaces` which also rechecks builtin and primitive + files. + +* The following deprecated compiler pragmas have been removed: + + ``` + {-# COMPILED f e #-} + {-# COMPILED_TYPE A T #-} + {-# COMPILED_DATA A D C1 .. CN #-} + {-# COMPILED_DECLARE_DATA #-} + {-# COMPILED_EXPORT f g #-} + {-# IMPORT M #-} + {-# HASKELL code #-} + {-# COMPILED_UHC f e #-} + {-# COMPILED_DATA_UHC A D C1 .. CN #-} + {-# IMPORT_UHC M #-} + {-# COMPILED_JS f e #-} + ``` + + See the [user manual](https://agda.readthedocs.io/en/v2.6.0/language/foreign-function-interface.html) + for how to use the `COMPILE` and `FOREIGN` pragmas that replaced these in Agda 2.5. + +### New warnings + +* A declaration of the form `f : A` without an accompanying definition + is no longer an error, but instead raises a warning. + +* A clause that has both an absurd pattern and a right-hand side is no + longer an error, but instead raises a warning. + +* An import statement for `M` that mentions names not exported by `M` + (in either `using`, `hiding`, or `renaming`) is no longer an + error. Instead, Agda will raise a warning and ignore the names. + +* Pragma, primitive, module or import statements in a mutual block + are no longer errors. Instead, Agda will raise a warning and ignore + these statements. + +### Pragmas and options concerning universes + +* New pragma `{-# NO_UNIVERSE_CHECK #-}`. + + The pragma `{-# NO_UNIVERSE_CHECK #-}` can be put in front of a data + or record type to disable universe consistency checking locally. + Example: + ```agda + {-# NO_UNIVERSE_CHECK #-} + data U : Set where + el : Set → U + ``` + Like the similar pragmas for disabling termination and positivity + checking, `{-# NO_UNIVERSE_CHECK #-}` cannot be used with `--safe`. + +* New builtin `SETOMEGA`. + + Agda's top sort `Setω` is now defined as a builtin in `Agda.Primitive` + and can be renamed when importing that module. + +* New option `--omega-in-omega`. + + The option `--omega-in-omega` enables the typing rule `Setω : Setω`. + Example: + ```agda + {-# OPTIONS --omega-in-omega #-} + open import Agda.Primitive + + data Type : Setω where + el : ∀ {ℓ} → Set ℓ → Type + ``` + Like `--type-in-type`, this makes Agda inconsistent. However, code + written using `--omega-in-omega` is still compatible with normal + universe-polymorphic code and can be used in such files. + +Emacs mode +---------- + +* Jump-to-definition now works for record field names in record expressions + and patterns. [Issue [#3120](https://github.com/agda/agda/issues/3120)] + ```agda + record R : Set₂ where + field f : Set₁ + + exp : R + exp = record { f = Set } + + pat : R → R + pat r@record { f = X } = record r { f = X } + ``` + Jump-to-definition (`M-.` or middle-click) on any of these `f`s + now jumps to the field declaration. + +* Commas "ʻ،⸲⸴⹁⹉、︐︑﹐﹑，､" and semi-colons "؛⁏፤꛶；︔﹔⍮⸵;" added + to the input mode. + +* It is now possible to customise the highlighting of more text in + pragmas [Issue [#2452](https://github.com/agda/agda/issues/2452)]. + + Some text was already highlighted. Now there is a specific face for + the remaining text (`agda2-highlight-pragma-face`). + +LaTeX backend +------------- + +* The code environment has two new options, `inline` and `inline*`. + + These options are for typesetting inline code. The implementation of + these options is a bit of a hack. Only use these options for + typesetting a single line of code without multiple consecutive + whitespace characters (except at the beginning of the line). + + When the option `inline*` is used space (`\AgdaSpace{}`) is added at + the end of the code, and when `inline` is used space is not added. + +* Now highlighting commands for things like "this is an unsolved + meta-variable" are applied on the outside of highlighting commands + for things like "this is a postulate" [Issue + [#2474](https://github.com/agda/agda/issues/2474)]. + + Example: Instead of generating + `\AgdaPostulate{\AgdaUnsolvedMeta{F}}` Agda now generates + `\AgdaUnsolvedMeta{\AgdaPostulate{F}}`. + +* The package `agda.sty` no longer selects any fonts, and no longer + changes the input or font encodings [Issue + [#3224](https://github.com/agda/agda/issues/3224)]. + + The new behaviour is the same as the old behaviour with the options + `nofontsetup` and `noinputencodingsetup`. These options have been + removed. + + One reason for this change is that several persons have received + complaints from reviewers because they have unwittingly used + non-standard fonts in submitted papers. Another is that the `utf8x` + option to `inputenc` is now deprecated. + + Note that Agda code is now less likely to typeset properly out of + the box. See the documentation for some hints about what to do if + this affects you. + +* Some text was by default typeset in math mode when LuaLaTeX or + XeLaTeX were used, and in text mode when pdfLaTeX was used. Now text + mode is the default for all of these engines. + +* Typesetting of pragmas should now work better [Issue + [#2452](https://github.com/agda/agda/issues/2452)]. + + The `\AgdaOption` command and `AgdaOption` colour have been replaced + by `\AgdaPragma` and `AgdaPragma`. The `\AgdaPragma` command is used + where `\AgdaOption` used to be used (for certain options), but also + in other cases (for other options and certain other text in + pragmas). + +* There is no longer any special treatment of the character `-` [Issue + [#2452](https://github.com/agda/agda/issues/2452)]. + + This might, depending on things like what font your are using, mean + that the token `--` is typeset like an en dash (–). However, this is + not the case for at least one common monospace font (in at least one + setting). + +* The default value of `\AgdaEmptySkip` has been changed from + `\baselineskip` to `\abovedisplayskip`. This could mean that less + vertical space is used to render empty lines in code blocks. + +HTML backend +------------ + +* New option `--html-highlight=[code,all,auto]`. + + The option `--html-highlight=code` makes the HTML-backend generate + files with: + + 0. No HTML footer/header + 1. Agda codes highlighted + 2. Non-Agda code parts as-is + 3. Output file extension as-is (i.e. `.lagda.md` becomes `.md`) + 4. For ReStructuredText, a `.. raw:: html\n` will be inserted + before every code blocks + + This makes it possible to use an ordinary Markdown/ReStructuredText + processor to render the generated HTML. + + This will affect all the files involved in one compilation, making + pure Agda code files rendered without HTML footer/header as well. + To use `code` with literate Agda files and `all` with pure Agda + files, use `--html-highlight=auto`, which means auto-detection. + + The old and default behaviour is still `--html-highlight=all`. + +List of all closed issues +------------------------- + +For 2.6.0, the following issues have been closed +(see [bug tracker](https://github.com/agda/agda/issues)): + + - [#572](https://github.com/agda/agda/issues/572): Shadowed identifiers should be preceded by a dot when printed + - [#723](https://github.com/agda/agda/issues/723): Instance search needs to know whether a meta must be a function type + - [#758](https://github.com/agda/agda/issues/758): No highlighting for syntax declarations + - [#887](https://github.com/agda/agda/issues/887): Case-split causes problems for coverage checker + - [#952](https://github.com/agda/agda/issues/952): Parse named implicit pi {x = y : A} -> B + - [#1003](https://github.com/agda/agda/issues/1003): No highlighting for ambiguous instance argument + - [#1063](https://github.com/agda/agda/issues/1063): Freeze metas in module telescope after checking the module? + - [#1086](https://github.com/agda/agda/issues/1086): Make absurd patterns not needed at toplevel + - [#1209](https://github.com/agda/agda/issues/1209): Guardedness checker inconsistency with copatterns + - [#1581](https://github.com/agda/agda/issues/1581): Fields of opened records sometimes highlighted, sometimes not + - [#1602](https://github.com/agda/agda/issues/1602): NonStrict arguments should be allowed to occur relevantly in the type + - [#1706](https://github.com/agda/agda/issues/1706): Feature request: ML-style forall-generalization + - [#1764](https://github.com/agda/agda/issues/1764): Type in type and universe polymorphism + - [#1886](https://github.com/agda/agda/issues/1886): Second copies of telescopes not checked? + - [#1909](https://github.com/agda/agda/issues/1909): parameters are not dropped from reflected pattern lambda + - [#1913](https://github.com/agda/agda/issues/1913): Names that are not in scope can sometimes be candidates for instance resolution + - [#1995](https://github.com/agda/agda/issues/1995): Correct names in goal types after multiple renaming imports. + - [#2044](https://github.com/agda/agda/issues/2044): Better diagnosis for failed instance search + - [#2089](https://github.com/agda/agda/issues/2089): ''No such module'' is a rude error message for private modules + - [#2153](https://github.com/agda/agda/issues/2153): PDF version of Language Documentation on readthedocs lacks most Unicode characters + - [#2273](https://github.com/agda/agda/issues/2273): C-c C-s should put new goals instead of underscores for unknown subterms + - [#2351](https://github.com/agda/agda/issues/2351): expose noConstraints to reflection framework + - [#2452](https://github.com/agda/agda/issues/2452): The LaTeX backend does not handle options very well + - [#2473](https://github.com/agda/agda/issues/2473): Don't reread the source code without checking that it is unchanged + - [#2487](https://github.com/agda/agda/issues/2487): Options used for different modules must be consistent with each other, and options used when loading an interface must be consistent with those used when the interface was created + - [#2489](https://github.com/agda/agda/issues/2489): Where clauses in functions leak instances to global instance search + - [#2490](https://github.com/agda/agda/issues/2490): possible non-terminating inference of instance arguments? + - [#2513](https://github.com/agda/agda/issues/2513): Extensible syntax for function space annotations + - [#2548](https://github.com/agda/agda/issues/2548): Move the "Old Reference Manual" to the current documentation + - [#2563](https://github.com/agda/agda/issues/2563): Improve documentation and error reporting related to instance resolution (especially unconstrained metavariables) + - [#2579](https://github.com/agda/agda/issues/2579): Import statements with module instantiation should not trigger an error message + - [#2618](https://github.com/agda/agda/issues/2618): Reflection and pattern-matching lambdas + - [#2670](https://github.com/agda/agda/issues/2670): Instance arguments and multi-sorted algebras + - [#2757](https://github.com/agda/agda/issues/2757): Proposal: split non-strict relevance into shape-irrelevance, parametricity, and runtime-irrelevance + - [#2760](https://github.com/agda/agda/issues/2760): Relax instance search restriction on unconstrained metas + - [#2774](https://github.com/agda/agda/issues/2774): Internal error with sized types + - [#2783](https://github.com/agda/agda/issues/2783): Make more primitive/builtin modules safe? + - [#2789](https://github.com/agda/agda/issues/2789): Narrow and broad options + - [#2791](https://github.com/agda/agda/issues/2791): More illtyped meta solutions + - [#2797](https://github.com/agda/agda/issues/2797): Relevance check missed for overloaded projection + - [#2833](https://github.com/agda/agda/issues/2833): Coverage checker splits on result too eagerly + - [#2837](https://github.com/agda/agda/issues/2837): The Emacs mode only handles LaTeX-based literate Agda + - [#2872](https://github.com/agda/agda/issues/2872): Case splitting adds a dot in front of pattern matches on Chars + - [#2880](https://github.com/agda/agda/issues/2880): Disallow FFI binding for defined functions when --safe is used + - [#2892](https://github.com/agda/agda/issues/2892): 'With' should also abstract over the type of stripped dot patterns + - [#2893](https://github.com/agda/agda/issues/2893): Display warnings also when an error is encountered + - [#2899](https://github.com/agda/agda/issues/2899): Add a warning for infix notations without corresponding fixity declaration + - [#2929](https://github.com/agda/agda/issues/2929): Turn "missing definition" into a warning + - [#2936](https://github.com/agda/agda/issues/2936): Sort warning flags alphabetically in user manual + - [#2939](https://github.com/agda/agda/issues/2939): make install-bin on a Mac can fail to install text-icu + - [#2964](https://github.com/agda/agda/issues/2964): Mismatch between order of matching in clauses and case tree; subject reduction broken + - [#2969](https://github.com/agda/agda/issues/2969): Module parameter is erased from dot pattern + - [#2979](https://github.com/agda/agda/issues/2979): Rewriting matching does not respect eta rules + - [#2993](https://github.com/agda/agda/issues/2993): Quadratic (failing) instance search + - [#3010](https://github.com/agda/agda/issues/3010): Field of opened record does not get highlighted + - [#3032](https://github.com/agda/agda/issues/3032): spurious meta in dot pattern + - [#3056](https://github.com/agda/agda/issues/3056): Matching on irrelevant variable of dependent record type should not be allowed + - [#3057](https://github.com/agda/agda/issues/3057): A module can export two definitions with the same name + - [#3068](https://github.com/agda/agda/issues/3068): Add option to turn off syntactic equality check + - [#3095](https://github.com/agda/agda/issues/3095): Would like to make hidden variable visible but it is created ambiguous + - [#3102](https://github.com/agda/agda/issues/3102): Performance regression: very slow reduction in the presence of many module parameters + - [#3114](https://github.com/agda/agda/issues/3114): Missing alpha-renaming when printing constraints + - [#3120](https://github.com/agda/agda/issues/3120): No tooltips for record field names in record expressions + - [#3122](https://github.com/agda/agda/issues/3122): Hidden record fields are not picked up from module in record expression + - [#3124](https://github.com/agda/agda/issues/3124): De Bruijn index in lhs checking error message + - [#3125](https://github.com/agda/agda/issues/3125): Internal error in InstanceArguments.hs:292 + - [#3127](https://github.com/agda/agda/issues/3127): Notation for out-of-scope variables conflicts with notation for irrelevance + - [#3128](https://github.com/agda/agda/issues/3128): Sigma builtin not added to setup, agdai file missing. + - [#3130](https://github.com/agda/agda/issues/3130): Conflict between dot pattern and postfix projection + - [#3137](https://github.com/agda/agda/issues/3137): Preserve Markdown as-is when outputting HTML + - [#3138](https://github.com/agda/agda/issues/3138): Result splitter introduces pattern variable that conflicts with constructor + - [#3139](https://github.com/agda/agda/issues/3139): Internal error in parser + - [#3147](https://github.com/agda/agda/issues/3147): Non-linear as-patterns + - [#3152](https://github.com/agda/agda/issues/3152): `give` in a do-block inserts spurious parentheses + - [#3153](https://github.com/agda/agda/issues/3153): Type checker fails to infer missing signature of module parameter. + - [#3161](https://github.com/agda/agda/issues/3161): Case splitter produces end-of-comment + - [#3169](https://github.com/agda/agda/issues/3169): Doc for rewriting + - [#3170](https://github.com/agda/agda/issues/3170): UnicodeDeclare fails with pdflatex from TeX Live 2018 + - [#3175](https://github.com/agda/agda/issues/3175): Instance resolution fails with defined method + - [#3176](https://github.com/agda/agda/issues/3176): Empty lambdas are sometimes considered definitionally equal, other times not + - [#3180](https://github.com/agda/agda/issues/3180): Remove feature `--guardedness-preserving-type-constructors` + - [#3188](https://github.com/agda/agda/issues/3188): Warnings disappear when fatal error is encountered + - [#3195](https://github.com/agda/agda/issues/3195): Internal error at Auto/Typecheck.hs:373 + - [#3196](https://github.com/agda/agda/issues/3196): Turning MissingDefinition into a warning + - [#3200](https://github.com/agda/agda/issues/3200): Function marked as irrelevant when it isn't + - [#3201](https://github.com/agda/agda/issues/3201): [ warning ] AbsurdPatternRequiresNoRHS + - [#3205](https://github.com/agda/agda/issues/3205): [ cleanup + warning ] ModuleDoesntExport can be recovered from + - [#3224](https://github.com/agda/agda/issues/3224): Switch from utf8x to utf8? Make agda.sty easier to maintain? + - [#3235](https://github.com/agda/agda/issues/3235): Cannot pass backend flags via emacs variable `agda2-program-args` + - [#3247](https://github.com/agda/agda/issues/3247): Support cabal-install >= 2.4.1.0 in the Makefile + - [#3248](https://github.com/agda/agda/issues/3248): Max of two sizes less than i + - [#3253](https://github.com/agda/agda/issues/3253): [ fix ] ignore duplicate declarations of libraries + - [#3254](https://github.com/agda/agda/issues/3254): `cpphs` doesn't build with GHC 8.6.* + - [#3256](https://github.com/agda/agda/issues/3256): Internal error at src/full/Agda/TypeChecking/Reduce.hs:148 + - [#3257](https://github.com/agda/agda/issues/3257): Anonymous top-level modules can have names with multiple components + - [#3258](https://github.com/agda/agda/issues/3258): Ordering the constructor names at Definition. + - [#3262](https://github.com/agda/agda/issues/3262): Suboptimal placement of "missing with-clauses" error + - [#3264](https://github.com/agda/agda/issues/3264): When refine leads to a termination error it should say so rather than "cannot refine" + - [#3268](https://github.com/agda/agda/issues/3268): [ haddock ] Fix haddock formatting + - [#3285](https://github.com/agda/agda/issues/3285): Internal error for syntax declaration + - [#3302](https://github.com/agda/agda/issues/3302): Multiple definitions called _ are sometimes allowed, sometimes not + - [#3307](https://github.com/agda/agda/issues/3307): `--no-unicode` bug: case splitting inside a pattern matching lambda still produces unicode arrows + - [#3309](https://github.com/agda/agda/issues/3309): Use of irrelevant arguments with copatterns and irrelevant fields + - [#3313](https://github.com/agda/agda/issues/3313): Add --html-highlight support for the HTML backend + - [#3315](https://github.com/agda/agda/issues/3315): The primErase primitive is not safe + - [#3318](https://github.com/agda/agda/issues/3318): Lots of primitives and builtins are not declared in the primitive/builtin modules + - [#3320](https://github.com/agda/agda/issues/3320): Extra indentation when code is hidden + - [#3323](https://github.com/agda/agda/issues/3323): Internal error with inconsistent irrelevance info between declaration and definition of data type + - [#3338](https://github.com/agda/agda/issues/3338): Missing Definitions not recognised in instance search + - [#3342](https://github.com/agda/agda/issues/3342): GHC panic on stack and GHC 7.10.3 + - [#3344](https://github.com/agda/agda/issues/3344): Disable compilation with GHC 8.6.1 + - [#3356](https://github.com/agda/agda/issues/3356): C-c C-s prints postfix projections by default + - [#3363](https://github.com/agda/agda/issues/3363): The wiki should support HTTPS + - [#3364](https://github.com/agda/agda/issues/3364): Funny scope error when trying to import as qualified + - [#3366](https://github.com/agda/agda/issues/3366): Add a command line flag to change the extension of the files generated by the HTML backend + - [#3368](https://github.com/agda/agda/issues/3368): Support GHC 8.6.2 + - [#3370](https://github.com/agda/agda/issues/3370): [ fix ] < and > need to be in math mode in latex + - [#3371](https://github.com/agda/agda/issues/3371): Document common LaTeX backend pitfalls + - [#3372](https://github.com/agda/agda/issues/3372): Provide some simple LaTeX backend templates + - [#3373](https://github.com/agda/agda/issues/3373): Wrap HTML in `raw` directive when working with ReStructuredText + - [#3379](https://github.com/agda/agda/issues/3379): Adding a tutorial set in the readthedocs frontpage + - [#3380](https://github.com/agda/agda/issues/3380): Too much erasure in strict backends + - [#3394](https://github.com/agda/agda/issues/3394): Internal error in mutual block with unsolved implicit argument in termination checker + - [#3400](https://github.com/agda/agda/issues/3400): Obscure parse error with copattern and infix field + - [#3403](https://github.com/agda/agda/issues/3403): Internal error in Agda.TypeChecking.Rules.Term + - [#3404](https://github.com/agda/agda/issues/3404): Positivity checker marks postulates as constant in mutual block + - [#3407](https://github.com/agda/agda/issues/3407): Internal error at "src/full/Agda/TypeChecking/Reduce/Fast.hs:1338" + - [#3409](https://github.com/agda/agda/issues/3409): No error if mapping the empty type to non-empty Haskell type + - [#3410](https://github.com/agda/agda/issues/3410): ghc backend generates program that segfaults + - [#3419](https://github.com/agda/agda/issues/3419): Allow unconstrained instances & disallow overlapping instances + - [#3420](https://github.com/agda/agda/issues/3420): Inductive definitions live in a larger set --without-K + - [#3425](https://github.com/agda/agda/issues/3425): Internal error at src/full/Agda/Termination/Monad.hs:177 + - [#3426](https://github.com/agda/agda/issues/3426): Termination checking false positive when using "where" + - [#3428](https://github.com/agda/agda/issues/3428): Another interal error in Substitute:72 when filling a hole + - [#3431](https://github.com/agda/agda/issues/3431): Rewrite rule doesn't fire during conversion checking + - [#3434](https://github.com/agda/agda/issues/3434): Regression related to instance resolution + - [#3435](https://github.com/agda/agda/issues/3435): Performance regression + - [#3439](https://github.com/agda/agda/issues/3439): Setω doesn’t respect --type-in-type + - [#3441](https://github.com/agda/agda/issues/3441): Generate Level expressions with fewer parentheses + - [#3442](https://github.com/agda/agda/issues/3442): Support GHC 8.6.3 + - [#3443](https://github.com/agda/agda/issues/3443): "internal error" in Agda of December 7, 2018 + - [#3444](https://github.com/agda/agda/issues/3444): `Setup.hs` is not generating the interface files + - [#3445](https://github.com/agda/agda/issues/3445): case splitting attempts to shadow constructor + - [#3451](https://github.com/agda/agda/issues/3451): The --no-sized-types option is broken + - [#3452](https://github.com/agda/agda/issues/3452): Case split on irrelevant argument goes through but is later rejected + - [#3454](https://github.com/agda/agda/issues/3454): Highlighting for incomplete pattern matching should be above highliting for non-exact split + - [#3456](https://github.com/agda/agda/issues/3456): [ new ] Injectivity of prim(NatToChar/StringToList) + - [#3461](https://github.com/agda/agda/issues/3461): Macro loop + - [#3463](https://github.com/agda/agda/issues/3463): Impossible to give certain instance arguments by name? + - [#3466](https://github.com/agda/agda/issues/3466): two definitionally equal terms are not equal + - [#3471](https://github.com/agda/agda/issues/3471): Can't install via cabal-install on current Haskell Platform + - [#3480](https://github.com/agda/agda/issues/3480): Parse error at EOF should be reported before EOF (especially if there is a long comment before EOF) + - [#3483](https://github.com/agda/agda/issues/3483): Internal error at TypeChecking/Monad/Signature.hs:732 + - [#3485](https://github.com/agda/agda/issues/3485): [ warnings ] for empty primitive blocks + - [#3491](https://github.com/agda/agda/issues/3491): Internal error src/full/Agda/TypeChecking/Rules/LHS.hs:294 after pattern matching + - [#3498](https://github.com/agda/agda/issues/3498): Internal error in activateLoadedFileCache + - [#3501](https://github.com/agda/agda/issues/3501): Case split in let clause causes internal error + - [#3503](https://github.com/agda/agda/issues/3503): Internal error in BasicOps + - [#3514](https://github.com/agda/agda/issues/3514): Accidential language change in 2.5.3: hiding is now part of name when resolving hidden argument insertion + - [#3517](https://github.com/agda/agda/issues/3517): Option consistency checking bug + - [#3518](https://github.com/agda/agda/issues/3518): Performance regression + - [#3521](https://github.com/agda/agda/issues/3521): Documentation: fixes a plural issue in copatterns + - [#3526](https://github.com/agda/agda/issues/3526): Do not generate trivially impossible clause when case-splitting + - [#3533](https://github.com/agda/agda/issues/3533): [ fix #3526 ] Remove trivially impossible clauses from case-split + - [#3534](https://github.com/agda/agda/issues/3534): Problem finding higher-order instances + - [#3536](https://github.com/agda/agda/issues/3536): Patternmatching on coinductive record fields breaks + - [#3544](https://github.com/agda/agda/issues/3544): internal error @ TypeChecking/Forcing.hs:227 + - [#3548](https://github.com/agda/agda/issues/3548): [ new ] Add support for compiling literate Org documents + - [#3554](https://github.com/agda/agda/issues/3554): Type checker explosion + - [#3561](https://github.com/agda/agda/issues/3561): fix typo: "FreBSD" => "FreeBSD" + - [#3566](https://github.com/agda/agda/issues/3566): Missing name when printing type of definition of a record + - [#3578](https://github.com/agda/agda/issues/3578): Pattern matching unifier normalizes too much + - [#3586](https://github.com/agda/agda/issues/3586): Internal error in ConcreteToAbstract.hs:2217 + - [#3590](https://github.com/agda/agda/issues/3590): Superlinear time required for simple code + - [#3597](https://github.com/agda/agda/issues/3597): Agda loops on simple code with a record and a hole + - [#3600](https://github.com/agda/agda/issues/3600): Size solver complains, explicit sizes work + - [#3610](https://github.com/agda/agda/issues/3610): Support GHC 8.6.4 + - [#3621](https://github.com/agda/agda/issues/3621): performance problem + - [#3631](https://github.com/agda/agda/issues/3631): Performance with --no-universe-polymorphism + - [#3638](https://github.com/agda/agda/issues/3638): Rewrite rules do not fire in goal normalization in parametrized module + - [#3639](https://github.com/agda/agda/issues/3639): Argument to function created by tactic is lost + - [#3640](https://github.com/agda/agda/issues/3640): Polarity: Size index check crashes due to wrong parameter number calculation + - [#3641](https://github.com/agda/agda/issues/3641): Remove old compiler pragmas + - [#3648](https://github.com/agda/agda/issues/3648): Agda could fail to build if a .agda-lib file exists in a parent directory + - [#3651](https://github.com/agda/agda/issues/3651): internal error ghc backend + - [#3657](https://github.com/agda/agda/issues/3657): Disable compilation with Windows and GHC 8.6.3 + - [#3678](https://github.com/agda/agda/issues/3678): Two out-of-scope variables are given the same name + - [#3687](https://github.com/agda/agda/issues/3687): Show module contents (C-c C-o) prints garbled names in clause diff --git a/doc/user-manual.pdf b/doc/user-manual.pdf Binary files a/doc/user-manual.pdf and b/doc/user-manual.pdf differ diff --git a/src/data/Agda.css b/src/data/Agda.css --- a/src/data/Agda.css +++ b/src/data/Agda.css @@ -24,13 +24,15 @@ .Agda .Record { color: #0000CD } /* OtherAspects. */ -.Agda .DottedPattern {} -.Agda .UnsolvedMeta { color: black; background: yellow } -.Agda .UnsolvedConstraint { color: black; background: yellow } -.Agda .TerminationProblem { color: black; background: #FFA07A } -.Agda .IncompletePattern { color: black; background: #F5DEB3 } -.Agda .Error { color: red; text-decoration: underline } -.Agda .TypeChecks { color: black; background: #ADD8E6 } +.Agda .DottedPattern {} +.Agda .UnsolvedMeta { color: black; background: yellow } +.Agda .UnsolvedConstraint { color: black; background: yellow } +.Agda .TerminationProblem { color: black; background: #FFA07A } +.Agda .IncompletePattern { color: black; background: #F5DEB3 } +.Agda .Error { color: red; text-decoration: underline } +.Agda .TypeChecks { color: black; background: #ADD8E6 } +.Agda .Deadcode { color: black; background: #808080 } +.Agda .ShadowingInTelescope { color: black; background: #808080 } /* Standard attributes. */ .Agda a { text-decoration: none } diff --git a/src/data/MAlonzo/src/MAlonzo/RTE.hs b/src/data/MAlonzo/src/MAlonzo/RTE.hs --- a/src/data/MAlonzo/src/MAlonzo/RTE.hs +++ b/src/data/MAlonzo/src/MAlonzo/RTE.hs @@ -4,13 +4,16 @@ module MAlonzo.RTE where import Unsafe.Coerce -#if __GLASGOW_HASKELL__ >= 800 import qualified GHC.Exts as GHC (Any) +import qualified Data.Word +import Numeric.IEEE ( IEEE(identicalIEEE, nan) ) +#if __GLASGOW_HASKELL__ >= 804 +import GHC.Float (castDoubleToWord64) #else -import qualified GHC.Prim as GHC (Any) +import System.IO.Unsafe (unsafePerformIO) +import qualified Foreign as F +import qualified Foreign.Storable as F #endif -import qualified Data.Word -import Numeric.IEEE ( IEEE(identicalIEEE) ) type AgdaAny = GHC.Any @@ -24,8 +27,9 @@ data QName = QName { nameId, moduleId :: Integer, qnameString :: String, qnameFixity :: Fixity } data Assoc = NonAssoc | LeftAssoc | RightAssoc -data Precedence = Unrelated | Related Integer +data Precedence = Unrelated | Related PrecedenceLevel data Fixity = Fixity Assoc Precedence +type PrecedenceLevel = Double instance Eq QName where QName a b _ _ == QName c d _ _ = (a, b) == (c, d) @@ -108,6 +112,21 @@ ltFloat x y = case compareFloat x y of LT -> True _ -> False + +#if __GLASGOW_HASKELL__ < 804 +castDoubleToWord64 :: Double -> Word64 +castDoubleToWord64 float = unsafePerformIO $ F.alloca $ \buf -> do + F.poke (F.castPtr buf) float + F.peek buf +#endif + +normaliseNaN :: Double -> Double +normaliseNaN x + | isNaN x = nan + | otherwise = x + +doubleToWord64 :: Double -> Word64 +doubleToWord64 = castDoubleToWord64 . normaliseNaN -- Words -- diff --git a/src/data/agda.sty b/src/data/agda.sty --- a/src/data/agda.sty +++ b/src/data/agda.sty @@ -5,7 +5,7 @@ \ProvidesPackage{agda} \RequirePackage{ifxetex, ifluatex, xifthen, xcolor, polytable, etoolbox, - calc, environ, xparse} + calc, environ, xparse, xkeyval} % https://tex.stackexchange.com/questions/47576/combining-ifxetex-and-ifluatex-with-the-logical-or-operation \newif\ifxetexorluatex @@ -159,6 +159,7 @@ % Other aspect colours. \definecolor{AgdaDottedPattern} {HTML}{000000} \definecolor{AgdaUnsolvedMeta} {HTML}{D3D3D3} + \definecolor{AgdaUnsolvedConstraint}{HTML}{D3D3D3} \definecolor{AgdaTerminationProblem}{HTML}{BEBEBE} \definecolor{AgdaIncompletePattern} {HTML}{D3D3D3} \definecolor{AgdaError} {HTML}{696969} @@ -197,6 +198,7 @@ % Other aspect colours. \definecolor{AgdaDottedPattern} {HTML}{000000} \definecolor{AgdaUnsolvedMeta} {HTML}{FFD700} + \definecolor{AgdaUnsolvedConstraint}{HTML}{FFD700} \definecolor{AgdaTerminationProblem}{HTML}{FF0000} \definecolor{AgdaIncompletePattern} {HTML}{A020F0} \definecolor{AgdaError} {HTML}{F4A460} @@ -234,6 +236,7 @@ % Other aspect colours. \definecolor{AgdaDottedPattern} {HTML}{000000} \definecolor{AgdaUnsolvedMeta} {HTML}{FFFF00} + \definecolor{AgdaUnsolvedConstraint}{HTML}{FFFF00} \definecolor{AgdaTerminationProblem}{HTML}{FFA07A} \definecolor{AgdaIncompletePattern} {HTML}{F5DEB3} \definecolor{AgdaError} {HTML}{FF0000} @@ -320,6 +323,8 @@ \newcommand{\AgdaDottedPattern} [1]{\textcolor{AgdaDottedPattern}{#1}} \newcommand{\AgdaUnsolvedMeta} [1] {\AgdaFontStyle{\colorbox{AgdaUnsolvedMeta}{#1}}} +\newcommand{\AgdaUnsolvedConstraint}[1] + {\AgdaFontStyle{\colorbox{AgdaUnsolvedConstraint}{#1}}} \newcommand{\AgdaTerminationProblem}[1] {\AgdaFontStyle{\colorbox{AgdaTerminationProblem}{#1}}} \newcommand{\AgdaIncompletePattern} [1]{\colorbox{AgdaIncompletePattern}{#1}} @@ -523,34 +528,74 @@ % \AgdaEmptySkip and \baselineskip). Used internally. \newlength{\AgdaEmptyExtraSkip} +% Counter used for code numbers. +\newcounter{AgdaCodeNumber} +% Formats a code number. +\newcommand{\AgdaFormatCodeNumber}[1]{(#1)} + +% A boolean used to handle the option number. +\newboolean{Agda@Number} +\setboolean{Agda@Number}{false} + +% A boolean used to handle the option inline*. (For some reason the +% approach used for hide and inline does not work for inline*.) +\newboolean{Agda@InlineStar} +\setboolean{Agda@InlineStar}{false} + +% Keys used by the code environment. +\define@boolkey[Agda]{code}{hide}[true]{} +\define@boolkey[Agda]{code}{inline}[true]{} +\define@boolkey[Agda]{code}{inline*}[true]{% + \setboolean{Agda@InlineStar}{true}} +\define@key[Agda]{code}{number}[]{% + \ifthenelse{\boolean{Agda@Number}}{}{% + \setboolean{Agda@Number}{true}% + % Increase the counter if this has not already been done. + \refstepcounter{AgdaCodeNumber}}% + % If the label is non-empty, set it. Note that it is possible to + % give several labels for a single code listing. + \ifthenelse{\equal{#1}{}}{}{\label{#1}}} + % The code environment. % -% Code can be hidden by writing \begin{code}[hide]. +% Options: % -% Inline code can be emitted by writing \begin{code}[inline]. In this -% case most of the discussion above does not apply, alignment is not -% respected, and so on. It is recommended to only use this option for -% a single line of code, and to not use two consecutive spaces in this -% piece of code. +% * hide: The code is hidden. Other options are ignored. % -% Note that this environment ignores spaces after its end. If a space -% (\AgdaSpace{}) should be inserted after the inline code, use inline* -% instead of inline. +% * number: Give the code an equation number. % +% * number=l: Give the code an equation number and the label l. It is +% possible to use this option several times with different labels. +% +% * inline/inline*: The code is inlined. In this case most of the +% discussion above does not apply, alignment is not respected, and so +% on. It is recommended to only use this option for a single line of +% code, and to not use two consecutive spaces in this piece of code. +% +% Note that this environment ignores spaces after its end. If a space +% (\AgdaSpace{}) should be inserted after the inline code, use +% inline*, otherwise use inline. +% +% When this option is used number is ignored. +% % The implementation is based on plainhscode in lhs2TeX's % polycode.fmt, written by Andres Löh. \NewEnviron{code}[1][]{% - % Conditionally hide the code. - \ifthenelse{\equal{#1}{hide}}{}{% - \ifthenelse{\equal{#1}{inline}}{% + % Process the options. Complain about unknown options. + \setkeys[Agda]{code}[number]{#1}% + \ifAgda@code@hide% + % Hide the code. + \else% + \ifAgda@code@inline% % Inline code. % % Make the polytable primitives emitted by the LaTeX backend % do nothing. \DeclareDocumentCommand{\>}{O{}O{}}{}% \DeclareDocumentCommand{\<}{O{}}{}% - \AgdaCodeStyle\BODY}{% - \ifthenelse{\equal{#1}{inline*}}{% + \AgdaCodeStyle\BODY% + \else% + \ifthenelse{\boolean{Agda@InlineStar}}{% % Inline code with space at the end. % \DeclareDocumentCommand{\>}{O{}O{}}{}% @@ -567,6 +612,20 @@ \Agda@NewlineWithVerticalSpace{\abovedisplayskip}}{% \Agda@NewlineWithVerticalSpace{0pt}}% % + % Check if numbers have been requested. If they have, then a side + % effect of this call is that Agda@Number is set to true, the code + % number counter is increased, and the label (if any) is set. + \setkeys[Agda]{code}[hide,inline,inline*]{#1}% + \ifthenelse{\boolean{Agda@Number}}{% + % Equation numbers have been requested. Use a minipage, so that + % there is room for the code number to the right, and the code + % number becomes centered vertically. + \begin{minipage}{% + \linewidth-% + \widthof{% + \AgdaSpace{}% + \AgdaFormatCodeNumber{\theAgdaCodeNumber}}}}{}% + % % Indent the entire code block. \advance\leftskip\mathindent% % @@ -590,6 +649,12 @@ \BODY% \end{pboxed}% % + \ifthenelse{\boolean{Agda@Number}}{% + % Equation numbers have been requested. + \end{minipage}% + % Insert the code number to the right. + \hfill \AgdaFormatCodeNumber{\theAgdaCodeNumber}}{}% + % % Does the label Agda@DoNotSuppressAfter@ exist? \ifcsdef{r@Agda@DoNotSuppressSpaceAfter@\theAgda@Current}{% @@ -605,7 +670,12 @@ \Agda@NewlineWithVerticalSpace{0pt}}% % % Step the code block counter, but only for non-hidden code. - \stepcounter{Agda@Current}}}}} + \stepcounter{Agda@Current}}% + \fi% + \fi% + % Reset Agda@Number and Agda@InlineStar. + \setboolean{Agda@Number}{false}% + \setboolean{Agda@InlineStar}{false}} % Space inserted after tokens. \newcommand{\AgdaSpace}{ } diff --git a/src/data/emacs-mode/agda-input.el b/src/data/emacs-mode/agda-input.el --- a/src/data/emacs-mode/agda-input.el +++ b/src/data/emacs-mode/agda-input.el @@ -362,7 +362,7 @@ ("dr" . ,(agda-input-to-string-list "↘⇘ ⇲ ➴➷➘ ")) ("dl" . ,(agda-input-to-string-list "↙⇙ ")) - ("l-" . ("←")) ("<-" . ("←")) ("l=" . ("⇐")) + ("l-" . ("←")) ("<-" . ("←")) ("l=" . ("⇐")) ("<=" . ("⇐")) ("r-" . ("→")) ("->" . ("→")) ("r=" . ("⇒")) ("=>" . ("⇒")) ("u-" . ("↑")) ("u=" . ("⇑")) ("d-" . ("↓")) ("d=" . ("⇓")) @@ -654,7 +654,7 @@ ("Gd" . ("δ")) ("GD" . ("Δ")) ("Ge" . ("ε")) ("GE" . ("Ε")) ("Gz" . ("ζ")) ("GZ" . ("Ζ")) - ;; \eta \Eta + ("Gh" . ("η")) ("GH" . ("Η")) ("Gth" . ("θ")) ("GTH" . ("Θ")) ("Gi" . ("ι")) ("GI" . ("Ι")) ("Gk" . ("κ")) ("GK" . ("Κ")) @@ -708,6 +708,7 @@ ("Mie" . ("𝑒")) ("Mif" . ("𝑓")) ("Mig" . ("𝑔")) + ("Mih" . ("ℎ")) ("Mii" . ("𝑖")) ("Mij" . ("𝑗")) ("Mik" . ("𝑘")) @@ -884,10 +885,13 @@ ("MCz" . ("𝔃")) ("MfA" . ("𝔄")) ("MfB" . ("𝔅")) + ("MfC" . ("ℭ")) ("MfD" . ("𝔇")) ("MfE" . ("𝔈")) ("MfF" . ("𝔉")) ("MfG" . ("𝔊")) + ("MfH" . ("ℌ")) + ("MfI" . ("ℑ")) ("MfJ" . ("𝔍")) ("MfK" . ("𝔎")) ("MfL" . ("𝔏")) @@ -896,6 +900,7 @@ ("MfO" . ("𝔒")) ("MfP" . ("𝔓")) ("MfQ" . ("𝔔")) + ("MfR" . ("ℜ")) ("MfS" . ("𝔖")) ("MfT" . ("𝔗")) ("MfU" . ("𝔘")) @@ -903,6 +908,7 @@ ("MfW" . ("𝔚")) ("MfX" . ("𝔛")) ("MfY" . ("𝔜")) + ("MfZ" . ("ℨ")) ("Mfa" . ("𝔞")) ("Mfb" . ("𝔟")) ("Mfc" . ("𝔠")) @@ -931,9 +937,21 @@ ("Mfz" . ("𝔷")) ;; (Sub / Super) scripts + ;; + ;; Unicode 12.1 omits several latin characters from sub/superscript. + ;; https://www.quora.com/Why-is-there-no-character-for-superscript-q-in-Unicode + ;; + ;; Perhaps they will be added in future versions, however there are no + ;; proposals for it currently in the pipeline: + ;; https://www.unicode.org/alloc/Pipeline.html ("_a" . ("ₐ")) + ;; ("_b" . ("b")) + ;; ("_c" . ("c")) + ;; ("_d" . ("d")) ("_e" . ("ₑ")) + ;; ("_f" . ("f")) + ;; ("_g" . ("g")) ("_h" . ("ₕ")) ("_i" . ("ᵢ")) ("_j" . ("ⱼ")) @@ -943,11 +961,16 @@ ("_n" . ("ₙ")) ("_o" . ("ₒ")) ("_p" . ("ₚ")) + ;; ("_q" . ("q")) ("_r" . ("ᵣ")) ("_s" . ("ₛ")) ("_t" . ("ₜ")) ("_u" . ("ᵤ")) + ("_v" . ("ᵥ")) + ;; ("_w" . ("w")) ("_x" . ("ₓ")) + ;; ("_y" . ("y")) + ;; ("_z" . ("z")) ("^a" . ("ᵃ")) ("^b" . ("ᵇ")) @@ -965,6 +988,7 @@ ("^n" . ("ⁿ")) ("^o" . ("ᵒ")) ("^p" . ("ᵖ")) + ;; ("^q" . ("q")) ("^r" . ("ʳ")) ("^s" . ("ˢ")) ("^t" . ("ᵗ")) @@ -977,8 +1001,10 @@ ("^A" . ("ᴬ")) ("^B" . ("ᴮ")) + ;; ("^C" . ("C")) ("^D" . ("ᴰ")) ("^E" . ("ᴱ")) + ;; ("^F" . ("F")) ("^G" . ("ᴳ")) ("^H" . ("ᴴ")) ("^I" . ("ᴵ")) @@ -989,11 +1015,16 @@ ("^N" . ("ᴺ")) ("^O" . ("ᴼ")) ("^P" . ("ᴾ")) + ;; ("^Q" . ("Q")) ("^R" . ("ᴿ")) + ;; ("^S" . ("S")) ("^T" . ("ᵀ")) ("^U" . ("ᵁ")) ("^V" . ("ⱽ")) ("^W" . ("ᵂ")) + ;; ("^X" . ("X")) + ;; ("^Y" . ("Y")) + ;; ("^Z" . ("Z")) ;; Some ISO8859-1 characters. diff --git a/src/data/emacs-mode/agda2-highlight.el b/src/data/emacs-mode/agda2-highlight.el --- a/src/data/emacs-mode/agda2-highlight.el +++ b/src/data/emacs-mode/agda2-highlight.el @@ -233,17 +233,26 @@ :group 'agda2-highlight) (defface agda2-highlight-keyword-face - '((t (:foreground "DarkOrange3"))) + '((((background light)) + (:foreground "DarkOrange3")) + (((background dark)) + (:foreground "#FF9932"))) "The face used for keywords." :group 'agda2-highlight-faces) (defface agda2-highlight-string-face - '((t (:foreground "firebrick"))) + '((((background light)) + (:foreground "firebrick")) + (((background dark)) + (:foreground "#DD4D4D"))) "The face used for strings." :group 'agda2-highlight-faces) (defface agda2-highlight-number-face - '((t (:foreground "purple"))) + '((((background light)) + (:foreground "purple")) + (((background dark)) + (:foreground "#9010E0"))) "The face used for numbers." :group 'agda2-highlight-faces) @@ -256,7 +265,10 @@ :group 'agda2-highlight-faces) (defface agda2-highlight-primitive-type-face - '((t (:foreground "medium blue"))) + '((((background light)) + (:foreground "medium blue")) + (((background dark)) + (:foreground "#8080FF"))) "The face used for primitive types (like Set and Prop)." :group 'agda2-highlight-faces) @@ -271,37 +283,58 @@ :group 'agda2-highlight-faces) (defface agda2-highlight-inductive-constructor-face - '((t (:foreground "green4"))) + '((((background light)) + :foreground "green4") + (((background dark)) + :foreground "#29CC29")) "The face used for inductive constructors." :group 'agda2-highlight-faces) (defface agda2-highlight-coinductive-constructor-face - '((t (:foreground "gold4"))) + '((((background light)) + :foreground "gold4") + (((background dark)) + :foreground "#FFEA75")) "The face used for coinductive constructors." :group 'agda2-highlight-faces) (defface agda2-highlight-datatype-face - '((t (:foreground "medium blue"))) + '((((background light)) + (:foreground "medium blue")) + (((background dark)) + (:foreground "#8080FF"))) "The face used for datatypes." :group 'agda2-highlight-faces) (defface agda2-highlight-field-face - '((t (:foreground "DeepPink2"))) + '((((background light)) + (:foreground "DeepPink2")) + (((background dark)) + (:foreground "#F570B7"))) "The face used for record fields." :group 'agda2-highlight-faces) (defface agda2-highlight-function-face - '((t (:foreground "medium blue"))) + '((((background light)) + (:foreground "medium blue")) + (((background dark)) + (:foreground "#8080FF"))) "The face used for functions." :group 'agda2-highlight-faces) (defface agda2-highlight-module-face - '((t (:foreground "purple"))) + '((((background light)) + (:foreground "purple")) + (((background dark)) + (:foreground "#CD80FF"))) "The face used for module names." :group 'agda2-highlight-faces) (defface agda2-highlight-postulate-face - '((t (:foreground "medium blue"))) + '((((background light)) + (:foreground "medium blue")) + (((background dark)) + (:foreground "#8080FF"))) "The face used for postulates." :group 'agda2-highlight-faces) @@ -311,17 +344,26 @@ :group 'agda2-highlight-faces) (defface agda2-highlight-primitive-face - '((t (:foreground "medium blue"))) + '((((background light)) + (:foreground "medium blue")) + (((background dark)) + (:foreground "#8080FF"))) "The face used for primitive functions." :group 'agda2-highlight-faces) (defface agda2-highlight-macro-face - '((t (:foreground "aquamarine4"))) + '((((background light)) + (:foreground "aquamarine4")) + (((background dark)) + (:foreground "#73BAA2"))) "The face used for macros." :group 'agda2-highlight-faces) (defface agda2-highlight-record-face - '((t (:foreground "medium blue"))) + '((((background light)) + (:foreground "medium blue")) + (((background dark)) + (:foreground "#8080FF"))) "The face used for record types." :group 'agda2-highlight-faces) @@ -336,56 +378,106 @@ :group 'agda2-highlight-faces) (defface agda2-highlight-error-face - '((t (:foreground "red" :underline t))) + '((((background light)) + (:foreground "red" :underline t)) + (((background dark)) + (:foreground "#FF0000" :underline t))) "The face used for errors." :group 'agda2-highlight-faces) (defface agda2-highlight-unsolved-meta-face - '((t (:background "yellow"))) + '((((background light)) + (:background "yellow")) + (((background dark)) + (:background "#806B00"))) "The face used for unsolved meta variables." :group 'agda2-highlight-faces) (defface agda2-highlight-unsolved-constraint-face - '((t (:background "yellow"))) + '((((background light)) + (:background "yellow")) + (((background dark)) + (:background "#806B00"))) "The face used for unsolved constraints which are not connected to metas." :group 'agda2-highlight-faces) (defface agda2-highlight-termination-problem-face - '((t (:background "light salmon"))) + '((((background light)) + (:background "light salmon")) + (((background dark)) + (:background "#802400"))) "The face used for termination problems." :group 'agda2-highlight-faces) (defface agda2-highlight-positivity-problem-face - '((t (:background "peru"))) + '((((background light)) + (:background "peru")) + (((background dark)) + (:background "#803F00"))) "The face used for positivity problems." :group 'agda2-highlight-faces) (defface agda2-highlight-deadcode-face - '((t (:background "dark gray"))) + '((((background light)) + (:background "dark gray")) + (((background dark)) + (:background "#808080"))) "The face used for dead code (unreachable clauses, etc.)." :group 'agda2-highlight-faces) +(defface agda2-highlight-shadowing-in-telescope-face + '((((background light)) + (:background "dark gray")) + (((background dark)) + (:background "#808080"))) + "The face used for shadowed repeated variable names in telescopes." + :group 'agda2-highlight-faces) + (defface agda2-highlight-coverage-problem-face - '((t (:background "wheat"))) + '((((background light)) + (:background "wheat")) + (((background dark)) + (:background "#805300"))) "The face used for coverage problems." :group 'agda2-highlight-faces) (defface agda2-highlight-catchall-clause-face - '((t (:background "white smoke"))) + '((((background light)) + (:background "white smoke")) + (((background dark)) + (:background "#404040"))) "The face used for catchall clauses." :group 'agda2-highlight-faces) +(defface agda2-highlight-confluence-problem-face + '((((background light)) + (:background "pink")) + (((background dark)) + (:background "#800080"))) + "The face used for confluence problems." + :group 'agda2-highlight-faces) + +(defface agda2-highlight-missing-definition-face + '((((background light)) + (:background "orange")) + (((background dark)) + (:background "#804040"))) + "The face used for type declarations with missing definitions." + :group 'agda2-highlight-faces) + (defface agda2-highlight-typechecks-face - '((t (:background "light blue" - :foreground "black"))) + '((((background light)) + (:background "light blue" :foreground "black")) + (((background dark)) + (:background "#006080" :foreground "white"))) "The face used for code which is being type-checked." :group 'agda2-highlight-faces) (defvar agda2-highlight-faces '((keyword . agda2-highlight-keyword-face) (comment . font-lock-comment-face) - (background . font-lock-comment-face) - (markup . font-lock-comment-face) + (background . default) + (markup . font-lock-comment-delimiter-face) (string . agda2-highlight-string-face) (number . agda2-highlight-number-face) (symbol . agda2-highlight-symbol-face) @@ -410,18 +502,26 @@ (unsolvedconstraint . agda2-highlight-unsolved-constraint-face) (terminationproblem . agda2-highlight-termination-problem-face) (deadcode . agda2-highlight-deadcode-face) + (shadowingintelescope . agda2-highlight-shadowing-in-telescope-face) (coverageproblem . agda2-highlight-coverage-problem-face) (positivityproblem . agda2-highlight-positivity-problem-face) (incompletepattern . agda2-highlight-incomplete-pattern-face) (catchallclause . agda2-highlight-catchall-clause-face) + (confluenceproblem . agda2-highlight-confluence-problem-face) + (missingdefinition . agda2-highlight-missing-definition-face) (typechecks . agda2-highlight-typechecks-face)) "Alist mapping code aspects to the face used when displaying them. The aspects currently recognised are the following: +`background' Non-Agda code contents in literate mode. `bound' Bound variables. +`catchallclause' Clause not holding definitionally. `coinductiveconstructor' Coinductive constructors. +`comment' Comments. +`coverageproblem' Coverage problems. `datatype' Data types. +`deadcode' Deadcode (like unreachable clauses or RHS). `dotted' Dotted patterns. `error' Errors. `field' Record fields. @@ -430,31 +530,27 @@ `incompletepattern' Incomplete patterns. `inductiveconstructor' Inductive constructors. `keyword' Keywords. +`macro' Macros. +`markup' Delimiters to separate the Agda code blocks + from other contents. `module' Module names. `number' Numbers. `operator' Operators. +`positivityproblem' Positivity problems. `postulate' Postulates. `pragma' Text occurring in pragmas that does not have a more specific (syntactic) aspect. `primitive' Primitive functions. `primitivetype' Primitive types (like Set and Prop). -`macro' Macros. `record' Record types. +`shadowingintelescope' Shadowed repeated variable names in telescopes. `string' Strings. `symbol' Symbols like forall, =, ->, etc. `terminationproblem' Termination problems. -`positivityproblem' Positivity problems. -`deadcode' Deadcode (like unreachable clauses or RHS) -`coverageproblem' Coverage problems. -`catchallclause' Clause not holding definitionally. `typechecks' Code which is being type-checked. `unsolvedconstraint' Unsolved constraints, not connected to meta variables. -`unsolvedmeta' Unsolved meta variables. -`background' Non-Agda code contents in literate mode. -`markup' Delimiters to separate the Agda code blocks - from other contents -`comment' Comments.") +`unsolvedmeta' Unsolved meta variables.") ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ;; Variables diff --git a/src/data/emacs-mode/agda2-mode-pkg.el b/src/data/emacs-mode/agda2-mode-pkg.el --- a/src/data/emacs-mode/agda2-mode-pkg.el +++ b/src/data/emacs-mode/agda2-mode-pkg.el @@ -1,2 +1,2 @@ -(define-package "agda2-mode" "2.6.0.1" +(define-package "agda2-mode" "2.6.1" "interactive development for Agda, a dependently typed functional programming language") diff --git a/src/data/emacs-mode/agda2-mode.el b/src/data/emacs-mode/agda2-mode.el --- a/src/data/emacs-mode/agda2-mode.el +++ b/src/data/emacs-mode/agda2-mode.el @@ -10,7 +10,7 @@ ;;; Code: -(defvar agda2-version "2.6.0.1" +(defvar agda2-version "2.6.1" "The version of the Agda mode. Note that the same version of the Agda executable must be used.") @@ -327,12 +327,6 @@ ;; reference. If the agda2-*-brace definitions were inlined, then ;; goals would be displayed as "{{ }}n" instead of "{ }n". -(defvar agda2-measure-data nil - "Used by `agda2-measure-load-time'. -This value is either nil or a pair containing a continuation (or -nil) and the time at which the measurement was started.") -(make-variable-buffer-local 'agda2-measure-data) - ;; The following variables are used by the filter process, ;; `agda2-output-filter'. Their values are only modified by the filter ;; process, `agda2-go', `agda2-restart', `agda2-abort-highlighting', @@ -702,18 +696,7 @@ agda2-in-progress nil agda2-last-responses (nreverse agda2-last-responses)) - (agda2-run-last-commands) - - (when agda2-measure-data - (let ((elapsed - (format "%.2fs" - (float-time (time-since - (cdr agda2-measure-data))))) - (continuation (car agda2-measure-data))) - (setq agda2-measure-data nil) - (message "Load time: %s." elapsed) - (when continuation - (funcall continuation elapsed)))))))))) + (agda2-run-last-commands))))))) (defun agda2-run-last-commands nil "Execute the last commands in the right order. @@ -807,23 +790,6 @@ (agda2-list-quote agda2-program-args) )) -(defun agda2-measure-load-time - (&optional highlighting-level continuation) - "Load the current buffer and print how much time it takes. -\(Wall-clock time.) - -The given HIGHLIGHTING-LEVEL is used (if non-nil). - -If CONTINUATION is non-nil, then CONTINUATION is applied to the -resulting time (represented as a string)." - (interactive) - (when agda2-in-progress - (error "Agda is busy with something")) - (let* ((agda2-highlight-level - (or highlighting-level agda2-highlight-level))) - (setq agda2-measure-data (cons continuation (current-time))) - (agda2-load))) - (defun agda2-compile () "Compile the current module. @@ -927,17 +893,14 @@ "Replace the line at point with new clauses NEWCLS and reload." (agda2-forget-all-goals);; we reload later anyway. (let* ((p0 (point)) - ;; (p1 (goto-char (agda2-decl-beginning))) (p1 (goto-char (+ (current-indentation) (line-beginning-position)))) (indent (current-column)) cl) - (goto-char p0) - (re-search-forward "!}" (line-end-position) 'noerr) - (delete-region p1 (point)) + (delete-region p1 (line-end-position)) (while (setq cl (pop newcls)) (insert cl) (if newcls (insert "\n" (make-string indent ? )))) - (goto-char p1)) + (goto-char p0)) (agda2-load)) (defun agda2-make-case-action-extendlam (newcls) @@ -1128,105 +1091,146 @@ (agda2-remove-annotations) (agda2-term)) -(defun agda2-term () - "Interrupt the Agda process and kill its buffer." - (interactive) - (when (and agda2-process - (process-status agda2-process)) - (interrupt-process agda2-process)) - (when (buffer-live-p agda2-process-buffer) - (kill-buffer agda2-process-buffer))) - -(defmacro agda2-maybe-normalised (name comment cmd want) - "This macro constructs a function NAME which runs CMD. -COMMENT is used to build the function's comment. The function -NAME takes a prefix argument which tells whether it should -normalise types or not when running CMD (through -`agda2-goal-cmd'; WANT is used as `agda2-goal-cmd's WANT -argument, and nil as its SAVE argument)." - (let ((eval (make-symbol "eval"))) - `(defun ,name (&optional prefix) - ,(concat comment ". +(defun agda2-term (&optional nicely) + "Interrupt the Agda process and kill its buffer. +If this function is invoked with a prefix argument, then Agda is +asked nicely to terminate itself after any previously invoked +commands have completed." + (interactive "P") + (if nicely + (progn + ;; Set up things so that if the Agda process terminates, then + ;; its buffer is killed. + (when (and agda2-process + (process-status agda2-process)) + (set-process-sentinel agda2-process 'agda2-kill-process-buffer)) + ;; Kill the process buffer if the Agda process has already + ;; been killed. + (agda2-kill-process-buffer) + ;; Try to kill the Agda process. + (agda2-send-command nil + "IOTCM" + (agda2-string-quote (buffer-file-name)) + "None" + "Indirect" + "Cmd_exit")) + ;; Try to kill the Agda process and the process buffer. + (when (and agda2-process + (process-status agda2-process)) + (interrupt-process agda2-process)) + (when (buffer-live-p agda2-process-buffer) + (kill-buffer agda2-process-buffer)))) -The form of the result depends on the prefix argument: +(defun agda2-kill-process-buffer (&optional process event) + "Kills the Agda process buffer, if any. +But only if the Agda process does not exist or has terminated. -* If the prefix argument is `nil' (i.e., if no prefix argument is - given), then the result is simplified. +This function can be used as a process sentinel." + (when (and (or (null agda2-process) + (member (process-status agda2-process) + '(exit signal failed nil))) + (buffer-live-p agda2-process-buffer)) + (kill-buffer agda2-process-buffer))) -* If the prefix argument is `(4)' (for instance if C-u is typed - exactly once right before the command is invoked), then the - result is neither explicitly normalised nor simplified. +(cl-defmacro agda2--with-gensyms ((&rest names) &body body) + "Bind NAMES to fresh symbols in BODY" + (declare (indent 1)) + `(let ,(cl-loop for x in names collecting `(,x (make-symbol (symbol-name',x)))) + ,@body)) -* If any other prefix argument is used (for instance if C-u is - typed twice right before the command is invoked), then the - result is normalised.") - (interactive "P") - (let ((,eval (cond ((equal prefix nil) "Simplified") - ((equal prefix '(4)) "Instantiated") - ("Normalised")))) - (agda2-goal-cmd (concat ,cmd " " ,eval) - nil ,want))))) +;; This macro is meant to be used to generate other macros which define +;; functions which can be used either directly from a goal or at a global +;; level and are modifiable using one of three levels of normalisation. -(defmacro agda2-maybe-normalised-toplevel (name comment cmd prompt) +(defmacro agda2-proto-maybe-normalised (name comment cmd norm0 norm1 norm2 spec) "This macro constructs a function NAME which runs CMD. -COMMENT is used to build the function's comments. The function -NAME takes a prefix argument which tells whether it should -normalise types or not when running CMD (through -`agda2-go' nil nil 'busy t; the string PROMPT is used as the goal -command prompt)." - (let ((eval (make-symbol "eval"))) - `(defun ,name (prefix expr) - ,(concat comment ". +COMMENT is used to build the function's comment. +The function NAME takes a prefix argument which tells whether it +should normalise types according to either NORM0, NORM1, or NORM2 +when running CMD through `agda2-goal-cmd`. +SPEC can be either (fromgoal want) or (global prompt). +" + ;; Names bound in a macro should be ``uninterned'' to avoid name capture + ;; We use the macro `agda2--with-gensyms' to bind these. + (agda2--with-gensyms (eval prefix args) + `(defun ,name (,prefix &rest ,args) + ,(format "%s. + The form of the result depends on the prefix argument: * If the prefix argument is `nil' (i.e., if no prefix argument is - given), then the result is simplified. + given), then the result is %s. * If the prefix argument is `(4)' (for instance if C-u is typed exactly once right before the command is invoked), then the - result is neither explicitly normalised nor simplified. + result is %s. * If any other prefix argument is used (for instance if C-u is typed twice right before the command is invoked), then the - result is normalised.") - (interactive ,(concat "P\nM" prompt ": ")) - (let ((,eval (cond ((equal prefix nil) "Simplified") - ((equal prefix '(4)) "Instantiated") - ("Normalised")))) - (agda2-go nil nil 'busy t - (concat ,cmd " " ,eval " " - (agda2-string-quote expr))))))) + result is %s." comment (nth 1 norm0) (nth 1 norm1) (nth 1 norm2)) -(defmacro agda2-maybe-normalised-global (name comment cmd) - "This macro constructs a function NAME which runs CMD. -COMMENT is used to build the function's comments. The function -NAME takes a prefix argument which tells whether it should -normalise types or not when running CMD (through -`agda2-go' nil nil 'busy t;)." - (let ((eval (make-symbol "eval"))) - `(defun ,name (prefix) - ,(concat comment ". + ;; All the commands generated by the macro are interactive. + ;; Those called from a goal, grab the value present there (if any) + ;; Whereas those called globally always use a prompt + (interactive ,(pcase spec + (`(fromgoal ,want) + "P") + (`(global ,prompt) + (if prompt + (concat "P\nM" prompt ": ") + "P")))) + ;; Depending on the prefix's value we pick one of the three + ;; normalisation levels + (let ((,eval (cond ((null ,prefix) + ,(car norm0)) + ((equal ,prefix '(4)) + ,(car norm1)) + (t ,(car norm2))))) + ;; Finally, if the command is called from a goal, we use `agda2-goal-cmd' + ;; Otherwise we resort to `agda2-go' + ,(pcase spec + (`(fromgoal ,want) + `(agda2-goal-cmd (concat ,cmd " " ,eval) nil ,want)) + (`(global ,prompt) + `(agda2-go nil nil 'busy t + (concat ,cmd " " + ,eval " " + (if ,prompt + (agda2-string-quote (car ,args)) + ""))))))))) -The form of the result depends on the prefix argument: +(defmacro agda2-maybe-normalised (name comment cmd want) + `(agda2-proto-maybe-normalised + ,name ,comment ,cmd + ("Simplified" "simplified") + ("Instantiated" "neither explicitly normalised nor simplified") + ("Normalised" "normalised") + (fromgoal ,want))) -* If the prefix argument is `nil' (i.e., if no prefix argument is - given), then the result is simplified. +(defmacro agda2-maybe-normalised-asis (name comment cmd want) + `(agda2-proto-maybe-normalised + ,name ,comment ,cmd + ("AsIs" "returned as is") + ("Simplified" "simplified") + ("Normalised" "normalised") + (fromgoal ,want))) -* If the prefix argument is `(4)' (for instance if C-u is typed - exactly once right before the command is invoked), then the - result is neither explicitly normalised nor simplified. +(defmacro agda2-maybe-normalised-toplevel (name comment cmd prompt) + `(agda2-proto-maybe-normalised + ,name ,comment ,cmd + ("Simplified" "simplified") + ("Instantiated" "neither explicitly normalised nor simplified") + ("Normalised" "normalised") + (global ,prompt))) -* If any other prefix argument is used (for instance if C-u is - typed twice right before the command is invoked), then the - result is normalised.") - (interactive "P") - (let ((,eval (cond ((equal prefix nil) "AsIs") - ((equal prefix '(4)) "Simplified") - ("Normalised")))) - (agda2-go nil nil 'busy t - (concat ,cmd " " ,eval " " - )))))) +(defmacro agda2-maybe-normalised-toplevel-asis-noprompt (name comment cmd) + `(agda2-proto-maybe-normalised + ,name ,comment ,cmd + ("AsIs" "returned as is") + ("Simplified" "simplified") + ("Normalised" "normalised") + (global nil))) (agda2-maybe-normalised agda2-goal-type @@ -1306,7 +1310,7 @@ "Cmd_context" nil) -(agda2-maybe-normalised +(agda2-maybe-normalised-asis agda2-helper-function-type "Compute the type of a hypothetical helper function." "Cmd_helper_function" @@ -1363,11 +1367,11 @@ 'agda2-autoAll)) ) -(agda2-maybe-normalised-global - agda2-solveAll - "Solves all goals that are already instantiated internally." - "Cmd_solveAll" -) +(agda2-maybe-normalised-toplevel-asis-noprompt + agda2-solveAll + "Solves all goals that are already instantiated internally." + "Cmd_solveAll" + ) (agda2-maybe-normalised agda2-solveOne diff --git a/src/data/lib/prim/Agda/Builtin/Bool.agda b/src/data/lib/prim/Agda/Builtin/Bool.agda --- a/src/data/lib/prim/Agda/Builtin/Bool.agda +++ b/src/data/lib/prim/Agda/Builtin/Bool.agda @@ -1,4 +1,5 @@ -{-# OPTIONS --without-K --safe --no-universe-polymorphism --no-sized-types --no-guardedness #-} +{-# OPTIONS --without-K --safe --no-universe-polymorphism + --no-sized-types --no-guardedness --no-subtyping #-} module Agda.Builtin.Bool where diff --git a/src/data/lib/prim/Agda/Builtin/Char.agda b/src/data/lib/prim/Agda/Builtin/Char.agda --- a/src/data/lib/prim/Agda/Builtin/Char.agda +++ b/src/data/lib/prim/Agda/Builtin/Char.agda @@ -1,4 +1,5 @@ -{-# OPTIONS --without-K --safe --no-universe-polymorphism --no-sized-types --no-guardedness #-} +{-# OPTIONS --without-K --safe --no-universe-polymorphism + --no-sized-types --no-guardedness --no-subtyping #-} module Agda.Builtin.Char where diff --git a/src/data/lib/prim/Agda/Builtin/Char/Properties.agda b/src/data/lib/prim/Agda/Builtin/Char/Properties.agda --- a/src/data/lib/prim/Agda/Builtin/Char/Properties.agda +++ b/src/data/lib/prim/Agda/Builtin/Char/Properties.agda @@ -1,4 +1,5 @@ -{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness #-} +{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness + --no-subtyping #-} module Agda.Builtin.Char.Properties where diff --git a/src/data/lib/prim/Agda/Builtin/Coinduction.agda b/src/data/lib/prim/Agda/Builtin/Coinduction.agda --- a/src/data/lib/prim/Agda/Builtin/Coinduction.agda +++ b/src/data/lib/prim/Agda/Builtin/Coinduction.agda @@ -1,4 +1,5 @@ -{-# OPTIONS --without-K --safe --universe-polymorphism --no-sized-types --no-guardedness #-} +{-# OPTIONS --without-K --safe --universe-polymorphism --no-sized-types + --no-guardedness --no-subtyping #-} module Agda.Builtin.Coinduction where diff --git a/src/data/lib/prim/Agda/Builtin/Cubical/Glue.agda b/src/data/lib/prim/Agda/Builtin/Cubical/Glue.agda --- a/src/data/lib/prim/Agda/Builtin/Cubical/Glue.agda +++ b/src/data/lib/prim/Agda/Builtin/Cubical/Glue.agda @@ -1,4 +1,6 @@ -{-# OPTIONS --cubical --safe --no-sized-types --no-guardedness #-} +{-# OPTIONS --cubical --safe --no-sized-types --no-guardedness + --no-subtyping #-} + module Agda.Builtin.Cubical.Glue where open import Agda.Primitive @@ -8,45 +10,9 @@ itIsOne to 1=1) open import Agda.Builtin.Cubical.Path open import Agda.Builtin.Cubical.Sub renaming (Sub to _[_↦_]; primSubOut to ouc) - -module Helpers where - -- Homogeneous filling - hfill : ∀ {ℓ} {A : Set ℓ} {φ : I} - (u : ∀ i → Partial φ A) - (u0 : A [ φ ↦ u i0 ]) (i : I) → A - hfill {φ = φ} u u0 i = - hcomp (λ j → \ { (φ = i1) → u (i ∧ j) 1=1 - ; (i = i0) → ouc u0 }) - (ouc u0) - - -- Heterogeneous filling defined using comp - fill : ∀ {ℓ : I → Level} (A : ∀ i → Set (ℓ i)) {φ : I} - (u : ∀ i → Partial φ (A i)) - (u0 : A i0 [ φ ↦ u i0 ]) → - ∀ i → A i - fill A {φ = φ} u u0 i = - comp (λ j → A (i ∧ j)) _ - (λ j → \ { (φ = i1) → u (i ∧ j) 1=1 - ; (i = i0) → ouc u0 }) - (ouc {φ = φ} u0) - - module _ {ℓ} {A : Set ℓ} where - refl : {x : A} → x ≡ x - refl {x = x} = λ _ → x - - sym : {x y : A} → x ≡ y → y ≡ x - sym p = λ i → p (~ i) - - cong : ∀ {ℓ'} {B : A → Set ℓ'} {x y : A} - (f : (a : A) → B a) (p : x ≡ y) - → PathP (λ i → B (p i)) (f x) (f y) - cong f p = λ i → f (p i) - - isContr : ∀ {ℓ} → Set ℓ → Set ℓ - isContr A = Σ A \ x → (∀ y → x ≡ y) +import Agda.Builtin.Cubical.HCompU as HCompU - fiber : ∀ {ℓ ℓ'} {A : Set ℓ} {B : Set ℓ'} (f : A → B) (y : B) → Set (ℓ ⊔ ℓ') - fiber {A = A} f y = Σ A \ x → f x ≡ y +module Helpers = HCompU.Helpers open Helpers @@ -131,20 +97,20 @@ sys : A → ∀ i → PartialP (~ j ∨ j) (λ _ → E (~ i)) sys x i (j = i0) = v (~ i) y sys x i (j = i1) = u (~ i) x - ω0 = comp ~E _ (sys x0) ((β0 (~ j))) - ω1 = comp ~E _ (sys x1) ((β1 (~ j))) + ω0 = comp ~E (sys x0) ((β0 (~ j))) + ω1 = comp ~E (sys x1) ((β1 (~ j))) θ0 = fill ~E (sys x0) (inc (β0 (~ j))) θ1 = fill ~E (sys x1) (inc (β1 (~ j))) sys = λ {j (k = i0) → ω0 j ; j (k = i1) → ω1 j} ω = hcomp sys (g y) θ = hfill sys (inc (g y)) - δ = λ (j : I) → comp E _ + δ = λ (j : I) → comp E (λ i → λ { (j = i0) → v i y ; (k = i0) → θ0 j (~ i) ; (j = i1) → u i ω ; (k = i1) → θ1 j (~ i) }) (θ j) γ : (y : B) → y ≡ f (g y) - γ y j = comp E _ (λ i → λ { (j = i0) → v i y + γ y j = comp E (λ i → λ { (j = i0) → v i y ; (j = i1) → u i (g y) }) (g y) pathToisEquiv : isEquiv f @@ -155,5 +121,3 @@ pathToEquiv : A ≃ B pathToEquiv .fst = f pathToEquiv .snd = pathToisEquiv - -{-# BUILTIN PATHTOEQUIV pathToEquiv #-} diff --git a/src/data/lib/prim/Agda/Builtin/Cubical/HCompU.agda b/src/data/lib/prim/Agda/Builtin/Cubical/HCompU.agda new file mode 100644 --- /dev/null +++ b/src/data/lib/prim/Agda/Builtin/Cubical/HCompU.agda @@ -0,0 +1,73 @@ +{-# OPTIONS --cubical --safe --no-sized-types --no-guardedness + --no-subtyping #-} + +module Agda.Builtin.Cubical.HCompU where + +open import Agda.Primitive +open import Agda.Builtin.Sigma +open import Agda.Primitive.Cubical renaming (primINeg to ~_; primIMax to _∨_; primIMin to _∧_; + primHComp to hcomp; primTransp to transp; primComp to comp; + itIsOne to 1=1) +open import Agda.Builtin.Cubical.Path +open import Agda.Builtin.Cubical.Sub renaming (Sub to _[_↦_]; primSubOut to outS; inc to inS) + +module Helpers where + -- Homogeneous filling + hfill : ∀ {ℓ} {A : Set ℓ} {φ : I} + (u : ∀ i → Partial φ A) + (u0 : A [ φ ↦ u i0 ]) (i : I) → A + hfill {φ = φ} u u0 i = + hcomp (λ j → \ { (φ = i1) → u (i ∧ j) 1=1 + ; (i = i0) → outS u0 }) + (outS u0) + + -- Heterogeneous filling defined using comp + fill : ∀ {ℓ : I → Level} (A : ∀ i → Set (ℓ i)) {φ : I} + (u : ∀ i → Partial φ (A i)) + (u0 : A i0 [ φ ↦ u i0 ]) → + ∀ i → A i + fill A {φ = φ} u u0 i = + comp (λ j → A (i ∧ j)) + (λ j → \ { (φ = i1) → u (i ∧ j) 1=1 + ; (i = i0) → outS u0 }) + (outS {φ = φ} u0) + + module _ {ℓ} {A : Set ℓ} where + refl : {x : A} → x ≡ x + refl {x = x} = λ _ → x + + sym : {x y : A} → x ≡ y → y ≡ x + sym p = λ i → p (~ i) + + cong : ∀ {ℓ'} {B : A → Set ℓ'} {x y : A} + (f : (a : A) → B a) (p : x ≡ y) + → PathP (λ i → B (p i)) (f x) (f y) + cong f p = λ i → f (p i) + + isContr : ∀ {ℓ} → Set ℓ → Set ℓ + isContr A = Σ A \ x → (∀ y → x ≡ y) + + fiber : ∀ {ℓ ℓ'} {A : Set ℓ} {B : Set ℓ'} (f : A → B) (y : B) → Set (ℓ ⊔ ℓ') + fiber {A = A} f y = Σ A \ x → f x ≡ y + +open Helpers + + +primitive + prim^glueU : {la : Level} {φ : I} {T : I → Partial φ (Set la)} + {A : Set la [ φ ↦ T i0 ]} → + PartialP φ (T i1) → outS A → hcomp T (outS A) + prim^unglueU : {la : Level} {φ : I} {T : I → Partial φ (Set la)} + {A : Set la [ φ ↦ T i0 ]} → + hcomp T (outS A) → outS A + +transpProof : ∀ {l} → (e : I → Set l) → (φ : I) → (a : Partial φ (e i0)) → (b : e i1 [ φ ↦ (\ o → transp e i0 (a o)) ] ) → fiber (transp e i0) (outS b) +transpProof e φ a b = f , \ j → comp e (\ i → \ { (φ = i1) → transp (\ j → e (j ∧ i)) (~ i) (a 1=1) + ; (j = i0) → transp (\ j → e (j ∧ i)) (~ i) f + ; (j = i1) → g (~ i) }) + f + where + g = fill (\ i → e (~ i)) (\ i → \ { (φ = i1) → transp (\ j → e (j ∧ ~ i)) i (a 1=1); (φ = i0) → transp (\ j → e (~ j ∨ ~ i)) (~ i) (outS b) }) (inS (outS b)) + f = comp (\ i → e (~ i)) (\ i → \ { (φ = i1) → transp (\ j → e (j ∧ ~ i)) i (a 1=1); (φ = i0) → transp (\ j → e (~ j ∨ ~ i)) (~ i) (outS b) }) (outS b) + +{-# BUILTIN TRANSPPROOF transpProof #-} diff --git a/src/data/lib/prim/Agda/Builtin/Cubical/Id.agda b/src/data/lib/prim/Agda/Builtin/Cubical/Id.agda --- a/src/data/lib/prim/Agda/Builtin/Cubical/Id.agda +++ b/src/data/lib/prim/Agda/Builtin/Cubical/Id.agda @@ -1,4 +1,6 @@ -{-# OPTIONS --cubical --safe --no-sized-types --no-guardedness #-} +{-# OPTIONS --cubical --safe --no-sized-types --no-guardedness + --no-subtyping #-} + module Agda.Builtin.Cubical.Id where open import Agda.Primitive.Cubical diff --git a/src/data/lib/prim/Agda/Builtin/Cubical/Path.agda b/src/data/lib/prim/Agda/Builtin/Cubical/Path.agda --- a/src/data/lib/prim/Agda/Builtin/Cubical/Path.agda +++ b/src/data/lib/prim/Agda/Builtin/Cubical/Path.agda @@ -1,4 +1,6 @@ -{-# OPTIONS --cubical --safe --no-sized-types --no-guardedness #-} +{-# OPTIONS --cubical --safe --no-sized-types --no-guardedness + --no-subtyping #-} + module Agda.Builtin.Cubical.Path where open import Agda.Primitive.Cubical diff --git a/src/data/lib/prim/Agda/Builtin/Cubical/Sub.agda b/src/data/lib/prim/Agda/Builtin/Cubical/Sub.agda --- a/src/data/lib/prim/Agda/Builtin/Cubical/Sub.agda +++ b/src/data/lib/prim/Agda/Builtin/Cubical/Sub.agda @@ -1,4 +1,6 @@ -{-# OPTIONS --cubical --safe --no-sized-types --no-guardedness #-} +{-# OPTIONS --cubical --safe --no-sized-types --no-guardedness + --no-subtyping #-} + module Agda.Builtin.Cubical.Sub where open import Agda.Primitive.Cubical diff --git a/src/data/lib/prim/Agda/Builtin/Equality.agda b/src/data/lib/prim/Agda/Builtin/Equality.agda --- a/src/data/lib/prim/Agda/Builtin/Equality.agda +++ b/src/data/lib/prim/Agda/Builtin/Equality.agda @@ -1,5 +1,5 @@ - -{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness #-} +{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness + --no-subtyping #-} module Agda.Builtin.Equality where diff --git a/src/data/lib/prim/Agda/Builtin/Equality/Erase.agda b/src/data/lib/prim/Agda/Builtin/Equality/Erase.agda --- a/src/data/lib/prim/Agda/Builtin/Equality/Erase.agda +++ b/src/data/lib/prim/Agda/Builtin/Equality/Erase.agda @@ -1,4 +1,5 @@ -{-# OPTIONS --with-K --safe --no-sized-types --no-guardedness #-} +{-# OPTIONS --with-K --safe --no-sized-types --no-guardedness + --no-subtyping #-} module Agda.Builtin.Equality.Erase where diff --git a/src/data/lib/prim/Agda/Builtin/Equality/Rewrite.agda b/src/data/lib/prim/Agda/Builtin/Equality/Rewrite.agda --- a/src/data/lib/prim/Agda/Builtin/Equality/Rewrite.agda +++ b/src/data/lib/prim/Agda/Builtin/Equality/Rewrite.agda @@ -1,4 +1,5 @@ -{-# OPTIONS --without-K --rewriting --no-sized-types --no-guardedness #-} +{-# OPTIONS --without-K --rewriting --no-sized-types --no-guardedness + --no-subtyping #-} module Agda.Builtin.Equality.Rewrite where diff --git a/src/data/lib/prim/Agda/Builtin/Float.agda b/src/data/lib/prim/Agda/Builtin/Float.agda --- a/src/data/lib/prim/Agda/Builtin/Float.agda +++ b/src/data/lib/prim/Agda/Builtin/Float.agda @@ -1,16 +1,19 @@ -{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness #-} +{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness + --no-subtyping #-} module Agda.Builtin.Float where open import Agda.Builtin.Bool open import Agda.Builtin.Nat open import Agda.Builtin.Int +open import Agda.Builtin.Word open import Agda.Builtin.String postulate Float : Set {-# BUILTIN FLOAT Float #-} primitive + primFloatToWord64 : Float → Word64 primFloatEquality : Float → Float → Bool primFloatLess : Float → Float → Bool primFloatNumericalEquality : Float → Float → Bool diff --git a/src/data/lib/prim/Agda/Builtin/Float/Properties.agda b/src/data/lib/prim/Agda/Builtin/Float/Properties.agda new file mode 100644 --- /dev/null +++ b/src/data/lib/prim/Agda/Builtin/Float/Properties.agda @@ -0,0 +1,11 @@ +{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness + --no-subtyping #-} + +module Agda.Builtin.Float.Properties where + +open import Agda.Builtin.Float +open import Agda.Builtin.Equality + +primitive + + primFloatToWord64Injective : ∀ a b → primFloatToWord64 a ≡ primFloatToWord64 b → a ≡ b diff --git a/src/data/lib/prim/Agda/Builtin/FromNat.agda b/src/data/lib/prim/Agda/Builtin/FromNat.agda --- a/src/data/lib/prim/Agda/Builtin/FromNat.agda +++ b/src/data/lib/prim/Agda/Builtin/FromNat.agda @@ -1,4 +1,5 @@ -{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness #-} +{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness + --no-subtyping #-} module Agda.Builtin.FromNat where diff --git a/src/data/lib/prim/Agda/Builtin/FromNeg.agda b/src/data/lib/prim/Agda/Builtin/FromNeg.agda --- a/src/data/lib/prim/Agda/Builtin/FromNeg.agda +++ b/src/data/lib/prim/Agda/Builtin/FromNeg.agda @@ -1,4 +1,5 @@ -{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness #-} +{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness + --no-subtyping #-} module Agda.Builtin.FromNeg where diff --git a/src/data/lib/prim/Agda/Builtin/FromString.agda b/src/data/lib/prim/Agda/Builtin/FromString.agda --- a/src/data/lib/prim/Agda/Builtin/FromString.agda +++ b/src/data/lib/prim/Agda/Builtin/FromString.agda @@ -1,4 +1,5 @@ -{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness #-} +{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness + --no-subtyping #-} module Agda.Builtin.FromString where diff --git a/src/data/lib/prim/Agda/Builtin/IO.agda b/src/data/lib/prim/Agda/Builtin/IO.agda --- a/src/data/lib/prim/Agda/Builtin/IO.agda +++ b/src/data/lib/prim/Agda/Builtin/IO.agda @@ -1,8 +1,10 @@ -{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness #-} +{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness + --no-subtyping #-} module Agda.Builtin.IO where postulate IO : ∀ {a} → Set a → Set a +{-# POLARITY IO ++ ++ #-} {-# BUILTIN IO IO #-} {-# FOREIGN GHC type AgdaIO a b = IO b #-} diff --git a/src/data/lib/prim/Agda/Builtin/Int.agda b/src/data/lib/prim/Agda/Builtin/Int.agda --- a/src/data/lib/prim/Agda/Builtin/Int.agda +++ b/src/data/lib/prim/Agda/Builtin/Int.agda @@ -1,4 +1,5 @@ -{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness #-} +{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness + --no-subtyping #-} module Agda.Builtin.Int where diff --git a/src/data/lib/prim/Agda/Builtin/List.agda b/src/data/lib/prim/Agda/Builtin/List.agda --- a/src/data/lib/prim/Agda/Builtin/List.agda +++ b/src/data/lib/prim/Agda/Builtin/List.agda @@ -1,4 +1,5 @@ -{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness #-} +{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness + --no-subtyping #-} module Agda.Builtin.List where diff --git a/src/data/lib/prim/Agda/Builtin/Nat.agda b/src/data/lib/prim/Agda/Builtin/Nat.agda --- a/src/data/lib/prim/Agda/Builtin/Nat.agda +++ b/src/data/lib/prim/Agda/Builtin/Nat.agda @@ -1,4 +1,5 @@ -{-# OPTIONS --without-K --safe --no-universe-polymorphism --no-sized-types --no-guardedness #-} +{-# OPTIONS --without-K --safe --no-universe-polymorphism + --no-sized-types --no-guardedness --no-subtyping #-} module Agda.Builtin.Nat where diff --git a/src/data/lib/prim/Agda/Builtin/Reflection.agda b/src/data/lib/prim/Agda/Builtin/Reflection.agda --- a/src/data/lib/prim/Agda/Builtin/Reflection.agda +++ b/src/data/lib/prim/Agda/Builtin/Reflection.agda @@ -1,4 +1,5 @@ -{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness #-} +{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness + --no-subtyping #-} module Agda.Builtin.Reflection where @@ -31,7 +32,7 @@ non-assoc : Associativity data Precedence : Set where - related : Int → Precedence + related : Float → Precedence unrelated : Precedence data Fixity : Set where @@ -69,6 +70,7 @@ primitive primQNameFixity : Name → Fixity + primQNameToWord64s : Name → Σ Word64 (λ _ → Word64) -- Metavariables -- @@ -79,6 +81,7 @@ primMetaEquality : Meta → Meta → Bool primMetaLess : Meta → Meta → Bool primShowMeta : Meta → String + primMetaToNat : Meta → Nat -- Arguments -- @@ -102,7 +105,7 @@ data ArgInfo : Set where arg-info : (v : Visibility) (r : Relevance) → ArgInfo -data Arg (A : Set) : Set where +data Arg {a} (A : Set a) : Set a where arg : (i : ArgInfo) (x : A) → Arg A {-# BUILTIN ARGINFO ArgInfo #-} @@ -112,7 +115,7 @@ -- Name abstraction -- -data Abs (A : Set) : Set where +data Abs {a} (A : Set a) : Set a where abs : (s : String) (x : A) → Abs A {-# BUILTIN ABS Abs #-} @@ -239,30 +242,30 @@ -- TC monad -- postulate - TC : ∀ {a} → Set a → Set a - returnTC : ∀ {a} {A : Set a} → A → TC A - bindTC : ∀ {a b} {A : Set a} {B : Set b} → TC A → (A → TC B) → TC B - unify : Term → Term → TC ⊤ - typeError : ∀ {a} {A : Set a} → List ErrorPart → TC A - inferType : Term → TC Type - checkType : Term → Type → TC Term - normalise : Term → TC Term - reduce : Term → TC Term - catchTC : ∀ {a} {A : Set a} → TC A → TC A → TC A - quoteTC : ∀ {a} {A : Set a} → A → TC Term - unquoteTC : ∀ {a} {A : Set a} → Term → TC A - getContext : TC (List (Arg Type)) - extendContext : ∀ {a} {A : Set a} → Arg Type → TC A → TC A - inContext : ∀ {a} {A : Set a} → List (Arg Type) → TC A → TC A - freshName : String → TC Name - declareDef : Arg Name → Type → TC ⊤ - declarePostulate : Arg Name → Type → TC ⊤ - defineFun : Name → List Clause → TC ⊤ - getType : Name → TC Type - getDefinition : Name → TC Definition - blockOnMeta : ∀ {a} {A : Set a} → Meta → TC A - commitTC : TC ⊤ - isMacro : Name → TC Bool + TC : ∀ {a} → Set a → Set a + returnTC : ∀ {a} {A : Set a} → A → TC A + bindTC : ∀ {a b} {A : Set a} {B : Set b} → TC A → (A → TC B) → TC B + unify : Term → Term → TC ⊤ + typeError : ∀ {a} {A : Set a} → List ErrorPart → TC A + inferType : Term → TC Type + checkType : Term → Type → TC Term + normalise : Term → TC Term + reduce : Term → TC Term + catchTC : ∀ {a} {A : Set a} → TC A → TC A → TC A + quoteTC : ∀ {a} {A : Set a} → A → TC Term + unquoteTC : ∀ {a} {A : Set a} → Term → TC A + getContext : TC (List (Arg Type)) + extendContext : ∀ {a} {A : Set a} → Arg Type → TC A → TC A + inContext : ∀ {a} {A : Set a} → List (Arg Type) → TC A → TC A + freshName : String → TC Name + declareDef : Arg Name → Type → TC ⊤ + declarePostulate : Arg Name → Type → TC ⊤ + defineFun : Name → List Clause → TC ⊤ + getType : Name → TC Type + getDefinition : Name → TC Definition + blockOnMeta : ∀ {a} {A : Set a} → Meta → TC A + commitTC : TC ⊤ + isMacro : Name → TC Bool -- If the argument is 'true' makes the following primitives also normalise -- their results: inferType, checkType, quoteTC, getType, and getContext @@ -281,31 +284,31 @@ -- new TC state if it is 'true'. runSpeculative : ∀ {a} {A : Set a} → TC (Σ A λ _ → Bool) → TC A -{-# BUILTIN AGDATCM TC #-} -{-# BUILTIN AGDATCMRETURN returnTC #-} -{-# BUILTIN AGDATCMBIND bindTC #-} -{-# BUILTIN AGDATCMUNIFY unify #-} -{-# BUILTIN AGDATCMTYPEERROR typeError #-} -{-# BUILTIN AGDATCMINFERTYPE inferType #-} -{-# BUILTIN AGDATCMCHECKTYPE checkType #-} -{-# BUILTIN AGDATCMNORMALISE normalise #-} -{-# BUILTIN AGDATCMREDUCE reduce #-} -{-# BUILTIN AGDATCMCATCHERROR catchTC #-} -{-# BUILTIN AGDATCMQUOTETERM quoteTC #-} -{-# BUILTIN AGDATCMUNQUOTETERM unquoteTC #-} -{-# BUILTIN AGDATCMGETCONTEXT getContext #-} -{-# BUILTIN AGDATCMEXTENDCONTEXT extendContext #-} -{-# BUILTIN AGDATCMINCONTEXT inContext #-} -{-# BUILTIN AGDATCMFRESHNAME freshName #-} -{-# BUILTIN AGDATCMDECLAREDEF declareDef #-} -{-# BUILTIN AGDATCMDECLAREPOSTULATE declarePostulate #-} -{-# BUILTIN AGDATCMDEFINEFUN defineFun #-} -{-# BUILTIN AGDATCMGETTYPE getType #-} -{-# BUILTIN AGDATCMGETDEFINITION getDefinition #-} -{-# BUILTIN AGDATCMBLOCKONMETA blockOnMeta #-} -{-# BUILTIN AGDATCMCOMMIT commitTC #-} -{-# BUILTIN AGDATCMISMACRO isMacro #-} -{-# BUILTIN AGDATCMWITHNORMALISATION withNormalisation #-} -{-# BUILTIN AGDATCMDEBUGPRINT debugPrint #-} -{-# BUILTIN AGDATCMNOCONSTRAINTS noConstraints #-} -{-# BUILTIN AGDATCMRUNSPECULATIVE runSpeculative #-} +{-# BUILTIN AGDATCM TC #-} +{-# BUILTIN AGDATCMRETURN returnTC #-} +{-# BUILTIN AGDATCMBIND bindTC #-} +{-# BUILTIN AGDATCMUNIFY unify #-} +{-# BUILTIN AGDATCMTYPEERROR typeError #-} +{-# BUILTIN AGDATCMINFERTYPE inferType #-} +{-# BUILTIN AGDATCMCHECKTYPE checkType #-} +{-# BUILTIN AGDATCMNORMALISE normalise #-} +{-# BUILTIN AGDATCMREDUCE reduce #-} +{-# BUILTIN AGDATCMCATCHERROR catchTC #-} +{-# BUILTIN AGDATCMQUOTETERM quoteTC #-} +{-# BUILTIN AGDATCMUNQUOTETERM unquoteTC #-} +{-# BUILTIN AGDATCMGETCONTEXT getContext #-} +{-# BUILTIN AGDATCMEXTENDCONTEXT extendContext #-} +{-# BUILTIN AGDATCMINCONTEXT inContext #-} +{-# BUILTIN AGDATCMFRESHNAME freshName #-} +{-# BUILTIN AGDATCMDECLAREDEF declareDef #-} +{-# BUILTIN AGDATCMDECLAREPOSTULATE declarePostulate #-} +{-# BUILTIN AGDATCMDEFINEFUN defineFun #-} +{-# BUILTIN AGDATCMGETTYPE getType #-} +{-# BUILTIN AGDATCMGETDEFINITION getDefinition #-} +{-# BUILTIN AGDATCMBLOCKONMETA blockOnMeta #-} +{-# BUILTIN AGDATCMCOMMIT commitTC #-} +{-# BUILTIN AGDATCMISMACRO isMacro #-} +{-# BUILTIN AGDATCMWITHNORMALISATION withNormalisation #-} +{-# BUILTIN AGDATCMDEBUGPRINT debugPrint #-} +{-# BUILTIN AGDATCMNOCONSTRAINTS noConstraints #-} +{-# BUILTIN AGDATCMRUNSPECULATIVE runSpeculative #-} diff --git a/src/data/lib/prim/Agda/Builtin/Reflection/Properties.agda b/src/data/lib/prim/Agda/Builtin/Reflection/Properties.agda new file mode 100644 --- /dev/null +++ b/src/data/lib/prim/Agda/Builtin/Reflection/Properties.agda @@ -0,0 +1,12 @@ +{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness + --no-subtyping #-} + +module Agda.Builtin.Reflection.Properties where + +open import Agda.Builtin.Reflection +open import Agda.Builtin.Equality + +primitive + + primMetaToNatInjective : ∀ a b → primMetaToNat a ≡ primMetaToNat b → a ≡ b + primQNameToWord64sInjective : ∀ a b → primQNameToWord64s a ≡ primQNameToWord64s b → a ≡ b diff --git a/src/data/lib/prim/Agda/Builtin/Sigma.agda b/src/data/lib/prim/Agda/Builtin/Sigma.agda --- a/src/data/lib/prim/Agda/Builtin/Sigma.agda +++ b/src/data/lib/prim/Agda/Builtin/Sigma.agda @@ -1,4 +1,5 @@ -{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness #-} +{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness + --no-subtyping #-} module Agda.Builtin.Sigma where diff --git a/src/data/lib/prim/Agda/Builtin/Size.agda b/src/data/lib/prim/Agda/Builtin/Size.agda --- a/src/data/lib/prim/Agda/Builtin/Size.agda +++ b/src/data/lib/prim/Agda/Builtin/Size.agda @@ -1,4 +1,5 @@ -{-# OPTIONS --without-K --safe --no-universe-polymorphism --sized-types --no-guardedness #-} +{-# OPTIONS --without-K --safe --no-universe-polymorphism --sized-types + --no-guardedness --no-subtyping #-} module Agda.Builtin.Size where diff --git a/src/data/lib/prim/Agda/Builtin/Strict.agda b/src/data/lib/prim/Agda/Builtin/Strict.agda --- a/src/data/lib/prim/Agda/Builtin/Strict.agda +++ b/src/data/lib/prim/Agda/Builtin/Strict.agda @@ -1,4 +1,5 @@ -{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness #-} +{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness + --no-subtyping #-} module Agda.Builtin.Strict where diff --git a/src/data/lib/prim/Agda/Builtin/String.agda b/src/data/lib/prim/Agda/Builtin/String.agda --- a/src/data/lib/prim/Agda/Builtin/String.agda +++ b/src/data/lib/prim/Agda/Builtin/String.agda @@ -1,10 +1,12 @@ -{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness #-} +{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness + --no-subtyping #-} module Agda.Builtin.String where open import Agda.Builtin.Bool open import Agda.Builtin.List open import Agda.Builtin.Char +open import Agda.Builtin.Nat using (Nat) postulate String : Set {-# BUILTIN STRING String #-} @@ -16,6 +18,7 @@ primStringEquality : String → String → Bool primShowChar : Char → String primShowString : String → String + primShowNat : Nat → String {-# COMPILE JS primStringToList = function(x) { return x.split(""); } #-} {-# COMPILE JS primStringFromList = function(x) { return x.join(""); } #-} diff --git a/src/data/lib/prim/Agda/Builtin/String/Properties.agda b/src/data/lib/prim/Agda/Builtin/String/Properties.agda --- a/src/data/lib/prim/Agda/Builtin/String/Properties.agda +++ b/src/data/lib/prim/Agda/Builtin/String/Properties.agda @@ -1,4 +1,5 @@ -{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness #-} +{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness + --no-subtyping #-} module Agda.Builtin.String.Properties where diff --git a/src/data/lib/prim/Agda/Builtin/TrustMe.agda b/src/data/lib/prim/Agda/Builtin/TrustMe.agda --- a/src/data/lib/prim/Agda/Builtin/TrustMe.agda +++ b/src/data/lib/prim/Agda/Builtin/TrustMe.agda @@ -1,4 +1,5 @@ -{-# OPTIONS --no-sized-types --no-guardedness #-} +{-# OPTIONS --no-sized-types --no-guardedness --no-subtyping #-} + module Agda.Builtin.TrustMe where open import Agda.Builtin.Equality diff --git a/src/data/lib/prim/Agda/Builtin/Unit.agda b/src/data/lib/prim/Agda/Builtin/Unit.agda --- a/src/data/lib/prim/Agda/Builtin/Unit.agda +++ b/src/data/lib/prim/Agda/Builtin/Unit.agda @@ -1,4 +1,5 @@ -{-# OPTIONS --without-K --safe --no-universe-polymorphism --no-sized-types --no-guardedness #-} +{-# OPTIONS --without-K --safe --no-universe-polymorphism + --no-sized-types --no-guardedness --no-subtyping #-} module Agda.Builtin.Unit where diff --git a/src/data/lib/prim/Agda/Builtin/Word.agda b/src/data/lib/prim/Agda/Builtin/Word.agda --- a/src/data/lib/prim/Agda/Builtin/Word.agda +++ b/src/data/lib/prim/Agda/Builtin/Word.agda @@ -1,4 +1,5 @@ -{-# OPTIONS --without-K --safe --no-universe-polymorphism --no-sized-types --no-guardedness #-} +{-# OPTIONS --without-K --safe --no-universe-polymorphism + --no-sized-types --no-guardedness --no-subtyping #-} module Agda.Builtin.Word where diff --git a/src/data/lib/prim/Agda/Builtin/Word/Properties.agda b/src/data/lib/prim/Agda/Builtin/Word/Properties.agda --- a/src/data/lib/prim/Agda/Builtin/Word/Properties.agda +++ b/src/data/lib/prim/Agda/Builtin/Word/Properties.agda @@ -1,4 +1,5 @@ -{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness #-} +{-# OPTIONS --without-K --safe --no-sized-types --no-guardedness + --no-subtyping #-} module Agda.Builtin.Word.Properties where diff --git a/src/data/lib/prim/Agda/Primitive.agda b/src/data/lib/prim/Agda/Primitive.agda --- a/src/data/lib/prim/Agda/Primitive.agda +++ b/src/data/lib/prim/Agda/Primitive.agda @@ -1,6 +1,6 @@ -- The Agda primitives (preloaded). -{-# OPTIONS --without-K #-} +{-# OPTIONS --without-K --no-subtyping #-} module Agda.Primitive where @@ -19,7 +19,6 @@ -- MAlonzo compiles Level to (). This should be safe, because it is -- not possible to pattern match on levels. -{-# COMPILE GHC Level = type () #-} {-# BUILTIN LEVEL Level #-} postulate diff --git a/src/data/lib/prim/Agda/Primitive/Cubical.agda b/src/data/lib/prim/Agda/Primitive/Cubical.agda --- a/src/data/lib/prim/Agda/Primitive/Cubical.agda +++ b/src/data/lib/prim/Agda/Primitive/Cubical.agda @@ -1,4 +1,4 @@ -{-# OPTIONS --cubical #-} +{-# OPTIONS --cubical --no-subtyping #-} module Agda.Primitive.Cubical where @@ -44,7 +44,7 @@ → PartialP (primIMax i j) A -- Computes in terms of primHComp and primTransp - primComp : ∀ {ℓ} (A : (i : I) → Set (ℓ i)) (φ : I) (u : ∀ i → Partial φ (A i)) (a : A i0) → A i1 + primComp : ∀ {ℓ} (A : (i : I) → Set (ℓ i)) {φ : I} (u : ∀ i → Partial φ (A i)) (a : A i0) → A i1 syntax primPOr p q u t = [ p ↦ u , q ↦ t ] diff --git a/src/data/postprocess-latex.pl b/src/data/postprocess-latex.pl --- a/src/data/postprocess-latex.pl +++ b/src/data/postprocess-latex.pl @@ -10,7 +10,7 @@ while (<>) { - s|(\\Agda$commands){(.*?)} + s|(\\Agda$commands)\{(.*?)\} | my $cmd = $1; my $arg = $3; diff --git a/src/full/Agda/Auto/Auto.hs b/src/full/Agda/Auto/Auto.hs --- a/src/full/Agda/Auto/Auto.hs +++ b/src/full/Agda/Auto/Auto.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} module Agda.Auto.Auto (auto @@ -8,7 +7,6 @@ import Prelude hiding (null) -import Data.Functor import Control.Monad.State import qualified Data.List as List import qualified Data.Map as Map @@ -16,12 +14,11 @@ import qualified System.Timeout import Data.Maybe import qualified Data.Traversable as Trav +import qualified Data.HashMap.Strict as HMap import Agda.Utils.Permutation (permute, takeP) import Agda.TypeChecking.Monad hiding (withCurrentModule) import Agda.TypeChecking.Telescope - -import Agda.Syntax.Common (Hiding(..)) import qualified Agda.Syntax.Abstract as A import Agda.Syntax.Abstract.Pretty (prettyA) import qualified Agda.Syntax.Concrete.Name as C @@ -31,16 +28,15 @@ import qualified Agda.Syntax.Internal as I import Agda.Syntax.Translation.InternalToAbstract import Agda.Syntax.Translation.AbstractToConcrete (abstractToConcreteScope, abstractToConcrete_, runAbsToCon, toConcrete) +import Agda.Interaction.Base import Agda.Interaction.BasicOps hiding (refine) import Agda.TypeChecking.Reduce (normalise) import Agda.Syntax.Common import qualified Agda.Syntax.Scope.Base as Scope import Agda.Syntax.Scope.Monad (withCurrentModule) -import Agda.Syntax.Concrete.Name (NameInScope(..), LensInScope(..)) import qualified Agda.Syntax.Abstract.Name as AN import qualified Agda.TypeChecking.Monad.Base as TCM import Agda.TypeChecking.EtaContract (etaContract) -import qualified Agda.Utils.HashMap as HMap import Agda.Auto.Options import Agda.Auto.Convert @@ -60,7 +56,6 @@ import Agda.Utils.Pretty ( prettyShow ) import Agda.Utils.Tuple -#include "undefined.h" insertAbsurdPattern :: String -> String insertAbsurdPattern [] = [] @@ -114,7 +109,7 @@ -> Range -> String -> tcm AutoResult -auto ii rng argstr = liftTCM $ do +auto ii rng argstr = liftTCM $ locallyTC eMakeCase (const True) $ do -- Parse hints and other configuration. let autoOptions = parseArgs argstr @@ -325,7 +320,8 @@ loop [] = return $ AutoResult (Solutions []) (Just "") loop (term : terms') = do -- On exception, try next solution - flip catchError (const $ loop terms') $ do + flip catchError (\ e -> do reportSDoc "auto" 40 $ "Solution failed:" TCM. TCM.prettyTCM e + loop terms') $ do exprs <- getsols term reportSDoc "auto" 20 $ "Trying solution " TCM.<+> TCM.prettyTCM exprs giveress <- forM exprs $ \ (mi, expr0) -> do @@ -381,12 +377,12 @@ case cls' of Left{} -> stopWithMsg "No solution found" Right cls' -> do - cls'' <- forM cls' $ \ (I.Clause _ _ tel ps body t catchall reachable) -> do + cls'' <- forM cls' $ \ (I.Clause _ _ tel ps body t catchall recursive reachable ell) -> do withCurrentModule (AN.qnameModule def) $ do -- Normalise the dot patterns ps <- addContext tel $ normalise ps body <- etaContract body - liftM modifyAbstractClause $ inTopContext $ reify $ AN.QNamed def $ I.Clause noRange noRange tel ps body t catchall reachable + liftM modifyAbstractClause $ inTopContext $ reify $ AN.QNamed def $ I.Clause noRange noRange tel ps body t catchall recursive reachable ell moduleTel <- lookupSection (AN.qnameModule def) pcs <- withInteractionId ii $ inTopContext $ addContext moduleTel $ mapM prettyA cls'' ticks <- liftIO $ readIORef ticks diff --git a/src/full/Agda/Auto/CaseSplit.hs b/src/full/Agda/Auto/CaseSplit.hs --- a/src/full/Agda/Auto/CaseSplit.hs +++ b/src/full/Agda/Auto/CaseSplit.hs @@ -1,11 +1,10 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE UndecidableInstances #-} module Agda.Auto.CaseSplit where import Data.IORef import Data.Tuple (swap) -import Data.List (findIndex, union) +import Data.List (findIndex) import Data.Monoid ((<>), Sum(..)) import Data.Foldable (foldMap) import qualified Data.Set as Set @@ -22,7 +21,6 @@ import Agda.Auto.SearchControl import Agda.Auto.Typecheck -#include "undefined.h" import Agda.Utils.Impossible import Agda.Utils.Monad (or2M) @@ -102,8 +100,6 @@ rc depth nscrutavoid ctx tt pats = do mblkvar <- getblks tt - - fork mblkvar where @@ -192,7 +188,7 @@ * Cost (depthofvar scrut pats) else costCaseSplitVeryHigh else - if elem scrut mblkvar then costCaseSplitLow else (if scrut < length ctx - nscrutavoid && nothid then costCaseSplitHigh else costCaseSplitVeryHigh) + if scrut `elem` mblkvar then costCaseSplitLow else (if scrut < length ctx - nscrutavoid && nothid then costCaseSplitHigh else costCaseSplitVeryHigh) nothid = let HI hid _ = ctx !! scrut in hid == NotHidden @@ -333,9 +329,9 @@ >> unify' b1 b2 (Sort _, Sort _) -> return () -- a bit sloppy (App _ _ (Var v) (NotM ALNil), _) - | elem v (freevars e2) -> St.lift Nothing -- Occurs check + | v `Set.member` (freeVars e2) -> St.lift Nothing -- Occurs check (_, App _ _ (Var v) (NotM ALNil)) - | elem v (freevars e1) -> St.lift Nothing -- Occurs check + | v `Set.member` (freeVars e1) -> St.lift Nothing -- Occurs check (App _ _ (Var v) (NotM ALNil), _) -> unifyVar v e2 (_, App _ _ (Var v) (NotM ALNil)) -> unifyVar v e1 _ -> St.lift Nothing @@ -582,7 +578,7 @@ okcall i size vars as = mmpcase (False, prioNo, Nothing) as $ \as -> case as of ALNil -> mpret OK - ALCons _ a as | elem i is -> + ALCons _ a as | i `elem` is -> mbpcase prioNo Nothing (he size vars a) $ \x -> case x of Nothing -> mpret $ Error "localTerminationSidecond: reccall not ok" Just (size', vars') -> okcall (i + 1) size' vars' as diff --git a/src/full/Agda/Auto/Convert.hs b/src/full/Agda/Auto/Convert.hs --- a/src/full/Agda/Auto/Convert.hs +++ b/src/full/Agda/Auto/Convert.hs @@ -1,27 +1,26 @@ -{-# LANGUAGE CPP #-} module Agda.Auto.Convert where -import Control.Applicative hiding (getConst, Const(..)) +import Control.Monad.State import Data.IORef import Data.Maybe (catMaybes) import Data.Map (Map) import qualified Data.Map as Map import Data.Traversable (traverse) -import Control.Monad.State -import Agda.Syntax.Common (Hiding(..), getHiding) +import Agda.Syntax.Common (Hiding(..), getHiding, Arg) import Agda.Syntax.Concrete (exprFieldA) import qualified Agda.Syntax.Internal as I +import Agda.Syntax.Internal (Dom'(..),domInfo,unDom) import qualified Agda.Syntax.Internal.Pattern as IP import qualified Agda.Syntax.Common as Cm -import Agda.Syntax.Common (Dom(..),domInfo,unDom) import qualified Agda.Syntax.Abstract.Name as AN import qualified Agda.Syntax.Abstract as A import qualified Agda.Syntax.Position as SP + import qualified Agda.TypeChecking.Monad.Base as MB + import Agda.TypeChecking.Monad.Signature (getConstInfo, getDefFreeVars, ignoreAbstractMode) -import Agda.Utils.Permutation (Permutation(Perm), permute, takeP, compactP) import Agda.TypeChecking.Level (reallyUnLevelView) import Agda.TypeChecking.Monad.Base (mvJudgement, mvPermutation, getMetaInfo, envContext, clEnv) import Agda.TypeChecking.Monad.MetaVars (lookupMeta, withMetaInfo, lookupInteractionPoint) @@ -34,7 +33,6 @@ import Agda.TypeChecking.EtaContract (etaContract) import Agda.TypeChecking.Monad.Builtin (constructorForm) import Agda.TypeChecking.Free as Free (freeIn) -import Agda.TypeChecking.Errors ( stringTCErr ) import Agda.Interaction.MakeCase (getClauseZipperForIP) @@ -44,12 +42,13 @@ import Agda.Auto.CaseSplit hiding (lift) import Agda.Utils.Either -import Agda.Utils.Except ( ExceptT , MonadError(throwError) ) +import Agda.Utils.Except ( ExceptT , MonadError(throwError) ) import Agda.Utils.Lens -import Agda.Utils.Pretty ( prettyShow ) +import Agda.Utils.Monad ( forMaybeMM ) +import Agda.Utils.Permutation ( Permutation(Perm), permute, takeP, compactP ) +import Agda.Utils.Pretty ( prettyShow ) import Agda.Utils.Impossible -#include "undefined.h" data Hint = Hint @@ -57,7 +56,7 @@ , hintQName :: I.QName } -type O = (Maybe Int, AN.QName) +type O = (Maybe (Int, [Arg AN.QName]),AN.QName) -- Nothing - Def -- Just npar - Con with npar parameters which don't appear in Agda @@ -126,7 +125,7 @@ cons2 <- mapM (\con -> getConst True con TMAll) cons return (Datatype cons2 [], []) MB.Record {MB.recFields = fields, MB.recTel = tel} -> do -- the value of recPars seems unreliable or don't know what it signifies - let pars n (I.El _ (I.Pi it typ)) = Cm.Arg (Cm.domInfo it) (I.var n) : + let pars n (I.El _ (I.Pi it typ)) = Cm.Arg (I.domInfo it) (I.var n) : pars (n - 1) (I.unAbs typ) pars _ (I.El _ _) = [] contyp npar I.EmptyTel = I.El (I.mkType 0 {- arbitrary -}) $ @@ -138,13 +137,13 @@ let Datatype [con] [] = cdcont cc lift $ liftIO $ modifyIORef con (\cdef -> cdef {cdtype = contyp'}) - projfcns <- mapM (\name -> getConst False name TMAll) (map Cm.unArg fields) + projfcns <- mapM (\name -> getConst False name TMAll) (map I.unDom fields) return (Datatype [con] projfcns, []{-map snd fields-}) MB.Constructor {MB.conData = dt} -> do _ <- getConst False dt TMAll -- make sure that datatype is included cc <- lift $ liftIO $ readIORef c - let (Just nomi, _) = cdorigin cc + let (Just (nomi,_), _) = cdorigin cc return (Constructor (nomi - cddeffreevars cc), []) lift $ liftIO $ modifyIORef c (\cdef -> cdef {cdtype = typ', cdcont = cont}) r $ projfcns2 ++ projfcns @@ -175,7 +174,7 @@ modify $ \s -> s {sEqs = (Map.insert (Map.size (fst $ sEqs s)) (Just (False, Meta m, sol')) (fst $ sEqs s), snd $ sEqs s)} let tt = MB.jMetaType $ mvJudgement mv minfo = getMetaInfo mv - localVars = map (snd . Cm.unDom) . envContext . clEnv $ minfo + localVars = map (snd . I.unDom) . envContext . clEnv $ minfo (targettype, localVars) <- lift $ withMetaInfo minfo $ do vs <- getContextArgs targettype <- tt `piApplyM` permute (takeP (length vs) $ mvPermutation mv) vs @@ -223,6 +222,7 @@ case MB.theDef def of MB.Record {MB.recConHead = con} -> do let conname = I.conName con + conflds = I.conFields con cmap <- fst `liftM` gets sConsts case Map.lookup name cmap of Just (mode', c) -> @@ -236,7 +236,7 @@ mainm <- gets sMainMeta dfv <- lift $ getdfv mainm name let nomi = I.arity (MB.defType def) - ccon <- lift $ liftIO $ newIORef (ConstDef {cdname = prettyShow name ++ ".CONS", cdorigin = (Just nomi, conname), cdtype = __IMPOSSIBLE__, cdcont = Constructor (nomi - dfv), cddeffreevars = dfv}) -- ?? correct value of deffreevars for records? + ccon <- lift $ liftIO $ newIORef (ConstDef {cdname = prettyShow name ++ ".CONS", cdorigin = (Just (nomi,conflds), conname), cdtype = __IMPOSSIBLE__, cdcont = Constructor (nomi - dfv), cddeffreevars = dfv}) -- ?? correct value of deffreevars for records? c <- lift $ liftIO $ newIORef (ConstDef {cdname = prettyShow name, cdorigin = (Nothing, name), cdtype = __IMPOSSIBLE__, cdcont = Datatype [ccon] [], cddeffreevars = dfv}) -- ?? correct value of deffreevars for records? modify (\s -> s {sConsts = (Map.insert name (mode, c) cmap, name : snd (sConsts s))}) return $ if iscon then ccon else c @@ -247,8 +247,8 @@ return c Nothing -> do (miscon, sname) <- if iscon then do - let MB.Constructor {MB.conPars = npar, MB.conData = dname} = MB.theDef def - return (Just npar, prettyShow dname ++ "." ++ prettyShow (I.qnameName name)) + let MB.Constructor {MB.conPars = npar, MB.conData = dname, MB.conSrcCon = ch} = MB.theDef def + return (Just (npar,I.conFields ch), prettyShow dname ++ "." ++ prettyShow (I.qnameName name)) else return (Nothing, prettyShow name) mainm <- gets sMainMeta @@ -270,28 +270,19 @@ return m Nothing -> do m <- lift $ liftIO initMeta - modify (\s -> s {sMetas = (Map.insert name (m, Nothing, []) mmap, name : snd (sMetas s))}) + modify $ \ s -> s { sMetas = (Map.insert name (m, Nothing, []) mmap, name : snd (sMetas s)) } return m getEqs :: MB.TCM [(Bool, I.Term, I.Term)] -getEqs = do - eqs <- getAllConstraints - let r = mapM (\eqc -> do - neqc <- normalise eqc - case MB.clValue $ MB.theConstraint neqc of - MB.ValueCmp ineq _ i e -> do - ei <- etaContract i - ee <- etaContract e - return [(tomyIneq ineq, ee, ei)] - MB.TypeCmp ineq i e -> do - I.El _ ei <- etaContract i - I.El _ ee <- etaContract e - return [(tomyIneq ineq, ee, ei)] - MB.Guarded (MB.UnBlock _) pid -> return [] - _ -> return [] - ) - eqs' <- r eqs - return $ concat eqs' +getEqs = forMaybeMM getAllConstraints $ \ eqc -> do + neqc <- normalise eqc + case MB.clValue $ MB.theConstraint neqc of + MB.ValueCmp ineq _ i e -> do + ei <- etaContract i + ee <- etaContract e + return $ Just (tomyIneq ineq, ee, ei) + MB.Guarded (MB.UnBlock _) _pid -> return Nothing + _ -> return Nothing copatternsNotImplemented :: MB.TCM a copatternsNotImplemented = MB.typeError $ MB.NotImplemented $ @@ -339,12 +330,12 @@ pats' <- mapM (convert . fmap Cm.namedThing) pats def <- lift $ getConstInfo n cc <- lift $ liftIO $ readIORef c - let Just npar = fst $ cdorigin cc + let Just (npar,_) = fst $ cdorigin cc return $ PatConApp c (replicate npar PatExp ++ pats') -- UNSUPPORTED CASES I.ProjP{} -> lift copatternsNotImplemented - I.LitP _ -> lift literalsNotImplemented + I.LitP{} -> lift literalsNotImplemented I.DefP{} -> lift hitsNotImplemented instance Conversion TOM I.Type (MExp O) where @@ -378,15 +369,15 @@ as' <- convert as def <- lift $ getConstInfo name cc <- lift $ liftIO $ readIORef c - let Just npar = fst $ cdorigin cc + let Just (npar,_) = fst $ cdorigin cc return $ NotM $ App Nothing (NotM OKVal) (Const c) (foldl (\x _ -> NotM $ ALConPar x) as' [1..npar]) - I.Pi (Cm.Dom{domInfo = info, unDom = x}) b -> do + I.Pi (I.Dom{domInfo = info, unDom = x}) b -> do let y = I.absBody b name = I.absName b x' <- convert x y' <- convert y return $ NotM $ Pi Nothing (getHiding info) (Free.freeIn 0 y) x' (Abs (Id name) y') - I.Sort (I.Type (I.Max [I.ClosedLevel l])) -> return $ NotM $ Sort $ Set $ fromIntegral l + I.Sort (I.Type (I.ClosedLevel l)) -> return $ NotM $ Sort $ Set $ fromIntegral l I.Sort _ -> return $ NotM $ Sort UnknownSort I.Dummy{}-> return $ NotM $ Sort UnknownSort t@I.MetaV{} -> do @@ -425,10 +416,10 @@ fmExp m (I.Var _ as) = fmExps m $ I.argsFromElims as fmExp m (I.Lam _ b) = fmExp m (I.unAbs b) fmExp m (I.Lit _) = False -fmExp m (I.Level (I.Max as)) = any (fmLevel m) as +fmExp m (I.Level (I.Max _ as)) = any (fmLevel m) as fmExp m (I.Def _ as) = fmExps m $ I.argsFromElims as fmExp m (I.Con _ ci as) = fmExps m $ I.argsFromElims as -fmExp m (I.Pi x y) = fmType m (Cm.unDom x) || fmType m (I.unAbs y) +fmExp m (I.Pi x y) = fmType m (I.unDom x) || fmType m (I.unAbs y) fmExp m (I.Sort _) = False fmExp m (I.MetaV mid _) = mid == m fmExp m (I.DontCare _) = False @@ -439,7 +430,6 @@ fmExps m (a : as) = fmExp m (Cm.unArg a) || fmExps m as fmLevel :: I.MetaId -> I.PlusLevel -> Bool -fmLevel m I.ClosedLevel{} = False fmLevel m (I.Plus _ l) = case l of I.MetaLevel m' _ -> m == m' I.NeutralLevel _ v -> fmExp m v @@ -495,13 +485,13 @@ frommyExps n as v -} (ndrop, h) = case iscon of - Just n -> (n, \ q -> I.Con (I.ConHead q Cm.Inductive []) Cm.ConOSystem) -- TODO: restore fields + Just (n,fs) -> (n, \ q -> I.Con (I.ConHead q Cm.Inductive fs) Cm.ConOSystem) Nothing -> (0, \ f vs -> I.Def f vs) frommyExps ndrop as (h name []) Lam hid t -> I.Lam (icnvh hid) <$> convert t Pi _ hid _ x y -> do x' <- convert x - let dom = (Cm.defaultDom x') {domInfo = icnvh hid} + let dom = (I.defaultDom x') {domInfo = icnvh hid} I.Pi dom <$> convert y -- maybe have case for Pi where possdep is False which produces Fun (and has to unweaken y), return $ I.Fun (Cm.Arg (icnvh hid) x') y' Sort (Set l) -> return $ I.Sort (I.mkType (fromIntegral l)) @@ -554,8 +544,8 @@ where f (A.App i e1 (Cm.Arg info (Cm.Named n e2))) = A.App i (f e1) (Cm.Arg info (Cm.Named n (f e2))) - f (A.Lam i (A.DomainFree x) _) - | A.BindName n <- Cm.namedArg x + f (A.Lam i (A.DomainFree _ x) _) + | A.Binder _ (A.BindName{unBind = n}) <- Cm.namedArg x , prettyShow (A.nameConcrete n) == abslamvarname = A.AbsurdLam i $ Cm.getHiding x f (A.Lam i b e) = A.Lam i b (f e) @@ -589,7 +579,7 @@ (c2, _) <- runStateT (getConst True c TMAll) (S {sConsts = (cmap, []), sMetas = initMapS, sEqs = initMapS, sCurMeta = Nothing, sMainMeta = mainm}) (ns', ps') <- cnvps ns ps cc <- liftIO $ readIORef c2 - let Just npar = fst $ cdorigin cc + let Just (npar,_) = fst $ cdorigin cc return (ns', HI hid (CSPatConApp c2 (replicate npar (HI Hidden CSOmittedArg) ++ ps'))) I.DotP _ t -> do (t2, _) <- runStateT (convert t) (S {sConsts = (cmap, []), sMetas = initMapS, sEqs = initMapS, sCurMeta = Nothing, sMainMeta = mainm}) @@ -609,7 +599,7 @@ let Id id = mid tel <- ctel ctx t' <- convert t - let dom = (Cm.defaultDom t') {domInfo = icnvh hid} + let dom = (I.defaultDom t') {domInfo = icnvh hid} return $ I.ExtendTel dom (I.Abs id tel) tel <- ctel $ reverse ids let getperms 0 [] perm nv = return (perm, nv) @@ -626,7 +616,7 @@ CSPatVar v -> return ((length ids - 1 - v, nv) : perm, nv + 1) CSPatConApp c ps -> do cdef <- lift $ readIORef c - let (Just ndrop, _) = cdorigin cdef + let (Just (ndrop,_), _) = cdorigin cdef getperms ndrop ps perm nv CSPatExp e -> return (perm, nv + 1) _ -> __IMPOSSIBLE__ @@ -649,7 +639,7 @@ CSPatVar v -> return (I.varP $ let HI _ (Id n, _) = ids !! v in n) CSPatConApp c ps -> do cdef <- lift $ readIORef c - let (Just ndrop, name) = cdorigin cdef + let (Just (ndrop,_), name) = cdorigin cdef ps' <- cnvps ndrop ps let con = I.ConHead name Cm.Inductive [] -- TODO: restore record fields! return (I.ConP con I.noConPatternInfo ps') @@ -672,7 +662,9 @@ , I.clauseBody = body , I.clauseType = Nothing -- TODO: compute clause type , I.clauseCatchall = False + , I.clauseRecursive = Nothing -- TODO: Don't know here whether recursive or not !? , I.clauseUnreachable = Nothing -- TODO: Don't know here whether reachable or not !? + , I.clauseEllipsis = Cm.NoEllipsis } contains_constructor :: [CSPat O] -> Bool @@ -724,7 +716,7 @@ MB.InteractionPoint { MB.ipClause = ipCl} <- lookupInteractionPoint ii case ipCl of MB.IPNoClause -> return Nothing - MB.IPClause f clauseNo _ -> do + MB.IPClause f clauseNo _ _ _ _ _ -> do (_, (_, c, _)) <- getClauseZipperForIP f clauseNo return $ Just (f, c, maybe __IMPOSSIBLE__ toplevel $ I.clauseBody c) where @@ -766,7 +758,7 @@ (I.Lit lit1, I.Lit lit2) | lit1 == lit2 -> c (n + 1) (I.Def n1 as1, I.Def n2 as2) | n1 == n2 -> fes nl (n + 1) c as1 as2 (I.Con n1 _ as1, I.Con n2 _ as2) | n1 == n2 -> fs nl (n + 1) c as1 as2 - (I.Pi (Cm.Dom{domInfo = info1, unDom = it1}) ot1, I.Pi (Cm.Dom{domInfo = info2, unDom = it2}) ot2) | Cm.argInfoHiding info1 == Cm.argInfoHiding info2 -> ft nl n (\n -> ft (nl + 1) n c (I.absBody ot1) (I.absBody ot2)) it1 it2 + (I.Pi (I.Dom{domInfo = info1, unDom = it1}) ot1, I.Pi (I.Dom{domInfo = info2, unDom = it2}) ot2) | Cm.argInfoHiding info1 == Cm.argInfoHiding info2 -> ft nl n (\n -> ft (nl + 1) n c (I.absBody ot1) (I.absBody ot2)) it1 it2 (I.Sort{}, I.Sort{}) -> c n -- sloppy _ -> Nothing fs nl n c es1 es2 = case (es1, es2) of diff --git a/src/full/Agda/Auto/NarrowingSearch.hs b/src/full/Agda/Auto/NarrowingSearch.hs --- a/src/full/Agda/Auto/NarrowingSearch.hs +++ b/src/full/Agda/Auto/NarrowingSearch.hs @@ -1,5 +1,3 @@ -{-# LANGUAGE CPP #-} -{-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} module Agda.Auto.NarrowingSearch where @@ -7,9 +5,7 @@ import Data.IORef hiding (writeIORef, modifyIORef) import qualified Data.IORef as NoUndo (writeIORef, modifyIORef) import Control.Monad.State -import Control.Applicative hiding (Const(..), getConst) -#include "undefined.h" import Agda.Utils.Impossible import Agda.Utils.Empty @@ -213,7 +209,7 @@ | Meta (Metavar a blk) rm :: Empty -> MM a b -> a -rm e (NotM x) = x +rm _ (NotM x) = x rm e Meta{} = absurd e type MetaEnv = IO @@ -282,7 +278,7 @@ x' <- x case x' of NotB x -> f x - Blocked m x -> fm (Meta m) + Blocked m _ -> fm (Meta m) Failed msg -> return $ NotPB $ Error msg waitok :: OKHandle blk -> MetaEnv (MB b blk) -> MetaEnv (MB b blk) @@ -456,7 +452,7 @@ True -> -- failed immediately return False False -> do - Left solfound <- lift $ searchSubProb [(mainroot, Nothing)] searchdepth + Left _solFound <- lift $ searchSubProb [(mainroot, Nothing)] searchdepth dr <- lift $ readIORef depthreached return dr @@ -552,7 +548,7 @@ uwriteIORef (ctpriometa node) (PrioMeta prio m) propagatePrio node - QPDoubleBlocked flag _ -> + QPDoubleBlocked _flag _ -> return [] Nothing -> return [] ) oldobs @@ -583,7 +579,7 @@ uwriteIORef (ctsub jnode) $ Just sc ndep <- case coms of Nothing -> return 1 -- no metas pointing to it so will never decrement to 0 - Just coms -> return 1 -- dito + Just _coms -> return 1 -- dito lift $ NoUndo.writeIORef (sccomcount sc) ndep -- OK since sc was just created resp1 <- donewp (Just $ scsub1 sc) p1 case resp1 of @@ -650,7 +646,7 @@ RightDisjunct -> p2 instance Refinable Choice blk where - refinements _ x _ = return $ Move 0 . return <$> [LeftDisjunct, RightDisjunct] + refinements _ _ _ = return $ Move 0 . return <$> [LeftDisjunct, RightDisjunct] instance Refinable OKVal blk where diff --git a/src/full/Agda/Auto/SearchControl.hs b/src/full/Agda/Auto/SearchControl.hs --- a/src/full/Agda/Auto/SearchControl.hs +++ b/src/full/Agda/Auto/SearchControl.hs @@ -1,11 +1,8 @@ -{-# LANGUAGE CPP #-} -{-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE UndecidableInstances #-} {-# OPTIONS_GHC -fno-warn-orphans #-} module Agda.Auto.SearchControl where -import Control.Applicative hiding (getConst, Const(..)) import Control.Monad import Data.IORef import Control.Monad.State @@ -15,7 +12,6 @@ import Agda.Auto.NarrowingSearch import Agda.Auto.Syntax -#include "undefined.h" import Agda.Utils.Impossible instance Refinable (ArgList o) (RefInfo o) where diff --git a/src/full/Agda/Auto/Syntax.hs b/src/full/Agda/Auto/Syntax.hs --- a/src/full/Agda/Auto/Syntax.hs +++ b/src/full/Agda/Auto/Syntax.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} module Agda.Auto.Syntax where @@ -8,7 +7,6 @@ import Agda.Syntax.Common (Hiding) import Agda.Auto.NarrowingSearch -#include "undefined.h" import Agda.Utils.Impossible -- | Unique identifiers for variable occurrences in unification. diff --git a/src/full/Agda/Auto/Typecheck.hs b/src/full/Agda/Auto/Typecheck.hs --- a/src/full/Agda/Auto/Typecheck.hs +++ b/src/full/Agda/Auto/Typecheck.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} module Agda.Auto.Typecheck where @@ -10,7 +9,6 @@ import Agda.Auto.Syntax import Agda.Auto.SearchControl -#include "undefined.h" import Agda.Utils.Impossible -- --------------------------------- diff --git a/src/full/Agda/Benchmarking.hs b/src/full/Agda/Benchmarking.hs --- a/src/full/Agda/Benchmarking.hs +++ b/src/full/Agda/Benchmarking.hs @@ -1,7 +1,3 @@ -{-# LANGUAGE CPP #-} -{-# LANGUAGE IncoherentInstances #-} -{-# LANGUAGE NoMonomorphismRestriction #-} - {-# OPTIONS_GHC -fno-warn-orphans #-} -- | Agda-specific benchmarking structure. @@ -15,7 +11,7 @@ import System.IO.Unsafe import Agda.Syntax.Concrete.Name (TopLevelModuleName) -import Agda.Syntax.Concrete.Pretty +import Agda.Syntax.Concrete.Pretty () --instance only import Agda.Syntax.Abstract.Name import Agda.Utils.Benchmark (MonadBench(..)) import qualified Agda.Utils.Benchmark as B @@ -64,6 +60,8 @@ -- ^ Subphase for 'Termination'. | ModuleName -- ^ Subphase for 'Import'. + | Compaction + -- ^ Subphase for 'Deserialization': compacting interfaces. | BuildInterface -- ^ Subphase for 'Serialization'. | Sort diff --git a/src/full/Agda/Compiler/Backend.hs b/src/full/Agda/Compiler/Backend.hs --- a/src/full/Agda/Compiler/Backend.hs +++ b/src/full/Agda/Compiler/Backend.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE PolyKinds #-} {-# LANGUAGE TypeOperators #-} @@ -10,33 +9,41 @@ , toTreeless , module Agda.Syntax.Treeless , module Agda.TypeChecking.Monad + , activeBackendMayEraseType -- For Agda.Main , backendInteraction , parseBackendOptions -- For InteractionTop , callBackend + -- Tools + , lookupBackend + , activeBackend ) where import Control.Monad.State +import Control.Monad.Trans.Maybe import qualified Data.List as List -import Data.Functor +import Data.Maybe import Data.Map (Map) import qualified Data.Map as Map -import System.Environment -import System.Exit import System.Console.GetOpt import Agda.Syntax.Treeless -import Agda.TypeChecking.Monad +-- Agda.TypeChecking.Monad.Base imports us, relying on the .hs-boot file to +-- resolve the circular dependency. Fine. However, ghci loads the module after +-- compilation, so it brings in all of the symbols. That causes .Base to see +-- getBenchmark (defined in Agda.TypeChecking.Monad.State) *and* the one +-- defined in Agda.Utils.Benchmark, which causes an error. So we explicitly +-- hide it here to prevent it from being seen there and causing an error. +import Agda.TypeChecking.Monad hiding (getBenchmark) import Agda.TypeChecking.Reduce import Agda.TypeChecking.Pretty as P import Agda.Interaction.Options import Agda.Interaction.FindFile -import Agda.Interaction.Highlighting.HTML import Agda.Interaction.Imports (getAllWarnings) import Agda.TypeChecking.Warnings @@ -45,12 +52,10 @@ import Agda.Utils.IndexedList import Agda.Utils.Lens import Agda.Utils.Monad -import Agda.Utils.Pretty import Agda.Compiler.ToTreeless import Agda.Compiler.Common -#include "undefined.h" import Agda.Utils.Impossible -- Public interface ------------------------------------------------------- @@ -75,27 +80,34 @@ , postCompile :: env -> IsMain -> Map ModuleName mod -> TCM () -- ^ Called after module compilation has completed. The @IsMain@ argument -- is @NotMain@ if the @--no-main@ flag is present. - , preModule :: env -> ModuleName -> FilePath -> TCM (Recompile menv mod) + , preModule :: env -> IsMain -> ModuleName -> FilePath -> TCM (Recompile menv mod) -- ^ Called before compilation of each module. Gets the path to the -- @.agdai@ file to allow up-to-date checking of previously written -- compilation results. Should return @Skip m@ if compilation is not -- required. , postModule :: env -> menv -> IsMain -> ModuleName -> [def] -> TCM mod - -- ^ Called after all definitions of a module has been compiled. + -- ^ Called after all definitions of a module have been compiled. , compileDef :: env -> menv -> IsMain -> Definition -> TCM def -- ^ Compile a single definition. , scopeCheckingSuffices :: Bool - -- ^ True if the backend works if @--only-scope-checking@ is used. + -- ^ True if the backend works if @--only-scope-checking@ is used. + , mayEraseType :: QName -> TCM Bool + -- ^ The treeless compiler may ask the Backend if elements + -- of the given type maybe possibly erased. + -- The answer should be 'False' if the compilation of the type + -- is used by a third party, e.g. in a FFI binding. } data Recompile menv mod = Recompile menv | Skip mod +-- | Call the 'compilerMain' function of the given backend. + callBackend :: String -> IsMain -> Interface -> TCM () -callBackend name iMain i = do - backends <- useTC stBackends - case [ b | b@(Backend b') <- backends, backendName b' == name ] of - Backend b : _ -> compilerMain b iMain i - [] -> genericError $ +callBackend name iMain i = lookupBackend name >>= \case + Just (Backend b) -> compilerMain b iMain i + Nothing -> do + backends <- useTC stBackends + genericError $ "No backend called '" ++ name ++ "' " ++ "(installed backends: " ++ List.intercalate ", " @@ -109,6 +121,27 @@ otherBackends :: [String] otherBackends = ["GHCNoMain", "LaTeX", "QuickLaTeX"] +-- | Look for a backend of the given name. + +lookupBackend :: BackendName -> TCM (Maybe Backend) +lookupBackend name = useTC stBackends <&> \ backends -> + listToMaybe [ b | b@(Backend b') <- backends, backendName b' == name ] + +-- | Get the currently active backend (if any). + +activeBackend :: TCM (Maybe Backend) +activeBackend = runMaybeT $ do + bname <- MaybeT $ asksTC envActiveBackendName + lift $ fromMaybe __IMPOSSIBLE__ <$> lookupBackend bname + +-- | Ask the active backend whether a type may be erased. +-- See issue #3732. + +activeBackendMayEraseType :: QName -> TCM Bool +activeBackendMayEraseType q = do + Backend b <- fromMaybe __IMPOSSIBLE__ <$> activeBackend + mayEraseType b q + -- Internals -------------------------------------------------------------- data BackendWithOpts opts where @@ -172,8 +205,8 @@ compilerMain :: Backend' opts env menv mod def -> IsMain -> Interface -> TCM () -compilerMain backend isMain0 i = - inCompilerEnv i $ do +compilerMain backend isMain0 i = inCompilerEnv i $ do + locallyTC eActiveBackendName (const $ Just $ backendName backend) $ do onlyScoping <- optOnlyScopeChecking <$> commandLineOptions when (not (scopeCheckingSuffices backend) && onlyScoping) $ genericError $ @@ -194,9 +227,9 @@ compileModule :: Backend' opts env menv mod def -> env -> IsMain -> Interface -> TCM mod compileModule backend env isMain i = do - ifile <- maybe __IMPOSSIBLE__ filePath <$> - (findInterfaceFile . toTopLevelModuleName =<< curMName) - r <- preModule backend env (iModuleName i) ifile + mName <- toTopLevelModuleName <$> curMName + ifile <- maybe __IMPOSSIBLE__ (filePath . intFilePath) <$> findInterfaceFile mName + r <- preModule backend env isMain (iModuleName i) ifile case r of Skip m -> return m Recompile menv -> do @@ -205,4 +238,6 @@ postModule backend env menv isMain (iModuleName i) res compileDef' :: Backend' opts env menv mod def -> env -> menv -> IsMain -> Definition -> TCM def -compileDef' backend env menv isMain def = setCurrentRange (defName def) $ compileDef backend env menv isMain def +compileDef' backend env menv isMain def = + setCurrentRange (defName def) $ + compileDef backend env menv isMain def diff --git a/src/full/Agda/Compiler/Backend.hs-boot b/src/full/Agda/Compiler/Backend.hs-boot --- a/src/full/Agda/Compiler/Backend.hs-boot +++ b/src/full/Agda/Compiler/Backend.hs-boot @@ -1,4 +1,29 @@ -module Agda.Compiler.Backend where +module Agda.Compiler.Backend + ( module Agda.Syntax.Treeless + , Backend + , activeBackendMayEraseType + , lookupBackend + ) + where +-- Explicitly adding the Agda.Syntax.Treeless import to the .hs-boot file +-- so that the `Args` symbol can be hidden by the `SOURCE` import in +-- TypeChecking.Monad.Base. +-- +-- Without exporting it here, a `hiding` clause there causes a compilation +-- error. But without hiding it there, the name conflicts with the one +-- imported from Agda.Syntax.Internal. +-- +-- This is only a problem with ghci, which will load a fully-compiled module if +-- available; but that module will contain more symbols than just the few in +-- the .hs-boot +import Agda.Syntax.Treeless (TTerm, Args) + +import Agda.Syntax.Abstract.Name (QName) +import {-# SOURCE #-} Agda.TypeChecking.Monad.Base (TCM, BackendName) + data Backend + +activeBackendMayEraseType :: QName -> TCM Bool +lookupBackend :: BackendName -> TCM (Maybe Backend) diff --git a/src/full/Agda/Compiler/CallCompiler.hs b/src/full/Agda/Compiler/CallCompiler.hs --- a/src/full/Agda/Compiler/CallCompiler.hs +++ b/src/full/Agda/Compiler/CallCompiler.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} ------------------------------------------------------------------------ -- | A command which calls a compiler @@ -10,14 +9,12 @@ import Control.Monad.Trans import Data.List ( intercalate ) -import qualified Data.List as List import System.Exit import System.IO import System.Process import Agda.TypeChecking.Monad -#include "undefined.h" import Agda.Utils.Impossible -- | Calls a compiler: diff --git a/src/full/Agda/Compiler/Common.hs b/src/full/Agda/Compiler/Common.hs --- a/src/full/Agda/Compiler/Common.hs +++ b/src/full/Agda/Compiler/Common.hs @@ -1,44 +1,34 @@ {-# LANGUAGE CPP #-} -{-# LANGUAGE ScopedTypeVariables #-} module Agda.Compiler.Common where import Data.List as List -import Data.Map (Map) import qualified Data.Map as Map import Data.Set (Set) import qualified Data.Set as Set +import qualified Data.HashMap.Strict as HMap import Data.Char import Data.Function +#if __GLASGOW_HASKELL__ < 804 import Data.Semigroup -import Data.Monoid hiding ((<>)) +#endif import Control.Monad import Control.Monad.State hiding (mapM_, forM_, mapM, forM, sequence) -import Agda.Syntax.Common -import qualified Agda.Syntax.Abstract.Name as A import qualified Agda.Syntax.Concrete.Name as C import Agda.Syntax.Internal as I import Agda.Interaction.FindFile -import Agda.Interaction.Imports import Agda.Interaction.Options import Agda.TypeChecking.Monad -import Agda.TypeChecking.Pretty hiding ((<>)) -import Agda.TypeChecking.Reduce -import Agda.TypeChecking.Substitute -import Agda.TypeChecking.Telescope import Agda.Utils.FileName -import qualified Agda.Utils.HashMap as HMap import Agda.Utils.Lens import Agda.Utils.Maybe -import Agda.Utils.Monad -import Agda.Utils.Pretty hiding ((<>)) +import Agda.Utils.Pretty -#include "undefined.h" import Agda.Utils.Impossible data IsMain = IsMain | NotMain @@ -136,15 +126,6 @@ go [] = [] --- | Copy pasted from MAlonzo.... --- Move somewhere else! -conArityAndPars :: QName -> TCM (Nat, Nat) -conArityAndPars q = do - def <- getConstInfo q - n <- typeArity (defType def) - let Constructor{ conPars = np } = theDef def - return (n - np, np) - -- | Sets up the compilation environment. inCompilerEnv :: Interface -> TCM a -> TCM a inCompilerEnv mainI cont = do @@ -164,7 +145,7 @@ Nothing -> do -- The default output directory is the project root. let tm = toTopLevelModuleName $ iModuleName mainI - f <- findFile tm + f <- srcFilePath <$> findFile tm return $ filePath $ C.projectRoot f tm setCommandLineOptions $ opts { optCompileDir = Just compileDir } @@ -177,8 +158,7 @@ stPragmaOptions `modifyTCLens` \ o -> o { optCompileNoMain = True } setScope (iInsideScope mainI) -- so that compiler errors don't use overly qualified names - ignoreAbstractMode $ do - cont + ignoreAbstractMode cont -- keep generated warnings let newWarnings = stPostTCWarnings $ stPostScopeState $ s stTCWarnings `setTCLens` newWarnings diff --git a/src/full/Agda/Compiler/JS/Compiler.hs b/src/full/Agda/Compiler/JS/Compiler.hs --- a/src/full/Agda/Compiler/JS/Compiler.hs +++ b/src/full/Agda/Compiler/JS/Compiler.hs @@ -1,57 +1,50 @@ -{-# LANGUAGE CPP #-} module Agda.Compiler.JS.Compiler where import Prelude hiding ( null, writeFile ) + import Control.Monad.Reader ( liftIO ) import Control.Monad.Trans + import Data.Char ( isSpace ) -import Data.List ( intercalate, genericLength, partition ) -import Data.Maybe ( isJust ) +import Data.List ( intercalate, partition ) import Data.Set ( Set, null, insert, difference, delete ) import Data.Traversable (traverse) -import Data.Map ( fromList, elems ) +import Data.Map ( fromList ) import qualified Data.Set as Set import qualified Data.Map as Map + import System.Directory ( createDirectoryIfMissing ) import System.FilePath ( splitFileName, () ) -import Agda.Interaction.FindFile ( findFile, findInterfaceFile ) +import Paths_Agda + +import Agda.Interaction.Options import Agda.Interaction.Imports ( isNewerThan ) -import Agda.Interaction.Options ( optCompileDir ) -import Agda.Syntax.Common ( Nat, unArg, namedArg, NameId(..) ) -import Agda.Syntax.Concrete.Name ( projectRoot , isNoName ) + +import Agda.Syntax.Common +import Agda.Syntax.Concrete.Name ( isNoName ) import Agda.Syntax.Abstract.Name - ( ModuleName(MName), QName, - mnameToConcrete, - mnameToList, qnameName, qnameModule, isInModule, nameId ) + ( ModuleName, QName, + mnameToList, qnameName, qnameModule, nameId ) import Agda.Syntax.Internal - ( Name, Args, Type, - conName, - toTopLevelModuleName, arity, unEl, unAbs, nameFixity ) -import Agda.Syntax.Position + ( Name, Type + , arity, nameFixity, unDom ) import Agda.Syntax.Literal ( Literal(..) ) -import Agda.Syntax.Fixity import qualified Agda.Syntax.Treeless as T -import Agda.TypeChecking.Substitute ( absBody ) -import Agda.TypeChecking.Level ( reallyUnLevelView ) + import Agda.TypeChecking.Monad import Agda.TypeChecking.Monad.Builtin import Agda.TypeChecking.Monad.Debug ( reportSLn ) -import Agda.TypeChecking.Monad.Options ( setCommandLineOptions ) -import Agda.TypeChecking.Reduce ( instantiateFull, normalise ) -import Agda.TypeChecking.Substitute (TelV(..)) -import Agda.TypeChecking.Telescope +import Agda.TypeChecking.Reduce ( instantiateFull ) import Agda.TypeChecking.Pretty -import Agda.Utils.FileName ( filePath ) -import Agda.Utils.Function ( iterate' ) + import Agda.Utils.Maybe import Agda.Utils.Monad ( (<$>), (<*>), ifM ) import Agda.Utils.Pretty (prettyShow) import qualified Agda.Utils.Pretty as P import Agda.Utils.IO.Directory import Agda.Utils.IO.UTF8 ( writeFile ) -import qualified Agda.Utils.HashMap as HMap import Agda.Compiler.Common import Agda.Compiler.ToTreeless @@ -65,15 +58,10 @@ LocalId(LocalId), GlobalId(GlobalId), MemberId(MemberId), Export(Export), Module(Module), modName, expName, uses ) import Agda.Compiler.JS.Substitution - ( curriedLambda, curriedApply, emp, subst, apply ) + ( curriedLambda, curriedApply, emp, apply ) import qualified Agda.Compiler.JS.Pretty as JSPretty -import Agda.Interaction.Options - -import Paths_Agda - -#include "undefined.h" -import Agda.Utils.Impossible ( Impossible(Impossible), throwImpossible ) +import Agda.Utils.Impossible (__IMPOSSIBLE__) -------------------------------------------------- -- Entry point into the compiler @@ -95,6 +83,12 @@ , postModule = jsPostModule , compileDef = jsCompileDef , scopeCheckingSuffices = False + , mayEraseType = const $ return True + -- Andreas, 2019-05-09, see issue #3732. + -- If you want to use JS data structures generated from Agda + -- @data@/@record@, you might want to tell the treeless compiler + -- not to erase these types even if they have no content, + -- to get a stable interface. } --- Options --- @@ -125,8 +119,8 @@ type JSModuleEnv = Maybe CoinductionKit -jsPreModule :: JSOptions -> ModuleName -> FilePath -> TCM (Recompile JSModuleEnv ()) -jsPreModule _ m ifile = ifM uptodate noComp yesComp +jsPreModule :: JSOptions -> IsMain -> ModuleName -> FilePath -> TCM (Recompile JSModuleEnv ()) +jsPreModule _ _ m ifile = ifM uptodate noComp yesComp where uptodate = liftIO =<< isNewerThan <$> outFile_ <*> pure ifile @@ -335,7 +329,7 @@ ( (last ls , Lambda 1 (Apply (Lookup (Local (LocalId 0)) (last ls)) [ Local (LocalId (np - i)) | i <- [0 .. np-1] ])) - : (zip [ jsMember (qnameName (unArg fld)) | fld <- flds ] + : (zip [ jsMember (qnameName (unDom fld)) | fld <- flds ] [ Local (LocalId (np - i)) | i <- [1 .. np] ]))))) _ -> ret (curriedLambda (np + 1) @@ -497,7 +491,7 @@ litAssoc RightAssoc = String "right-assoc" litPrec Unrelated = String "unrelated" - litPrec (Related l) = Integer l + litPrec (Related l) = Double l -------------------------------------------------- -- Writing out an ECMAScript module @@ -521,7 +515,6 @@ outFile_ = do m <- curMName outFile (jsMod m) - copyRTEModules :: TCM () copyRTEModules = do diff --git a/src/full/Agda/Compiler/JS/Pretty.hs b/src/full/Agda/Compiler/JS/Pretty.hs --- a/src/full/Agda/Compiler/JS/Pretty.hs +++ b/src/full/Agda/Compiler/JS/Pretty.hs @@ -1,10 +1,10 @@ module Agda.Compiler.JS.Pretty where import Prelude hiding ( null ) +import Data.Char ( isAsciiLower, isAsciiUpper, isDigit ) import Data.List ( intercalate ) import Data.Set ( Set, toList, singleton, insert, member ) import Data.Map ( Map, toAscList, empty, null ) -import Text.Regex.TDFA (makeRegex, matchTest, Regex) import Agda.Syntax.Common ( Nat ) import Agda.Utils.Hash @@ -128,8 +128,13 @@ -- | Check if a string is a valid JS identifier. The check ignores keywords -- as we prepend z_ to our identifiers. The check -- is conservative and may not admit all valid JS identifiers. + isValidJSIdent :: String -> Bool -isValidJSIdent s = matchTest regex s +isValidJSIdent [] = False +isValidJSIdent (c:cs) = validFirst c && all validOther cs where - regex :: Regex - regex = makeRegex ("^[a-zA-Z_$][0-9a-zA-Z_$]*$" :: String) + validFirst :: Char -> Bool + validFirst c = isAsciiUpper c || isAsciiLower c || c == '_' || c == '$' + + validOther :: Char -> Bool + validOther c = validFirst c || isDigit c diff --git a/src/full/Agda/Compiler/JS/Syntax.hs b/src/full/Agda/Compiler/JS/Syntax.hs --- a/src/full/Agda/Compiler/JS/Syntax.hs +++ b/src/full/Agda/Compiler/JS/Syntax.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DeriveDataTypeable #-} module Agda.Compiler.JS.Syntax where diff --git a/src/full/Agda/Compiler/MAlonzo/Coerce.hs b/src/full/Agda/Compiler/MAlonzo/Coerce.hs --- a/src/full/Agda/Compiler/MAlonzo/Coerce.hs +++ b/src/full/Agda/Compiler/MAlonzo/Coerce.hs @@ -1,11 +1,10 @@ -module Agda.Compiler.MAlonzo.Coerce (addCoercions) where +module Agda.Compiler.MAlonzo.Coerce (addCoercions, erasedArity) where +import Agda.Syntax.Common (Nat) import Agda.Syntax.Treeless + import Agda.TypeChecking.Monad -import Agda.TypeChecking.Telescope -import Agda.TypeChecking.Substitute -import Agda.Utils.Functor -- | Insert unsafeCoerce (in the form of 'TCoerce') everywhere it's needed in -- the right-hand side of a definition. @@ -66,9 +65,12 @@ TLet e b -> TLet <$> softCoerce e <*> softCoerce b TCase x t d bs -> TCase x t <$> coerce d <*> mapM coerceAlt bs -funArity :: TTerm -> TCM Int +funArity :: TTerm -> TCM Nat funArity (TDef q) = maybe 0 (fst . tLamView) <$> getTreeless q -funArity (TCon q) = length . filter not <$> getErasedConArgs q +funArity (TCon q) = erasedArity q funArity (TPrim _) = return 3 -- max arity of any primitive funArity _ = return 0 +-- | The number of retained arguments after erasure. +erasedArity :: QName -> TCM Nat +erasedArity q = length . filter not <$> getErasedConArgs q diff --git a/src/full/Agda/Compiler/MAlonzo/Compiler.hs b/src/full/Agda/Compiler/MAlonzo/Compiler.hs --- a/src/full/Agda/Compiler/MAlonzo/Compiler.hs +++ b/src/full/Agda/Compiler/MAlonzo/Compiler.hs @@ -1,25 +1,13 @@ -{-# LANGUAGE CPP #-} module Agda.Compiler.MAlonzo.Compiler where -#if MIN_VERSION_base(4,11,0) -import Prelude hiding ((<>)) -#endif - import Control.Monad.Reader hiding (mapM_, forM_, mapM, forM, sequence) -import Control.Monad.State hiding (mapM_, forM_, mapM, forM, sequence) -import Data.Generics.Geniplate -import Data.Foldable hiding (any, all, foldr, sequence_) -import Data.Function import qualified Data.List as List import Data.Map (Map) import qualified Data.Map as Map import Data.Maybe -import Data.Set (Set) import qualified Data.Set as Set -import Data.Traversable hiding (for) -import Data.Monoid hiding ((<>)) import Numeric.IEEE @@ -41,33 +29,26 @@ import Agda.Compiler.Treeless.Erase import Agda.Compiler.Backend -import Agda.Interaction.FindFile import Agda.Interaction.Imports import Agda.Interaction.Options import Agda.Syntax.Common import Agda.Syntax.Fixity import qualified Agda.Syntax.Abstract.Name as A -import qualified Agda.Syntax.Concrete.Name as C import Agda.Syntax.Internal as I import Agda.Syntax.Internal.Names (namesIn) import qualified Agda.Syntax.Treeless as T import Agda.Syntax.Literal -import Agda.TypeChecking.Monad import Agda.TypeChecking.Monad.Builtin -import Agda.TypeChecking.Datatypes import Agda.TypeChecking.Primitive (getBuiltinName) -import Agda.TypeChecking.Records import Agda.TypeChecking.Reduce import Agda.TypeChecking.Pretty import Agda.TypeChecking.Substitute import Agda.TypeChecking.Telescope import Agda.TypeChecking.Warnings -import Agda.TypeChecking.CompiledClause - -import Agda.Utils.FileName +import Agda.Utils.Function import Agda.Utils.Functor import Agda.Utils.IO.Directory import Agda.Utils.Lens @@ -76,15 +57,10 @@ import Agda.Utils.Monad import Agda.Utils.Pretty (prettyShow, Pretty) import qualified Agda.Utils.IO.UTF8 as UTF8 -import qualified Agda.Utils.HashMap as HMap -import Agda.Utils.Singleton -import Agda.Utils.Size import Agda.Utils.String -import Agda.Utils.Tuple import Paths_Agda -#include "undefined.h" import Agda.Utils.Impossible -- The backend callbacks -------------------------------------------------- @@ -105,6 +81,7 @@ , postModule = ghcPostModule , compileDef = ghcCompileDef , scopeCheckingSuffices = False + , mayEraseType = ghcMayEraseType } --- Options --- @@ -153,14 +130,20 @@ type GHCModuleEnv = () -ghcPreModule :: GHCOptions -> ModuleName -> FilePath -> TCM (Recompile GHCModuleEnv IsMain) -ghcPreModule _ m ifile = ifM uptodate noComp yesComp +ghcPreModule + :: GHCOptions + -> IsMain -- ^ Are we looking at the main module? + -> ModuleName + -> FilePath -- ^ Path to the @.agdai@ file. + -> TCM (Recompile GHCModuleEnv IsMain) + -- ^ Could we confirm the existence of a main function? +ghcPreModule _ isMain m ifile = ifM uptodate noComp yesComp where uptodate = liftIO =<< isNewerThan <$> outFile_ <*> pure ifile noComp = do reportSLn "compile.ghc" 2 . (++ " : no compilation is needed.") . show . A.mnameToConcrete =<< curMName - Skip . hasMainFunction <$> curIF + Skip . hasMainFunction isMain <$> curIF yesComp = do m <- show . A.mnameToConcrete <$> curMName @@ -169,8 +152,14 @@ stImportedModules `setTCLens` Set.empty -- we use stImportedModules to accumulate the required Haskell imports return (Recompile ()) -ghcPostModule :: GHCOptions -> GHCModuleEnv -> IsMain -> ModuleName -> [[HS.Decl]] -> TCM IsMain -ghcPostModule _ _ _ _ defs = do +ghcPostModule + :: GHCOptions + -> GHCModuleEnv + -> IsMain -- ^ Are we looking at the main module? + -> ModuleName + -> [[HS.Decl]] -- ^ Compiled module content. + -> TCM IsMain -- ^ Could we confirm the existence of a main function? +ghcPostModule _ _ isMain _ defs = do m <- curHsMod imps <- imports -- Get content of FOREIGN pragmas. @@ -179,11 +168,22 @@ (map HS.OtherPragma headerPragmas) imps (map fakeDecl (hsImps ++ code) ++ concat defs) - hasMainFunction <$> curIF + hasMainFunction isMain <$> curIF ghcCompileDef :: GHCOptions -> GHCModuleEnv -> IsMain -> Definition -> TCM [HS.Decl] -ghcCompileDef _ = definition +ghcCompileDef _ env isMain def = definition env isMain def +-- | We do not erase types that have a 'HsData' pragma. +-- This is to ensure a stable interface to third-party code. +ghcMayEraseType :: QName -> TCM Bool +ghcMayEraseType q = getHaskellPragma q <&> \case + -- Andreas, 2019-05-09, issue #3732. + -- We restrict this to 'HsData' since types like @Size@, @Level@ + -- should be erased although they have a 'HsType' binding to the + -- Haskell unit type. + Just HsData{} -> False + _ -> True + -- Compilation ------------------------------------------------------------ -------------------------------------------------- @@ -231,11 +231,11 @@ -} definition _env _isMain Defn{defArgInfo = info, defName = q} | not $ usableModality info = do reportSDoc "compile.ghc.definition" 10 $ - "Not compiling" <+> prettyTCM q <> "." + ("Not compiling" <+> prettyTCM q) <> "." return [] definition env isMain def@Defn{defName = q, defType = ty, theDef = d} = do reportSDoc "compile.ghc.definition" 10 $ vcat - [ "Compiling" <+> prettyTCM q <> ":" + [ ("Compiling" <+> prettyTCM q) <> ":" , nest 2 $ text (show d) ] pragma <- getHaskellPragma q @@ -246,22 +246,22 @@ checkTypeOfMain isMain q def $ do infodecl q <$> case d of - _ | Just HsDefn{} <- pragma, Just q == mflat -> - genericError - "\"COMPILE GHC\" pragmas are not allowed for the FLAT builtin." - - _ | Just (HsDefn r hs) <- pragma -> setCurrentRange r $ do - -- Make sure we have imports for all names mentioned in the type. - hsty <- haskellType q - ty <- normalise ty - sequence_ [ xqual x (HS.Ident "_") | x <- Set.toList (namesIn ty) ] + _ | Just (HsDefn r hs) <- pragma -> setCurrentRange r $ + if Just q == mflat + then genericError + "\"COMPILE GHC\" pragmas are not allowed for the FLAT builtin." + else do + -- Make sure we have imports for all names mentioned in the type. + hsty <- haskellType q + ty <- normalise ty + sequence_ [ xqual x (HS.Ident "_") | x <- Set.toList (namesIn ty) ] - -- Check that the function isn't INLINE (since that will make this - -- definition pointless). - inline <- (^. funInline) . theDef <$> getConstInfo q - when inline $ warning $ UselessInline q + -- Check that the function isn't INLINE (since that will make this + -- definition pointless). + inline <- (^. funInline) . theDef <$> getConstInfo q + when inline $ warning $ UselessInline q - return $ fbWithType hsty (fakeExp hs) + return $ fbWithType hsty (fakeExp hs) -- Compiling Bool Datatype{} | Just q == mbool -> do @@ -321,17 +321,17 @@ ccscov <- constructorCoverageCode q (np + ni) cs ty hsCons cds <- mapM compiledcondecl cs let result = concat $ - [ tvaldecl q (dataInduction d) (np + ni) [] (Just __IMPOSSIBLE__) + [ tvaldecl q Inductive (np + ni) [] (Just __IMPOSSIBLE__) , [ compiledTypeSynonym q ty np ] , cds , ccscov ] return result Datatype{ dataPars = np, dataIxs = ni, dataClause = cl, - dataCons = cs, dataInduction = ind } -> do + dataCons = cs } -> do computeErasedConstructorArgs q - cds <- mapM (flip condecl ind) cs - return $ tvaldecl q ind (np + ni) cds cl + cds <- mapM (flip condecl Inductive) cs + return $ tvaldecl q Inductive (np + ni) cds cl Constructor{} -> return [] GeneralizableVar{} -> return [] Record{ recPars = np, recClause = cl, recConHead = con, @@ -359,17 +359,18 @@ ccls <- mkwhere <$> fun mflat <- getBuiltinName builtinFlat case mhe of - Just HsExport{} | Just q == mflat -> - genericError - "\"COMPILE GHC as\" pragmas are not allowed for the FLAT builtin." - Just (HsExport r name) -> do - t <- setCurrentRange r $ haskellType q - let tsig :: HS.Decl - tsig = HS.TypeSig [HS.Ident name] t + Just (HsExport r name) -> setCurrentRange r $ + if Just q == mflat + then genericError + "\"COMPILE GHC as\" pragmas are not allowed for the FLAT builtin." + else do + t <- setCurrentRange r $ haskellType q + let tsig :: HS.Decl + tsig = HS.TypeSig [HS.Ident name] t - def :: HS.Decl - def = HS.FunBind [HS.Match (HS.Ident name) [] (HS.UnGuardedRhs (hsCoerce $ hsVarUQ $ dname q)) emptyBinds] - return ([tsig,def] ++ ccls) + def :: HS.Decl + def = HS.FunBind [HS.Match (HS.Ident name) [] (HS.UnGuardedRhs (hsCoerce $ hsVarUQ $ dname q)) emptyBinds] + return ([tsig,def] ++ ccls) _ -> return ccls functionViaTreeless :: QName -> TCM [HS.Decl] @@ -523,76 +524,86 @@ -- Erased arguments are extracted as @()@. -- Types are extracted as @()@. term :: T.TTerm -> CC HS.Exp -term tm0 = mkIf tm0 >>= \ tm0 -> case tm0 of - T.TVar i -> do - x <- lookupIndex i <$> view ccContext - return $ hsVarUQ x - T.TApp (T.TPrim T.PIf) [c, x, y] -> HS.If <$> term c - <*> term x - <*> term y - T.TApp t ts | Just (coe, f) <- coerceView t -> do - used <- lift $ getCompiledArgUse f - isCompiled <- lift $ isJust <$> getHaskellPragma f -- #2248: no unused argument pruning for COMPILE'd functions - let given = length ts - needed = length used - missing = drop given used - if not isCompiled && any not used - then if any not missing then term (etaExpand (needed - given) tm0) else do - f <- lift $ coe . HS.Var <$> xhqn "du" f -- used stripped function - f `apps` [ t | (t, True) <- zip ts $ used ++ repeat True ] - else do - t' <- term (T.TDef f) - coe t' `apps` ts - where coerceView (T.TCoerce (T.TDef f)) = Just (hsCoerce, f) - coerceView (T.TDef f) = Just (id, f) - coerceView _ = Nothing - T.TApp (T.TCon c) ts -> do -- Note that constructors are never coerced - (ar, _) <- lift $ conArityAndPars c - erased <- lift $ getErasedConArgs c - let missing = drop (length ts) erased - notErased = not - case all notErased missing of - False -> term $ etaExpand (length missing) tm0 - True -> do - f <- lift $ HS.Con <$> conhqn c - f `apps` [ t | (t, False) <- zip ts erased ] - T.TApp t ts -> do - t' <- term t - t' `apps` ts - T.TLam at -> do - (nm:_) <- view ccNameSupply - intros 1 $ \ [x] -> - hsLambda [HS.PVar x] <$> term at +term tm0 = mkIf tm0 >>= \ tm0 -> do + let ((hasCoerce, t), ts) = coerceAppView tm0 + -- let (t0, ts) = tAppView tm0 + -- let (hasCoerce, t) = coerceView t0 + let coe = applyWhen hasCoerce hsCoerce + case (t, ts) of + (T.TPrim T.PIf, [c, x, y]) -> coe <$> do HS.If <$> term c <*> term x <*> term y + + (T.TDef f, ts) -> do + used <- lift $ getCompiledArgUse f + -- #2248: no unused argument pruning for COMPILE'd functions + isCompiled <- lift $ isJust <$> getHaskellPragma f + let given = length ts + needed = length used + missing = drop given used + notUsed = not + if not isCompiled && any not used + then if any notUsed missing then term (etaExpand (needed - given) tm0) else do + f <- lift $ HS.Var <$> xhqn "du" f -- use stripped function + -- Andreas, 2019-11-07, issue #4169. + -- Insert coercion unconditionally as erasure of arguments + -- that are matched upon might remove the unfolding of codomain types. + -- (Hard to explain, see test/Compiler/simple/Issue4169.) + hsCoerce f `apps` [ t | (t, True) <- zip ts $ used ++ repeat True ] + else do + f <- lift $ HS.Var <$> xhqn "d" f -- use original (non-stripped) function + coe f `apps` ts + + (T.TCon c, ts) -> do + erased <- lift $ getErasedConArgs c + let missing = drop (length ts) erased + notErased = not + case all notErased missing of + -- If the constructor is fully applied or all missing arguments are retained, + -- we can drop the erased arguments here, doing a complete job of dropping erased arguments. + True -> do + f <- lift $ HS.Con <$> conhqn c + hsCoerce f `apps` [ t | (t, False) <- zip ts erased ] + -- Otherwise, we translate the eta-expanded constructor application. + False -> do + let n = length missing + unless (n >= 1) __IMPOSSIBLE__ -- We will add at least on TLam, not getting a busy loop here. + term $ etaExpand (length missing) tm0 + + -- Other kind of application: fall back to apps. + (t, ts) -> noApplication t >>= \ t' -> coe t' `apps` ts + where + apps = foldM (\ h a -> HS.App h <$> term a) + etaExpand n t = mkTLam n $ raise n t `T.mkTApp` map T.TVar (downFrom n) + +-- | Translate a non-application, non-coercion, non-constructor, non-definition term. +noApplication :: T.TTerm -> CC HS.Exp +noApplication = \case + T.TApp{} -> __IMPOSSIBLE__ + T.TCoerce{} -> __IMPOSSIBLE__ + T.TCon{} -> __IMPOSSIBLE__ + T.TDef{} -> __IMPOSSIBLE__ + + T.TVar i -> hsVarUQ . lookupIndex i <$> view ccContext + T.TLam t -> intros 1 $ \ [x] -> hsLambda [HS.PVar x] <$> term t + T.TLet t1 t2 -> do t1' <- term t1 intros 1 $ \[x] -> do - t2' <- term t2 - return $ hsLet x t1' t2' + hsLet x t1' <$> term t2 T.TCase sc ct def alts -> do - sc' <- term (T.TVar sc) + sc' <- term $ T.TVar sc alts' <- traverse (alt sc) alts - def' <- term def + def' <- term def let defAlt = HS.Alt HS.PWildCard (HS.UnGuardedRhs def') emptyBinds - return $ HS.Case (hsCoerce sc') (alts' ++ [defAlt]) - T.TLit l -> return $ literal l - T.TDef q -> do - HS.Var <$> (lift $ xhqn "d" q) - T.TCon q -> term (T.TApp (T.TCon q) []) - T.TPrim p -> return $ compilePrim p - T.TUnit -> return HS.unit_con - T.TSort -> return HS.unit_con - T.TCoerce e -> hsCoerce <$> term e - T.TErased -> return $ hsVarUQ $ HS.Ident mazErasedName - T.TError e -> return $ case e of - T.TUnreachable -> rtmUnreachableError - where apps = foldM (\ h a -> HS.App h <$> term a) - etaExpand n t = - foldr (const T.TLam) - (T.mkTApp (raise n t) [T.TVar i | i <- [n - 1, n - 2..0]]) - (replicate n ()) + T.TLit l -> return $ literal l + T.TPrim p -> return $ compilePrim p + T.TUnit -> return $ HS.unit_con + T.TSort -> return $ HS.unit_con + T.TErased -> return $ hsVarUQ $ HS.Ident mazErasedName + T.TError e -> return $ case e of + T.TUnreachable -> rtmUnreachableError hsCoerce :: HS.Exp -> HS.Exp hsCoerce t = HS.App mazCoerce t @@ -691,7 +702,9 @@ , HS.Lit $ HS.String $ prettyShow x , rteCon "Fixity" `apps` [ litAssoc (fixityAssoc fx) - , litPrec (fixityLevel fx) ] ] + , litPrec (fixityLevel fx) + ] + ] where apps = foldl HS.App rteCon name = HS.Con $ HS.Qual mazRTE $ HS.Ident name @@ -703,7 +716,7 @@ litAssoc RightAssoc = rteCon "RightAssoc" litPrec Unrelated = rteCon "Unrelated" - litPrec (Related l) = rteCon "Related" `HS.App` hsTypedInt l + litPrec (Related l) = rteCon "Related" `HS.App` hsTypedDouble l litqnamepat :: QName -> HS.Pat litqnamepat x = @@ -714,12 +727,6 @@ where NameId n m = nameId $ qnameName x -erasedArity :: QName -> TCM Nat -erasedArity q = do - (ar, _) <- conArityAndPars q - erased <- length . filter id <$> getErasedConArgs q - return (ar - erased) - condecl :: QName -> Induction -> TCM HS.ConDecl condecl q _ind = do def <- getConstInfo q @@ -728,7 +735,7 @@ let argTypes = [ (Just HS.Lazy, t) -- Currently all constructors are lazy. | (t, False) <- zip (drop np argTypes0) - (erased ++ repeat False) + (fromMaybe [] erased ++ repeat False) ] return $ HS.ConDecl (unqhname "C" q) argTypes @@ -795,7 +802,7 @@ , "ExistentialQuantification" , "ScopedTypeVariables" , "NoMonomorphismRestriction" - , "Rank2Types" + , "RankNTypes" , "PatternSynonyms" ] @@ -850,7 +857,8 @@ , "-fno-warn-overlapping-patterns" ] args = overridableArgs ++ ghcopts ++ otherArgs - compiler = "ghc" + + compiler <- fromMaybeM (pure "ghc") (optWithCompiler <$> commandLineOptions) -- Note: Some versions of GHC use stderr for progress reports. For -- those versions of GHC we don't print any progress information diff --git a/src/full/Agda/Compiler/MAlonzo/Encode.hs b/src/full/Agda/Compiler/MAlonzo/Encode.hs --- a/src/full/Agda/Compiler/MAlonzo/Encode.hs +++ b/src/full/Agda/Compiler/MAlonzo/Encode.hs @@ -7,7 +7,6 @@ ) where import Data.Char -import Data.Function import qualified Data.List as List import qualified Agda.Utils.Haskell.Syntax as HS diff --git a/src/full/Agda/Compiler/MAlonzo/HaskellTypes.hs b/src/full/Agda/Compiler/MAlonzo/HaskellTypes.hs --- a/src/full/Agda/Compiler/MAlonzo/HaskellTypes.hs +++ b/src/full/Agda/Compiler/MAlonzo/HaskellTypes.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} -- | Translating Agda types to Haskell types. Used to ensure that imported -- Haskell functions have the right type. @@ -9,11 +8,8 @@ , hsTelApproximation, hsTelApproximation' ) where -#if MIN_VERSION_base(4,11,0) -import Prelude hiding ((<>)) -#endif - import Control.Monad (zipWithM) +import Control.Monad.Fail (MonadFail) import Data.Maybe (fromMaybe) import Data.List (intercalate) @@ -31,14 +27,13 @@ import Agda.Compiler.MAlonzo.Pragmas import Agda.Compiler.MAlonzo.Misc -import Agda.Compiler.MAlonzo.Pretty +import Agda.Compiler.MAlonzo.Pretty () --instance only import qualified Agda.Utils.Haskell.Syntax as HS import Agda.Utils.Except import Agda.Utils.Pretty (prettyShow) import Agda.Utils.Null -#include "undefined.h" import Agda.Utils.Impossible hsQCon :: String -> String -> HS.Type @@ -135,7 +130,7 @@ Just HsData{} -> namedType _ -> throwError $ NoPragmaFor x -getHsVar :: MonadTCM tcm => Nat -> tcm HS.Name +getHsVar :: (MonadFail tcm, MonadTCM tcm) => Nat -> tcm HS.Name getHsVar i = HS.Ident . encodeName <$> nameOfBV i where encodeName x = "x" ++ concatMap encode (prettyShow x) @@ -177,15 +172,15 @@ Sort{} -> return hsUnit MetaV{} -> throwError (BadMeta v) DontCare{} -> throwError (BadDontCare v) - Dummy s -> __IMPOSSIBLE_VERBOSE__ s + Dummy s _ -> __IMPOSSIBLE_VERBOSE__ s haskellType :: QName -> TCM HS.Type haskellType q = do def <- getConstInfo q let (np, erased) = case theDef def of - Constructor{ conPars = np, conErased = erased } - -> (np, erased ++ repeat False) + Constructor{ conPars, conErased } + -> (conPars, fromMaybe [] conErased ++ repeat False) _ -> (0, repeat False) stripErased (True : es) (HS.TyFun _ t) = stripErased es t stripErased (False : es) (HS.TyFun s t) = HS.TyFun s $ stripErased es t @@ -199,7 +194,7 @@ Pi a b -> underAbstraction a b $ \b -> hsForall <$> getHsVar 0 <*> underPars (n - 1) b _ -> __IMPOSSIBLE__ ty <- underPars np $ defType def - reportSDoc "tc.pragma.compile" 10 $ ("Haskell type for" <+> prettyTCM q <> ":") pretty ty + reportSDoc "tc.pragma.compile" 10 $ (("Haskell type for" <+> prettyTCM q) <> ":") pretty ty return ty checkConstructorCount :: QName -> [QName] -> [HaskellCode] -> TCM () diff --git a/src/full/Agda/Compiler/MAlonzo/Misc.hs b/src/full/Agda/Compiler/MAlonzo/Misc.hs --- a/src/full/Agda/Compiler/MAlonzo/Misc.hs +++ b/src/full/Agda/Compiler/MAlonzo/Misc.hs @@ -1,18 +1,11 @@ -{-# LANGUAGE CPP #-} module Agda.Compiler.MAlonzo.Misc where -import Control.Monad.State (gets) import Data.Char -import qualified Data.List as List -import Data.Map as Map -import Data.Set as Set -import Data.Function import qualified Agda.Utils.Haskell.Syntax as HS import Agda.Compiler.Common -import Agda.Compiler.MAlonzo.Pragmas import Agda.Syntax.Common import Agda.Syntax.Internal @@ -20,12 +13,8 @@ import Agda.TypeChecking.Monad import Agda.TypeChecking.Monad.Builtin -import Agda.Utils.Lens -import Agda.Utils.Monad import Agda.Utils.Pretty -import Agda.Utils.Maybe -#include "undefined.h" import Agda.Utils.Impossible -------------------------------------------------- @@ -107,6 +96,9 @@ hsTypedInt :: Integral a => a -> HS.Exp hsTypedInt n = HS.ExpTypeSig (HS.Lit (HS.Int $ fromIntegral n)) (HS.TyCon (hsName "Integer")) + +hsTypedDouble :: Real a => a -> HS.Exp +hsTypedDouble n = HS.ExpTypeSig (HS.Lit (HS.Frac $ toRational n)) (HS.TyCon (hsName "Double")) hsLet :: HS.Name -> HS.Exp -> HS.Exp -> HS.Exp hsLet x e b = diff --git a/src/full/Agda/Compiler/MAlonzo/Pragmas.hs b/src/full/Agda/Compiler/MAlonzo/Pragmas.hs --- a/src/full/Agda/Compiler/MAlonzo/Pragmas.hs +++ b/src/full/Agda/Compiler/MAlonzo/Pragmas.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} module Agda.Compiler.MAlonzo.Pragmas where import Control.Monad @@ -6,17 +5,14 @@ import Data.Char import qualified Data.List as List import Data.Traversable (traverse) -import Data.Map (Map) import qualified Data.Map as Map +import Text.ParserCombinators.ReadP import Agda.Syntax.Position import Agda.Syntax.Abstract.Name import Agda.TypeChecking.Monad -import Agda.TypeChecking.Monad.Builtin import Agda.TypeChecking.Primitive -import Agda.Utils.Lens -import Agda.Utils.Parser.ReadP import Agda.Utils.Pretty hiding (char) import Agda.Utils.String ( ltrim ) import Agda.Utils.Three @@ -24,7 +20,6 @@ import Agda.Compiler.Common import Agda.Utils.Impossible -#include "undefined.h" type HaskellCode = String type HaskellType = String @@ -64,12 +59,12 @@ -- HsExport NAME "as NAME" parsePragma :: CompilerPragma -> Either String HaskellPragma parsePragma (CompilerPragma r s) = - case parse pragmaP s of + case [ p | (p, "") <- readP_to_S pragmaP s ] of [] -> Left $ "Failed to parse GHC pragma '" ++ s ++ "'" [p] -> Right p ps -> Left $ "Ambiguous parse of pragma '" ++ s ++ "':\n" ++ unlines (map show ps) -- shouldn't happen where - pragmaP :: ReadP Char HaskellPragma + pragmaP :: ReadP HaskellPragma pragmaP = choice [ exportP, typeP, dataP, defnP ] whitespace = many1 (satisfy isSpace) diff --git a/src/full/Agda/Compiler/MAlonzo/Pretty.hs b/src/full/Agda/Compiler/MAlonzo/Pretty.hs --- a/src/full/Agda/Compiler/MAlonzo/Pretty.hs +++ b/src/full/Agda/Compiler/MAlonzo/Pretty.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} ------------------------------------------------------------------------ -- Pretty-printing of Haskell modules @@ -6,19 +5,12 @@ module Agda.Compiler.MAlonzo.Pretty where -#if MIN_VERSION_base(4,11,0) -import Prelude hiding ((<>)) -#endif - -import Data.Generics.Geniplate import qualified Agda.Utils.Haskell.Syntax as HS import Text.PrettyPrint (empty) import Agda.Compiler.MAlonzo.Encode import Agda.Utils.Pretty -import Agda.Utils.Impossible -#include "undefined.h" prettyPrint :: Pretty a => a -> String prettyPrint = show . pretty @@ -130,7 +122,7 @@ case t of HS.TyForall xs t -> mparens (pr > 0) $ - sep [ "forall" <+> fsep (map pretty xs) <> "." + sep [ ("forall" <+> fsep (map pretty xs)) <> "." , nest 2 $ pretty t ] HS.TyFun a b -> mparens (pr > 4) $ diff --git a/src/full/Agda/Compiler/MAlonzo/Primitives.hs b/src/full/Agda/Compiler/MAlonzo/Primitives.hs --- a/src/full/Agda/Compiler/MAlonzo/Primitives.hs +++ b/src/full/Agda/Compiler/MAlonzo/Primitives.hs @@ -1,11 +1,9 @@ -{-# LANGUAGE CPP #-} module Agda.Compiler.MAlonzo.Primitives where -import Control.Monad.State -import Data.Char import qualified Data.List as List import qualified Data.Map as Map +import qualified Data.HashMap.Strict as HMap import Data.Maybe import Agda.Compiler.Common @@ -23,14 +21,10 @@ import Agda.TypeChecking.Pretty import Agda.Utils.Either -import Agda.Utils.Except import Agda.Utils.Lens -import Agda.Utils.Monad import Agda.Utils.Pretty (prettyShow) -import qualified Agda.Utils.HashMap as HMap import qualified Agda.Utils.Haskell.Syntax as HS -#include "undefined.h" import Agda.Utils.Impossible -- Andreas, 2019-04-29, issue #3731: exclude certain kinds of names, like constructors. @@ -51,8 +45,13 @@ perhaps = "main" == prettyShow (nameConcrete $ qnameName q) -- ignores the qualification!? no = False -hasMainFunction :: Interface -> IsMain -hasMainFunction i +-- | Check for "main" function, but only in the main module. +hasMainFunction + :: IsMain -- ^ Are we looking at the main module? + -> Interface -- ^ The module. + -> IsMain -- ^ Did we find a "main" function? +hasMainFunction NotMain _ = NotMain +hasMainFunction IsMain i | List.any (\ (x, def) -> isMainFunction x $ theDef def) names = IsMain | otherwise = NotMain where @@ -175,6 +174,7 @@ , "primNatModSucAux" |-> binNat4 "(\\ k m n j -> if n > j then mod (n - j - 1) (m + 1) else (k + n))" , "primNatEquality" |-> relNat "(==)" , "primNatLess" |-> relNat "(<)" + , "primShowNat" |-> return "(Data.Text.pack . show :: Integer -> Data.Text.Text)" -- Machine word functions , "primWord64ToNat" |-> return "MAlonzo.RTE.word64ToNat" @@ -196,9 +196,9 @@ , "primFloatNumericalEquality" |-> return "MAlonzo.RTE.eqNumFloat" , "primFloatNumericalLess" |-> return "MAlonzo.RTE.ltNumFloat" , "primFloatSqrt" |-> return "(sqrt :: Double -> Double)" - , "primRound" |-> return "(round :: Double -> Integer)" - , "primFloor" |-> return "(floor :: Double -> Integer)" - , "primCeiling" |-> return "(ceiling :: Double -> Integer)" + , "primRound" |-> return "(round . MAlonzo.RTE.normaliseNaN :: Double -> Integer)" + , "primFloor" |-> return "(floor . MAlonzo.RTE.normaliseNaN :: Double -> Integer)" + , "primCeiling" |-> return "(ceiling . MAlonzo.RTE.normaliseNaN :: Double -> Integer)" , "primExp" |-> return "(exp :: Double -> Double)" , "primLog" |-> return "(log :: Double -> Double)" , "primSin" |-> return "(sin :: Double -> Double)" @@ -209,6 +209,8 @@ , "primATan" |-> return "(atan :: Double -> Double)" , "primATan2" |-> return "(atan2 :: Double -> Double -> Double)" , "primShowFloat" |-> return "(Data.Text.pack . show :: Double -> Data.Text.Text)" + , "primFloatToWord64" |-> return "MAlonzo.RTE.doubleToWord64" + , "primFloatToWord64Injective" |-> return "erased" -- Character functions , "primCharEquality" |-> rel "(==)" "Char" @@ -240,9 +242,13 @@ , "primQNameLess" |-> rel "(<)" "MAlonzo.RTE.QName" , "primShowQName" |-> return "Data.Text.pack . MAlonzo.RTE.qnameString" , "primQNameFixity" |-> return "MAlonzo.RTE.qnameFixity" + , "primQNameToWord64s" |-> return "\\ qn -> (MAlonzo.RTE.nameId qn, MAlonzo.RTE.moduleId qn)" + , "primQNameToWord64sInjective" |-> return "erased" , "primMetaEquality" |-> rel "(==)" "Integer" , "primMetaLess" |-> rel "(<)" "Integer" , "primShowMeta" |-> return "\\ x -> Data.Text.pack (\"_\" ++ show (x :: Integer))" + , "primMetaToNat" |-> return "(id :: Integer -> Integer)" + , "primMetaToNatInjective" |-> return "erased" -- Seq , "primForce" |-> return "\\ _ _ _ _ x f -> f $! x" diff --git a/src/full/Agda/Compiler/ToTreeless.hs b/src/full/Agda/Compiler/ToTreeless.hs --- a/src/full/Agda/Compiler/ToTreeless.hs +++ b/src/full/Agda/Compiler/ToTreeless.hs @@ -1,13 +1,12 @@ -{-# LANGUAGE CPP #-} module Agda.Compiler.ToTreeless ( toTreeless , closedTermToTreeless ) where -import Control.Arrow (first, second) +import Control.Arrow (first) import Control.Monad.Reader -import Control.Monad.State + import Data.Maybe import Data.Map (Map) import qualified Data.Map as Map @@ -15,40 +14,37 @@ import Agda.Syntax.Common import Agda.Syntax.Internal as I +import Agda.Syntax.Literal import qualified Agda.Syntax.Treeless as C import Agda.Syntax.Treeless (TTerm, EvaluationStrategy) -import Agda.Syntax.Literal -import qualified Agda.TypeChecking.CompiledClause as CC + +import Agda.TypeChecking.CompiledClause as CC import qualified Agda.TypeChecking.CompiledClause.Compile as CC -import Agda.TypeChecking.Records (getRecordConstructor) +import Agda.TypeChecking.EtaContract (binAppView, BinAppView(..)) +import Agda.TypeChecking.Monad as TCM import Agda.TypeChecking.Pretty -import Agda.TypeChecking.CompiledClause -import Agda.TypeChecking.Telescope +import Agda.TypeChecking.Records (getRecordConstructor) +import Agda.TypeChecking.Reduce +import Agda.TypeChecking.Substitute +import Agda.Compiler.Treeless.AsPatterns import Agda.Compiler.Treeless.Builtin -import Agda.Compiler.Treeless.Simplify import Agda.Compiler.Treeless.Erase +import Agda.Compiler.Treeless.Identity +import Agda.Compiler.Treeless.Simplify import Agda.Compiler.Treeless.Uncase -import Agda.Compiler.Treeless.Pretty import Agda.Compiler.Treeless.Unused -import Agda.Compiler.Treeless.AsPatterns -import Agda.Compiler.Treeless.Identity -import Agda.Syntax.Common -import Agda.TypeChecking.Monad as TCM -import Agda.TypeChecking.Reduce -import Agda.TypeChecking.Substitute - +import Agda.Utils.Function import Agda.Utils.Functor -import qualified Agda.Utils.HashMap as HMap +import Agda.Utils.Lens import Agda.Utils.List import Agda.Utils.Maybe import Agda.Utils.Monad -import Agda.Utils.Lens import Agda.Utils.Pretty (prettyShow) import qualified Agda.Utils.Pretty as P +import qualified Agda.Utils.SmallSet as SmallSet -#include "undefined.h" import Agda.Utils.Impossible prettyPure :: P.Pretty a => a -> TCM Doc @@ -231,7 +227,7 @@ CC.Done xs v -> withContextSize (length xs) $ do -- Issue 2469: Body context size (`length xs`) may be smaller than current context size -- if some arguments are not used in the body. - v <- lift (putAllowedReductions [ProjectionReductions, CopatternReductions] $ normalise v) + v <- lift (putAllowedReductions (SmallSet.fromList [ProjectionReductions, CopatternReductions]) $ normalise v) substTerm v CC.Case _ (CC.Branches True _ _ _ Just{} _ _) -> __IMPOSSIBLE__ -- Andreas, 2016-06-03, issue #1986: Ulf: "no catch-all for copatterns!" @@ -306,8 +302,9 @@ if diff <= 0 then do - local (\e -> e { ccCxt = shift diff $ drop (-diff) (ccCxt e)}) $ - C.mkTApp <$> cont <*> pure [C.TVar i | i <- reverse [0..(-diff - 1)]] + let diff' = -diff + local (\e -> e { ccCxt = shift diff . drop diff' $ ccCxt e }) $ + cont <&> (`C.mkTApp` map C.TVar (downFrom diff')) else do local (\e -> e { ccCxt = [0..(diff - 1)] ++ shift diff (ccCxt e)}) $ do createLambdas diff <$> do @@ -335,7 +332,7 @@ -- we also bind the catch all to a let, to avoid code duplication local (\e -> e { ccCatchAll = Just 0 , ccCxt = shift 1 (ccCxt e)}) $ do - let catchAllArgs = map C.TVar $ reverse [0..(diff - 1)] + let catchAllArgs = map C.TVar $ downFrom diff C.mkLet (C.mkTApp (C.TVar $ catchAll' + diff) catchAllArgs) <$> cont Nothing -> cont @@ -353,8 +350,7 @@ branch (C.TALit l ) cc branch :: (C.TTerm -> C.TAlt) -> CC.CompiledClauses -> CC C.TAlt -branch alt cc = do - alt <$> casetree cc +branch alt cc = alt <$> casetree cc -- | Replace de Bruijn Level @x@ by @n@ new variables. replaceVar :: Int -> Int -> CC a -> CC a @@ -375,7 +371,7 @@ mkRecord :: Map QName C.TTerm -> CC C.TTerm mkRecord fs = lift $ do -- Get the name of the first field - let p1 = fst $ fromMaybe __IMPOSSIBLE__ $ headMaybe $ Map.toList fs + let p1 = fst $ headWithDefault __IMPOSSIBLE__ $ Map.toList fs -- Use the field name to get the record constructor and the field names. I.ConHead c _ind xs <- conSrcCon . theDef <$> (getConstInfo =<< canonicalName . I.conName =<< recConFromProj p1) reportSDoc "treeless.convert.mkRecord" 60 $ vcat @@ -383,7 +379,7 @@ , text "to be filled with content: keys fs = " <+> (text . show) (Map.keys fs) ] -- Convert the constructor - let (args :: [C.TTerm]) = for xs $ \ (Arg ai x) -> Map.findWithDefault __IMPOSSIBLE__ x fs + let (args :: [C.TTerm]) = for xs $ \ x -> Map.findWithDefault __IMPOSSIBLE__ (unArg x) fs return $ C.mkTApp (C.TCon c) args @@ -401,7 +397,7 @@ -- indices in the environment as well. substTerm :: I.Term -> CC C.TTerm substTerm term = normaliseStatic term >>= \ term -> - case I.unSpine term of + case I.unSpine $ etaContractErased term of I.Var ind es -> do ind' <- lookupIndex ind <$> asks ccCxt let args = fromMaybe __IMPOSSIBLE__ $ I.allApplyElims es @@ -424,6 +420,55 @@ I.MetaV _ _ -> __IMPOSSIBLE__ -- we don't compiled if unsolved metas I.DontCare _ -> return C.TErased I.Dummy{} -> __IMPOSSIBLE__ + +-- Andreas, 2019-07-10, issue #3792 +-- | Eta-contract erased lambdas. +-- +-- Should also be fine for strict backends: +-- +-- * eta-contraction is semantics-preserving for total, effect-free languages. +-- * should a user rely on thunking, better not used an erased abstraction! +-- +-- A live-or-death issue for the GHC 8.0 backend. Consider: +-- @ +-- foldl : ∀ {A} (B : Nat → Set) +-- → (f : ∀ {@0 n} → B n → A → B (suc n)) +-- → (z : B 0) +-- → ∀ {@0 n} → Vec A n → B n +-- foldl B f z (x ∷ xs) = foldl (λ n → B (suc n)) (λ{@0 x} → f {suc x}) (f z x) xs +-- foldl B f z [] = z +-- @ +-- The hidden composition of @f@ with @suc@, term @(λ{@0 x} → f {suc x})@, +-- can be eta-contracted to just @f@ by the compiler, since the first argument +-- of @f@ is erased. +-- +-- GHC >= 8.2 seems to be able to do the optimization himself, but not 8.0. +-- +etaContractErased :: I.Term -> I.Term +etaContractErased = trampoline etaErasedOnce + where + etaErasedOnce :: I.Term -> Either I.Term I.Term -- Left = done, Right = jump again + etaErasedOnce t = + case t of + + -- If the abstraction is void, we don't have to strengthen. + I.Lam _ (NoAbs _ v) -> + case binAppView v of + -- If the body is an application ending with an erased argument, eta-reduce! + App u arg | not (usableModality arg) -> Right u + _ -> done + + -- If the abstraction is non-void, only eta-contract if erased. + I.Lam ai (Abs _ v) | not (usableModality ai) -> + case binAppView v of + -- If the body is an application ending with an erased argument, eta-reduce! + -- We need to strengthen the function part then. + App u arg | not (usableModality arg) -> Right $ subst 0 (DontCare __DUMMY_TERM__) u + _ -> done + + _ -> done + where + done = Left t normaliseStatic :: I.Term -> CC I.Term normaliseStatic v@(I.Def f es) = lift $ do diff --git a/src/full/Agda/Compiler/Treeless/AsPatterns.hs b/src/full/Agda/Compiler/Treeless/AsPatterns.hs --- a/src/full/Agda/Compiler/Treeless/AsPatterns.hs +++ b/src/full/Agda/Compiler/Treeless/AsPatterns.hs @@ -1,17 +1,8 @@ -{-# LANGUAGE CPP #-} module Agda.Compiler.Treeless.AsPatterns (recoverAsPatterns) where import Control.Monad.Reader -import Data.Monoid import Agda.Syntax.Treeless -import Agda.Syntax.Literal -import Agda.TypeChecking.Substitute -import Agda.Compiler.Treeless.Subst -import Agda.Compiler.Treeless.Compare - -import Agda.Utils.Impossible -#include "undefined.h" data AsPat = AsPat Int QName [Int] -- x@(c ys) deriving (Show) diff --git a/src/full/Agda/Compiler/Treeless/Builtin.hs b/src/full/Agda/Compiler/Treeless/Builtin.hs --- a/src/full/Agda/Compiler/Treeless/Builtin.hs +++ b/src/full/Agda/Compiler/Treeless/Builtin.hs @@ -14,7 +14,6 @@ -- optimisations that analyse case tree, like impossible case elimination. -- -- Ulf, 2015-10-30: Guards are actually a better primitive. Fixed that. -{-# LANGUAGE CPP #-} module Agda.Compiler.Treeless.Builtin (translateBuiltins) where import qualified Agda.Syntax.Internal as I @@ -27,13 +26,9 @@ import Agda.TypeChecking.Monad import Agda.TypeChecking.Monad.Builtin -import Agda.Compiler.Treeless.Subst - -import Agda.Utils.Except ( MonadError(catchError) ) -import Agda.Utils.Maybe +import Agda.Compiler.Treeless.Subst () --instance only import Agda.Utils.Impossible -#include "undefined.h" data BuiltinKit = BuiltinKit { isZero :: QName -> Bool diff --git a/src/full/Agda/Compiler/Treeless/Compare.hs b/src/full/Agda/Compiler/Treeless/Compare.hs --- a/src/full/Agda/Compiler/Treeless/Compare.hs +++ b/src/full/Agda/Compiler/Treeless/Compare.hs @@ -2,7 +2,7 @@ import Agda.Syntax.Treeless import Agda.TypeChecking.Substitute -import Agda.Compiler.Treeless.Subst +import Agda.Compiler.Treeless.Subst () --instance only equalTerms :: TTerm -> TTerm -> Bool equalTerms u v = diff --git a/src/full/Agda/Compiler/Treeless/EliminateDefaults.hs b/src/full/Agda/Compiler/Treeless/EliminateDefaults.hs --- a/src/full/Agda/Compiler/Treeless/EliminateDefaults.hs +++ b/src/full/Agda/Compiler/Treeless/EliminateDefaults.hs @@ -1,27 +1,16 @@ -{-# LANGUAGE CPP #-} -- | Eliminates case defaults by adding an alternative for all possible -- constructors. Literal cases are preserved as-is. module Agda.Compiler.Treeless.EliminateDefaults where import Control.Monad import qualified Data.List as List -import Data.Maybe -import Agda.Syntax.Abstract.Name (QName) import Agda.Syntax.Treeless -import Agda.Syntax.Literal -import qualified Agda.Syntax.Internal as I import Agda.TypeChecking.Monad -import Agda.TypeChecking.Monad.Builtin -import Agda.TypeChecking.Primitive import Agda.TypeChecking.Substitute -import Agda.Compiler.Treeless.Subst - -import Agda.Utils.Impossible - -#include "undefined.h" +import Agda.Compiler.Treeless.Subst () --instance only eliminateCaseDefaults :: TTerm -> TCM TTerm eliminateCaseDefaults = tr diff --git a/src/full/Agda/Compiler/Treeless/EliminateLiteralPatterns.hs b/src/full/Agda/Compiler/Treeless/EliminateLiteralPatterns.hs --- a/src/full/Agda/Compiler/Treeless/EliminateLiteralPatterns.hs +++ b/src/full/Agda/Compiler/Treeless/EliminateLiteralPatterns.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} -- | Converts case matches on literals to if cascades with equality comparisons. module Agda.Compiler.Treeless.EliminateLiteralPatterns where @@ -7,18 +6,13 @@ import Agda.Syntax.Abstract.Name (QName) import Agda.Syntax.Treeless import Agda.Syntax.Literal -import qualified Agda.Syntax.Internal as I import Agda.TypeChecking.Monad import Agda.TypeChecking.Monad.Builtin import Agda.TypeChecking.Primitive -import Agda.TypeChecking.Substitute -import Agda.Compiler.Treeless.Subst - import Agda.Utils.Impossible -#include "undefined.h" eliminateLiteralPatterns :: TTerm -> TCM TTerm eliminateLiteralPatterns t = do diff --git a/src/full/Agda/Compiler/Treeless/Erase.hs b/src/full/Agda/Compiler/Treeless/Erase.hs --- a/src/full/Agda/Compiler/Treeless/Erase.hs +++ b/src/full/Agda/Compiler/Treeless/Erase.hs @@ -1,14 +1,16 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE PatternSynonyms #-} -module Agda.Compiler.Treeless.Erase (eraseTerms, computeErasedConstructorArgs) where +module Agda.Compiler.Treeless.Erase + ( eraseTerms + , computeErasedConstructorArgs + , isErasable + ) where -import Control.Arrow ((&&&), (***), first, second) +import Control.Arrow (first, second) import Control.Monad import Control.Monad.State import Data.Map (Map) import qualified Data.Map as Map -import Data.Semigroup import Agda.Syntax.Common import Agda.Syntax.Internal as I @@ -21,13 +23,12 @@ import Agda.TypeChecking.Monad as I import Agda.TypeChecking.Monad.Builtin import Agda.TypeChecking.Telescope -import Agda.TypeChecking.Reduce import Agda.TypeChecking.Datatypes -import Agda.TypeChecking.Pretty hiding ((<>)) +import Agda.TypeChecking.Pretty import Agda.TypeChecking.Primitive +import {-# SOURCE #-} Agda.Compiler.Backend import Agda.Compiler.Treeless.Subst -import Agda.Compiler.Treeless.Pretty import Agda.Compiler.Treeless.Unused import Agda.Utils.Functor @@ -36,15 +37,18 @@ import Agda.Utils.Memo import Agda.Utils.Monad import Agda.Utils.Pretty (prettyShow) -import qualified Agda.Utils.Pretty as P import Agda.Utils.IntSet.Infinite (IntSet) import qualified Agda.Utils.IntSet.Infinite as IntSet -#include "undefined.h" import Agda.Utils.Impossible -data ESt = ESt { _funMap :: Map QName FunInfo - , _typeMap :: Map QName TypeInfo } +-- | State of the eraser. +data ESt = ESt + { _funMap :: Map QName FunInfo + -- ^ Memoize computed `FunInfo` for functions/constructors/... `QName`. + , _typeMap :: Map QName TypeInfo + -- ^ Memoize computed `TypeInfo` for data/record types `QName`. + } funMap :: Lens' (Map QName FunInfo) ESt funMap f r = f (_funMap r) <&> \ a -> r { _funMap = a } @@ -52,6 +56,7 @@ typeMap :: Lens' (Map QName TypeInfo) ESt typeMap f r = f (_typeMap r) <&> \ a -> r { _typeMap = a } +-- | Eraser monad. type E = StateT ESt TCM runE :: E a -> TCM a @@ -75,7 +80,7 @@ erase t = case tAppView t of - TCon c : vs -> do + (TCon c, vs) -> do (rs, h) <- getFunInfo c when (length rs < length vs) __IMPOSSIBLE__ case h of @@ -83,7 +88,7 @@ Empty -> pure TErased _ -> tApp (TCon c) <$> zipWithM eraseRel rs vs - TDef f : vs -> do + (TDef f, vs) -> do (rs, h) <- getFunInfo f case h of Erasable -> pure TErased @@ -128,7 +133,7 @@ tApp f [] = f tApp TErased _ = TErased tApp f _ | isUnreachable f = tUnreachable - tApp f es = TApp f es + tApp f es = mkTApp f es tCase x t d bs | isErased d && all (isErased . aBody) bs = pure TErased @@ -223,6 +228,7 @@ getFunInfo :: QName -> E FunInfo getFunInfo q = memo (funMap . key q) $ getInfo q where + getInfo :: QName -> E FunInfo getInfo q = do (rs, t) <- do (tel, t) <- lift $ typeWithoutParams q @@ -243,6 +249,15 @@ | Forced <- f = Erasable | otherwise = i +isErasable :: QName -> TCM Bool +isErasable qn = + -- The active backend should be set + caseMaybeM (viewTC eActiveBackendName) __IMPOSSIBLE__ $ \ bname -> + -- However it may not be part of the set of available backends + -- in which case we default to not erasable to avoid false negatives. + caseMaybeM (lookupBackend bname) (pure False) $ \ _ -> + erasable . snd <$> runE (getFunInfo qn) + telListView :: Type -> TCM (ListTel, Type) telListView t = do TelV tel t <- telView t @@ -278,8 +293,9 @@ lift $ reportSDoc "treeless.opt.erase.type" 50 $ prettyTCM t0 <+> text ("is " ++ show e) return e where - typeInfo :: QName -> E TypeInfo - typeInfo q = memoRec (typeMap . key q) Erasable $ do -- assume recursive occurrences are erasable + typeInfo :: QName -> E TypeInfo + typeInfo q = ifM (erasureForbidden q) (return NotErasable) $ {-else-} do + memoRec (typeMap . key q) Erasable $ do -- assume recursive occurrences are erasable msizes <- lift $ mapM getBuiltinName [builtinSize, builtinSizeLt] def <- lift $ getConstInfo q @@ -302,3 +318,6 @@ I.Function{ funClauses = cs } -> sumTypeInfo <$> mapM (maybe (return Empty) (getTypeInfo . El __DUMMY_SORT__) . clauseBody) cs _ -> return NotErasable + -- | The backend also has a say whether a type is eraseable or not. + erasureForbidden :: QName -> E Bool + erasureForbidden q = lift $ not <$> activeBackendMayEraseType q diff --git a/src/full/Agda/Compiler/Treeless/Erase.hs-boot b/src/full/Agda/Compiler/Treeless/Erase.hs-boot new file mode 100644 --- /dev/null +++ b/src/full/Agda/Compiler/Treeless/Erase.hs-boot @@ -0,0 +1,6 @@ +module Agda.Compiler.Treeless.Erase where + +import Agda.TypeChecking.Monad.Base (TCM) +import Agda.Syntax.Abstract.Name (QName) + +isErasable :: QName -> TCM Bool diff --git a/src/full/Agda/Compiler/Treeless/GuardsToPrims.hs b/src/full/Agda/Compiler/Treeless/GuardsToPrims.hs --- a/src/full/Agda/Compiler/Treeless/GuardsToPrims.hs +++ b/src/full/Agda/Compiler/Treeless/GuardsToPrims.hs @@ -1,24 +1,13 @@ -- | Translates guard alternatives to if-then-else cascades. -- -- The builtin translation must be run before this transformation. -{-# LANGUAGE CPP #-} module Agda.Compiler.Treeless.GuardsToPrims ( convertGuards ) where import qualified Data.List as List - -import Agda.Syntax.Abstract.Name (QName) import Agda.Syntax.Treeless -import Agda.Syntax.Literal -import Agda.TypeChecking.Substitute - -import Agda.Compiler.Treeless.Subst - import Agda.Utils.Impossible - -#include "undefined.h" - convertGuards :: TTerm -> TTerm diff --git a/src/full/Agda/Compiler/Treeless/Identity.hs b/src/full/Agda/Compiler/Treeless/Identity.hs --- a/src/full/Agda/Compiler/Treeless/Identity.hs +++ b/src/full/Agda/Compiler/Treeless/Identity.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} module Agda.Compiler.Treeless.Identity ( detectIdentityFunctions ) where @@ -6,19 +5,15 @@ import Prelude hiding ((!!)) -- don't use partial functions import Control.Applicative ( Alternative((<|>), empty) ) -import Data.Foldable (foldMap) import Data.Semigroup import Data.List.NonEmpty (NonEmpty(..)) import qualified Data.List as List import Agda.Syntax.Treeless -import Agda.TypeChecking.Substitute import Agda.TypeChecking.Monad -import Agda.Utils.Lens import Agda.Utils.List -#include "undefined.h" import Agda.Utils.Impossible detectIdentityFunctions :: QName -> TTerm -> TCM TTerm diff --git a/src/full/Agda/Compiler/Treeless/NormalizeNames.hs b/src/full/Agda/Compiler/Treeless/NormalizeNames.hs --- a/src/full/Agda/Compiler/Treeless/NormalizeNames.hs +++ b/src/full/Agda/Compiler/Treeless/NormalizeNames.hs @@ -11,7 +11,6 @@ -- concrete name. -- -- This transfomation should be run as the last transformation. -{-# LANGUAGE CPP #-} module Agda.Compiler.Treeless.NormalizeNames ( normalizeNames ) where import Agda.TypeChecking.Monad diff --git a/src/full/Agda/Compiler/Treeless/Pretty.hs b/src/full/Agda/Compiler/Treeless/Pretty.hs --- a/src/full/Agda/Compiler/Treeless/Pretty.hs +++ b/src/full/Agda/Compiler/Treeless/Pretty.hs @@ -1,11 +1,10 @@ -{-# LANGUAGE CPP #-} {-# OPTIONS_GHC -fno-warn-orphans #-} module Agda.Compiler.Treeless.Pretty () where import Prelude hiding ((!!)) -- don't use partial functions! -import Control.Arrow ((&&&), (***), first, second) +import Control.Arrow (first) import Control.Monad.Reader import Data.Maybe import qualified Data.Map as Map @@ -15,7 +14,6 @@ import Agda.Utils.Pretty import Agda.Utils.List -#include "undefined.h" import Agda.Utils.Impossible data PEnv = PEnv { pPrec :: Int @@ -24,8 +22,9 @@ type P = Reader PEnv -withName :: (String -> P a) -> P a -withName k = withNames 1 $ \[x] -> k x +--UNUSED Liang-Ting Chen 2019-07-16 +--withName :: (String -> P a) -> P a +--withName k = withNames 1 $ \[x] -> k x withNames :: Int -> ([String] -> P a) -> P a withNames n k = do diff --git a/src/full/Agda/Compiler/Treeless/Simplify.hs b/src/full/Agda/Compiler/Treeless/Simplify.hs --- a/src/full/Agda/Compiler/Treeless/Simplify.hs +++ b/src/full/Agda/Compiler/Treeless/Simplify.hs @@ -1,28 +1,25 @@ -{-# LANGUAGE CPP #-} module Agda.Compiler.Treeless.Simplify (simplifyTTerm) where -import Control.Arrow (first, second, (***)) +import Control.Arrow (second, (***)) import Control.Monad.Reader -import Control.Monad.Writer import Data.Traversable (traverse) import qualified Data.List as List import Agda.Syntax.Treeless import Agda.Syntax.Internal (Substitution'(..)) import Agda.Syntax.Literal + import Agda.TypeChecking.Monad import Agda.TypeChecking.Monad.Builtin import Agda.TypeChecking.Primitive import Agda.TypeChecking.Substitute -import Agda.Utils.Maybe -import Agda.Compiler.Treeless.Subst -import Agda.Compiler.Treeless.Pretty import Agda.Compiler.Treeless.Compare -import Agda.Utils.Pretty +import Agda.Utils.List +import Agda.Utils.Maybe + import Agda.Utils.Impossible -#include "undefined.h" data SEnv = SEnv { envSubst :: Substitution' TTerm @@ -79,11 +76,11 @@ simplify :: FunctionKit -> TTerm -> S TTerm simplify FunctionKit{..} = simpl where - simpl = rewrite' >=> unchainCase >=> \ t -> case t of + simpl = rewrite' >=> unchainCase >=> \case - TDef{} -> pure t - TPrim{} -> pure t - TVar{} -> pure t + t@TDef{} -> pure t + t@TPrim{} -> pure t + t@TVar{} -> pure t TApp (TDef f) [TLit (LitNat _ 0), m, n, m'] -- div/mod are equivalent to quot/rem on natural numbers. @@ -99,7 +96,7 @@ opTo64 op = lookup op [(PAdd, PAdd64), (PSub, PSub64), (PMul, PMul64), (PQuot, PQuot64), (PRem, PRem64)] - TApp (TPrim _) _ -> pure t -- taken care of by rewrite' + t@(TApp (TPrim _) _) -> pure t -- taken care of by rewrite' TCoerce t -> TCoerce <$> simpl t @@ -107,12 +104,11 @@ f <- simpl f es <- traverse simpl es maybeMinusToPrim f es - TLam b -> TLam <$> underLam (simpl b) - TLit{} -> pure t - TCon{} -> pure t - TLet e b -> do - e <- simpl e - case e of + TLam b -> TLam <$> underLam (simpl b) + t@TLit{} -> pure t + t@TCon{} -> pure t + TLet e b -> do + simpl e >>= \case TPFn P64ToI a -> do -- Inline calls to P64ToI since these trigger optimisations. -- Ideally, the optimisations would trigger anyway, but at the @@ -120,7 +116,7 @@ -- good idea. let rho = inplaceS 0 (TPFn P64ToI (TVar 0)) tLet a <$> underLet a (simpl (applySubst rho b)) - _ -> tLet e <$> underLet e (simpl b) + e -> tLet e <$> underLet e (simpl b) TCase x t d bs -> do v <- lookupVar x @@ -150,14 +146,14 @@ bs <- traverse (simplAlt x) bs tCase x t d bs - TUnit -> pure t - TSort -> pure t - TErased -> pure t - TError{} -> pure t + t@TUnit -> pure t + t@TSort -> pure t + t@TErased -> pure t + t@TError{} -> pure t - conView (TCon c) = Just (c, []) - conView (TApp (TCon c) as) = Just (c, as) - conView e = Nothing + conView (TCon c) = Just (c, []) + conView (TApp f as) = second (++ as) <$> conView f + conView e = Nothing -- Collapse chained cases (case x of bs -> vs; _ -> case x of bs' -> vs' ==> -- case x of bs -> vs; bs' -> vs') @@ -225,14 +221,14 @@ , Just trueCon <- true , Just falseCon <- false = if k < j then TCon trueCon else TCon falseCon simplPrim' (TApp (TPrim op) [u, v]) - | elem op [PGeq, PLt, PEqI] + | op `elem` [PGeq, PLt, PEqI] , Just (PAdd, k, u) <- constArithView u , Just j <- intView v = TApp (TPrim op) [u, tInt (j - k)] simplPrim' (TApp (TPrim PEqI) [u, v]) | Just (op1, k, u) <- constArithView u, Just (op2, j, v) <- constArithView v, op1 == op2, k == j, - elem op1 [PAdd, PSub] = tOp PEqI u v + op1 `elem` [PAdd, PSub] = tOp PEqI u v simplPrim' (TPOp op u v) | zeroL, isMul || isDiv = tInt 0 | zeroL, isAdd = v @@ -240,18 +236,18 @@ | zeroR, isAdd || isSub = u where zeroL = Just 0 == intView u || Just 0 == word64View u zeroR = Just 0 == intView v || Just 0 == word64View v - isAdd = elem op [PAdd, PAdd64] - isSub = elem op [PSub, PSub64] - isMul = elem op [PMul, PMul64] - isDiv = elem op [PQuot, PQuot64, PRem, PRem64] + isAdd = op `elem` [PAdd, PAdd64] + isSub = op `elem` [PSub, PSub64] + isMul = op `elem` [PMul, PMul64] + isDiv = op `elem` [PQuot, PQuot64, PRem, PRem64] simplPrim' (TApp (TPrim op) [u, v]) | Just u <- negView u, Just v <- negView v, - elem op [PMul, PQuot] = tOp op u v + op `elem` [PMul, PQuot] = tOp op u v | Just u <- negView u, - elem op [PMul, PQuot] = simplArith $ tOp PSub (tInt 0) (tOp op u v) + op `elem` [PMul, PQuot] = simplArith $ tOp PSub (tInt 0) (tOp op u v) | Just v <- negView v, - elem op [PMul, PQuot] = simplArith $ tOp PSub (tInt 0) (tOp op u v) + op `elem` [PMul, PQuot] = simplArith $ tOp PSub (tInt 0) (tOp op u v) simplPrim' (TApp (TPrim PRem) [u, v]) | Just u <- negView u = simplArith $ tOp PSub (tInt 0) (tOp PRem u (unNeg v)) | Just v <- negView v = tOp PRem u v @@ -299,14 +295,14 @@ constArithView :: TTerm -> Maybe (TPrim, Integer, TTerm) constArithView (TApp (TPrim op) [TLit (LitNat _ k), u]) - | elem op [PAdd, PSub] = Just (op, k, u) + | op `elem` [PAdd, PSub] = Just (op, k, u) constArithView (TApp (TPrim op) [u, TLit (LitNat _ k)]) | op == PAdd = Just (op, k, u) | op == PSub = Just (PAdd, -k, u) constArithView _ = Nothing simplAlt x (TACon c a b) = TACon c a <$> underLams a (maybeAddRewrite (x + a) conTerm $ simpl b) - where conTerm = mkTApp (TCon c) [TVar i | i <- reverse $ take a [0..]] + where conTerm = mkTApp (TCon c) $ map TVar $ downFrom a simplAlt x (TALit l b) = TALit l <$> maybeAddRewrite x (TLit l) (simpl b) simplAlt x (TAGuard g b) = TAGuard <$> simpl g <*> simpl b @@ -466,8 +462,8 @@ aCancel :: [Atom] -> [Atom] aCancel (a : as) - | elem (aNeg a) as = aCancel (List.delete (aNeg a) as) - | otherwise = a : aCancel as + | (aNeg a) `elem` as = aCancel (List.delete (aNeg a) as) + | otherwise = a : aCancel as aCancel [] = [] sortR :: Ord a => [a] -> [a] diff --git a/src/full/Agda/Compiler/Treeless/Subst.hs b/src/full/Agda/Compiler/Treeless/Subst.hs --- a/src/full/Agda/Compiler/Treeless/Subst.hs +++ b/src/full/Agda/Compiler/Treeless/Subst.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# OPTIONS_GHC -fno-warn-orphans #-} @@ -15,7 +14,6 @@ import Agda.TypeChecking.Substitute import Agda.Utils.Impossible -#include "undefined.h" instance DeBruijn TTerm where deBruijnVar = TVar @@ -76,6 +74,11 @@ instance Monoid Occurs where mempty = Occurs 0 mempty mempty mappend = (<>) + + +-- Andreas, 2019-07-10: this free variable computation should be rewritten +-- in the style of TypeChecking.Free.Lazy. +-- https://github.com/agda/agda/commit/03eb3945114a4ccdb449f22d69db8d6eaa4699b8#commitcomment-34249120 class HasFree a where freeVars :: a -> Map Int Occurs diff --git a/src/full/Agda/Compiler/Treeless/Uncase.hs b/src/full/Agda/Compiler/Treeless/Uncase.hs --- a/src/full/Agda/Compiler/Treeless/Uncase.hs +++ b/src/full/Agda/Compiler/Treeless/Uncase.hs @@ -1,16 +1,11 @@ -{-# LANGUAGE CPP #-} module Agda.Compiler.Treeless.Uncase (caseToSeq) where -import Data.Monoid - import Agda.Syntax.Treeless -import Agda.Syntax.Literal import Agda.TypeChecking.Substitute import Agda.Compiler.Treeless.Subst import Agda.Compiler.Treeless.Compare import Agda.Utils.Impossible -#include "undefined.h" caseToSeq :: Monad m => TTerm -> m TTerm caseToSeq t = return $ uncase t diff --git a/src/full/Agda/Compiler/Treeless/Unused.hs b/src/full/Agda/Compiler/Treeless/Unused.hs --- a/src/full/Agda/Compiler/Treeless/Unused.hs +++ b/src/full/Agda/Compiler/Treeless/Unused.hs @@ -4,16 +4,13 @@ , stripUnusedArguments ) where -import Control.Arrow (first) import qualified Data.Set as Set -import Data.Maybe import Agda.Syntax.Treeless import Agda.TypeChecking.Monad import Agda.TypeChecking.Substitute -import Agda.Compiler.Treeless.Subst -import Agda.Compiler.Treeless.Pretty +import Agda.Compiler.Treeless.Pretty () --instance only import Agda.Utils.Pretty (prettyShow) diff --git a/src/full/Agda/ImpossibleTest.hs b/src/full/Agda/ImpossibleTest.hs --- a/src/full/Agda/ImpossibleTest.hs +++ b/src/full/Agda/ImpossibleTest.hs @@ -1,8 +1,6 @@ -{-# LANGUAGE CPP #-} module Agda.ImpossibleTest where -#include "undefined.h" import Agda.Utils.Impossible impossibleTest :: a diff --git a/src/full/Agda/Interaction/AgdaTop.hs b/src/full/Agda/Interaction/AgdaTop.hs --- a/src/full/Agda/Interaction/AgdaTop.hs +++ b/src/full/Agda/Interaction/AgdaTop.hs @@ -4,14 +4,15 @@ import Control.Monad.State import Data.Char +import Data.Maybe import System.IO +import Agda.Interaction.Base import Agda.Interaction.Response as R import Agda.Interaction.InteractionTop import Agda.Interaction.Options import Agda.TypeChecking.Monad import qualified Agda.TypeChecking.Monad.Benchmark as Bench -import Agda.Utils.Maybe ---------------------------------- diff --git a/src/full/Agda/Interaction/Base.hs b/src/full/Agda/Interaction/Base.hs new file mode 100644 --- /dev/null +++ b/src/full/Agda/Interaction/Base.hs @@ -0,0 +1,430 @@ +{-# OPTIONS_GHC -fno-cse #-} +{-# OPTIONS_GHC -fno-warn-orphans #-} + +module Agda.Interaction.Base where + +import Control.Concurrent.STM.TChan +import Control.Concurrent.STM.TVar +import Control.Monad.Identity +import Control.Monad.State + +import qualified Data.List as List +import Data.Map (Map) +import qualified Data.Map as Map +import Data.Maybe (listToMaybe) + +import {-# SOURCE #-} Agda.TypeChecking.Monad.Base + (HighlightingLevel, HighlightingMethod, TCM, ProblemId, Comparison, Polarity) + +import Agda.Syntax.Abstract (QName) +import Agda.Syntax.Common (InteractionId (..)) +import Agda.Syntax.Position +import Agda.Syntax.Scope.Base (ScopeInfo) + +import Agda.Interaction.Options (CommandLineOptions, + defaultOptions) + +import Agda.Utils.Except (ExceptT, MonadError (throwError), + runExceptT) +import Agda.Utils.FileName (AbsolutePath, mkAbsolute) +import Agda.Utils.Time (ClockTime) + +------------------------------------------------------------------------ +-- The CommandM monad + +-- | Auxiliary state of an interactive computation. + +data CommandState = CommandState + { theInteractionPoints :: [InteractionId] + -- ^ The interaction points of the buffer, in the order in which + -- they appear in the buffer. The interaction points are + -- recorded in 'theTCState', but when new interaction points are + -- added by give or refine Agda does not ensure that the ranges + -- of later interaction points are updated. + , theCurrentFile :: Maybe (AbsolutePath, ClockTime) + -- ^ The file which the state applies to. Only stored if the + -- module was successfully type checked (potentially with + -- warnings). The 'ClockTime' is the modification time stamp of + -- the file when it was last loaded. + , optionsOnReload :: CommandLineOptions + -- ^ Reset the options on each reload to these. + , oldInteractionScopes :: !OldInteractionScopes + -- ^ We remember (the scope of) old interaction points to make it + -- possible to parse and compute highlighting information for the + -- expression that it got replaced by. + , commandQueue :: !CommandQueue + -- ^ The command queue. + -- + -- This queue should only be manipulated by + -- 'initialiseCommandQueue' and 'maybeAbort'. + } + +type OldInteractionScopes = Map InteractionId ScopeInfo + +-- | Initial auxiliary interaction state + +initCommandState :: CommandQueue -> CommandState +initCommandState commandQueue = + CommandState + { theInteractionPoints = [] + , theCurrentFile = Nothing + , optionsOnReload = defaultOptions + , oldInteractionScopes = Map.empty + , commandQueue = commandQueue + } + +-- | Monad for computing answers to interactive commands. +-- +-- 'CommandM' is 'TCM' extended with state 'CommandState'. + +type CommandM = StateT CommandState TCM + + +------------------------------------------------------------------------ +-- Command queues + +-- | A generalised command type. + +data Command' a + = Command !a + -- ^ A command. + | Done + -- ^ Stop processing commands. + | Error String + -- ^ An error message for a command that could not be parsed. + deriving Show + +-- | IOTCM commands. + +type Command = Command' IOTCM + +-- | Command queues. + +data CommandQueue = CommandQueue + { commands :: !(TChan (Integer, Command)) + -- ^ Commands that should be processed, in the order in which they + -- should be processed. Each command is associated with a number, + -- and the numbers are strictly increasing. Abort commands are not + -- put on this queue. + , abort :: !(TVar (Maybe Integer)) + -- ^ When this variable is set to @Just n@ an attempt is made to + -- abort all commands with a command number that is at most @n@. + } + + +---------------------------------------------------------------------------- +-- | An interactive computation. + +type Interaction = Interaction' Range + +data Interaction' range + -- | @cmd_load m argv@ loads the module in file @m@, using + -- @argv@ as the command-line options. + = Cmd_load FilePath [String] + + -- | @cmd_compile b m argv@ compiles the module in file @m@ using + -- the backend @b@, using @argv@ as the command-line options. + | Cmd_compile CompilerBackend FilePath [String] + + | Cmd_constraints + + -- | Show unsolved metas. If there are no unsolved metas but unsolved constraints + -- show those instead. + | Cmd_metas + + -- | Shows all the top-level names in the given module, along with + -- their types. Uses the top-level scope. + | Cmd_show_module_contents_toplevel + Rewrite + String + + -- | Shows all the top-level names in scope which mention all the given + -- identifiers in their type. + | Cmd_search_about_toplevel Rewrite String + + -- | Solve (all goals / the goal at point) whose values are determined by + -- the constraints. + | Cmd_solveAll Rewrite + | Cmd_solveOne Rewrite InteractionId range String + + -- | Solve (all goals / the goal at point) by using Auto. + | Cmd_autoOne InteractionId range String + | Cmd_autoAll + + -- | Parse the given expression (as if it were defined at the + -- top-level of the current module) and infer its type. + | Cmd_infer_toplevel Rewrite -- Normalise the type? + String + + + -- | Parse and type check the given expression (as if it were defined + -- at the top-level of the current module) and normalise it. + | Cmd_compute_toplevel ComputeMode + String + + ------------------------------------------------------------------------ + -- Syntax highlighting + + -- | @cmd_load_highlighting_info source@ loads syntax highlighting + -- information for the module in @source@, and asks Emacs to apply + -- highlighting info from this file. + -- + -- If the module does not exist, or its module name is malformed or + -- cannot be determined, or the module has not already been visited, + -- or the cached info is out of date, then no highlighting information + -- is printed. + -- + -- This command is used to load syntax highlighting information when a + -- new file is opened, and it would probably be annoying if jumping to + -- the definition of an identifier reset the proof state, so this + -- command tries not to do that. One result of this is that the + -- command uses the current include directories, whatever they happen + -- to be. + | Cmd_load_highlighting_info FilePath + + -- | Tells Agda to compute token-based highlighting information + -- for the file. + -- + -- This command works even if the file's module name does not + -- match its location in the file system, or if the file is not + -- scope-correct. Furthermore no file names are put in the + -- generated output. Thus it is fine to put source code into a + -- temporary file before calling this command. However, the file + -- extension should be correct. + -- + -- If the second argument is 'Remove', then the (presumably + -- temporary) file is removed after it has been read. + | Cmd_tokenHighlighting FilePath Remove + + -- | Tells Agda to compute highlighting information for the expression just + -- spliced into an interaction point. + | Cmd_highlight InteractionId range String + + ------------------------------------------------------------------------ + -- Implicit arguments + + -- | Tells Agda whether or not to show implicit arguments. + | ShowImplicitArgs Bool -- Show them? + + + -- | Toggle display of implicit arguments. + | ToggleImplicitArgs + + ------------------------------------------------------------------------ + -- | Goal commands + -- + -- If the range is 'noRange', then the string comes from the + -- minibuffer rather than the goal. + + | Cmd_give UseForce InteractionId range String + + | Cmd_refine InteractionId range String + + | Cmd_intro Bool InteractionId range String + + | Cmd_refine_or_intro Bool InteractionId range String + + | Cmd_context Rewrite InteractionId range String + + | Cmd_helper_function Rewrite InteractionId range String + + | Cmd_infer Rewrite InteractionId range String + + | Cmd_goal_type Rewrite InteractionId range String + + -- | Grabs the current goal's type and checks the expression in the hole + -- against it. Returns the elaborated term. + | Cmd_elaborate_give + Rewrite InteractionId range String + + -- | Displays the current goal and context. + | Cmd_goal_type_context Rewrite InteractionId range String + + -- | Displays the current goal and context /and/ infers the type of an + -- expression. + | Cmd_goal_type_context_infer + Rewrite InteractionId range String + + -- | Grabs the current goal's type and checks the expression in the hole + -- against it. + | Cmd_goal_type_context_check + Rewrite InteractionId range String + + -- | Shows all the top-level names in the given module, along with + -- their types. Uses the scope of the given goal. + | Cmd_show_module_contents + Rewrite InteractionId range String + + | Cmd_make_case InteractionId range String + + | Cmd_compute ComputeMode + InteractionId range String + + | Cmd_why_in_scope InteractionId range String + | Cmd_why_in_scope_toplevel String + -- | Displays version of the running Agda + | Cmd_show_version + | Cmd_abort + -- ^ Abort the current computation. + -- + -- Does nothing if no computation is in progress. + | Cmd_exit + -- ^ Exit the program. + deriving (Show, Read, Functor, Foldable, Traversable) + +type IOTCM = IOTCM' Range +data IOTCM' range + = IOTCM + FilePath + -- -^ The current file. If this file does not match + -- 'theCurrentFile, and the 'Interaction' is not + -- \"independent\", then an error is raised. + HighlightingLevel + HighlightingMethod + (Interaction' range) + -- -^ What to do + deriving (Show, Read, Functor, Foldable, Traversable) + +-- | Used to indicate whether something should be removed or not. + +data Remove + = Remove + | Keep + deriving (Show, Read) + + + + +--------------------------------------------------------- +-- Read instances + + +-- | The 'Parse' monad. +-- 'StateT' state holds the remaining input. + +type Parse a = ExceptT String (StateT String Identity) a + +-- | Converter from the type of 'reads' to 'Parse' +-- The first paramter is part of the error message +-- in case the parse fails. + +readsToParse :: String -> (String -> Maybe (a, String)) -> Parse a +readsToParse s f = do + st <- lift get + case f st of + Nothing -> throwError s + Just (a, st) -> do + lift $ put st + return a + +parseToReadsPrec :: Parse a -> Int -> String -> [(a, String)] +parseToReadsPrec p i s = case runIdentity . flip runStateT s . runExceptT $ parens' p of + (Right a, s) -> [(a,s)] + _ -> [] + +-- | Demand an exact string. + +exact :: String -> Parse () +exact s = readsToParse (show s) $ fmap (\x -> ((),x)) . List.stripPrefix s . dropWhile (==' ') + +readParse :: Read a => Parse a +readParse = readsToParse "read failed" $ listToMaybe . reads + +parens' :: Parse a -> Parse a +parens' p = do + exact "(" + x <- p + exact ")" + return x + `mplus` + p + +instance Read InteractionId where + readsPrec = parseToReadsPrec $ + fmap InteractionId readParse + +-- | Note that the grammar implemented by this instance does not +-- necessarily match the current representation of ranges. + +instance Read a => Read (Range' a) where + readsPrec = parseToReadsPrec $ + (exact "intervalsToRange" >> + liftM2 intervalsToRange readParse readParse) + `mplus` + (exact "noRange" >> return noRange) + +instance Read a => Read (Interval' a) where + readsPrec = parseToReadsPrec $ do + exact "Interval" + liftM2 Interval readParse readParse + +instance Read AbsolutePath where + readsPrec = parseToReadsPrec $ do + exact "mkAbsolute" + fmap mkAbsolute readParse + +instance Read a => Read (Position' a) where + readsPrec = parseToReadsPrec $ do + exact "Pn" + liftM4 Pn readParse readParse readParse readParse + +--------------------------------------------------------- +-- | Available backends. + +data CompilerBackend = LaTeX | QuickLaTeX | OtherBackend String + deriving (Eq) + +instance Show CompilerBackend where + show LaTeX = "LaTeX" + show QuickLaTeX = "QuickLaTeX" + show (OtherBackend s) = s + +instance Read CompilerBackend where + readsPrec _ s = do + (t, s) <- lex s + let b = case t of + "LaTeX" -> LaTeX + "QuickLaTeX" -> QuickLaTeX + _ -> OtherBackend t + return (b, s) + +data Rewrite = AsIs | Instantiated | HeadNormal | Simplified | Normalised + deriving (Show, Read) + +data ComputeMode = DefaultCompute | IgnoreAbstract | UseShowInstance + deriving (Show, Read, Eq) + +data UseForce + = WithForce -- ^ Ignore additional checks, like termination/positivity... + | WithoutForce -- ^ Don't ignore any checks. + deriving (Eq, Read, Show) + +data OutputForm a b = OutputForm Range [ProblemId] (OutputConstraint a b) + deriving (Functor) + +data OutputConstraint a b + = OfType b a | CmpInType Comparison a b b + | CmpElim [Polarity] a [b] [b] + | JustType b | CmpTypes Comparison b b + | CmpLevels Comparison b b + | CmpTeles Comparison b b + | JustSort b | CmpSorts Comparison b b + | Guard (OutputConstraint a b) ProblemId + | Assign b a | TypedAssign b a a | PostponedCheckArgs b [a] a a + | IsEmptyType a + | SizeLtSat a + | FindInstanceOF b a [(a,a)] + | PTSInstance b b + | PostponedCheckFunDef QName a + deriving (Functor) + +-- | A subset of 'OutputConstraint'. + +data OutputConstraint' a b = OfType' + { ofName :: b + , ofExpr :: a + } + +data OutputContextEntry name ty val + = ContextVar name ty + | ContextLet name ty val diff --git a/src/full/Agda/Interaction/BasicOps.hs b/src/full/Agda/Interaction/BasicOps.hs --- a/src/full/Agda/Interaction/BasicOps.hs +++ b/src/full/Agda/Interaction/BasicOps.hs @@ -1,5 +1,4 @@ {-# LANGUAGE BangPatterns #-} -{-# LANGUAGE CPP #-} {-# LANGUAGE UndecidableInstances #-} {-# LANGUAGE NondecreasingIndentation #-} @@ -9,8 +8,7 @@ import Prelude hiding (null) -import Control.Arrow ((***), first, second) -import Control.Applicative hiding (empty) +import Control.Arrow (first) import Control.Monad.Reader import Control.Monad.State import Control.Monad.Identity @@ -20,17 +18,21 @@ import qualified Data.Set as Set import qualified Data.List as List import Data.Maybe -import Data.Traversable hiding (mapM, forM, for) import Data.Monoid +import Data.Function (on) +import Agda.Interaction.Base import Agda.Interaction.Options +import {-# SOURCE #-} Agda.Interaction.Imports (MaybeWarnings'(..), getMaybeWarnings) +import Agda.Interaction.Response (Goals, ResponseContextEntry(..)) + import qualified Agda.Syntax.Concrete as C -- ToDo: Remove with instance of ToConcrete import Agda.Syntax.Position import Agda.Syntax.Abstract as A hiding (Open, Apply, Assign) import Agda.Syntax.Abstract.Views as A import Agda.Syntax.Abstract.Pretty import Agda.Syntax.Common -import Agda.Syntax.Info (ExprInfo(..),MetaInfo(..),emptyMetaInfo,exprNoRange,defaultAppInfo_,defaultAppInfo) +import Agda.Syntax.Info (MetaInfo(..),emptyMetaInfo,exprNoRange,defaultAppInfo_,defaultAppInfo) import qualified Agda.Syntax.Info as Info import Agda.Syntax.Internal as I import Agda.Syntax.Literal @@ -48,6 +50,7 @@ import Agda.TypeChecking.Errors ( stringTCErr ) import Agda.TypeChecking.Monad as M hiding (MetaInfo) import Agda.TypeChecking.MetaVars +import Agda.TypeChecking.MetaVars.Mention import Agda.TypeChecking.Reduce import Agda.TypeChecking.Substitute import Agda.TypeChecking.Telescope @@ -57,13 +60,16 @@ import Agda.TypeChecking.Records import Agda.TypeChecking.Irrelevance (wakeIrrelevantVars) import Agda.TypeChecking.Pretty ( PrettyTCM, prettyTCM ) +import Agda.TypeChecking.IApplyConfluence import Agda.TypeChecking.Primitive import Agda.TypeChecking.Names import Agda.TypeChecking.Free import Agda.TypeChecking.CheckInternal import Agda.TypeChecking.SizedTypes.Solve import qualified Agda.TypeChecking.Pretty as TP -import Agda.TypeChecking.Warnings ( runPM, warning ) +import Agda.TypeChecking.Warnings + ( runPM, warning, WhichWarnings(..), classifyWarnings, isMetaTCWarning + , WarningsAndNonFatalErrors, emptyWarningsAndNonFatalErrors ) import Agda.Termination.TermCheck (termMutual) @@ -78,7 +84,6 @@ import Agda.Utils.Permutation import Agda.Utils.Size -#include "undefined.h" import Agda.Utils.Impossible -- | Parses an expression. @@ -97,7 +102,13 @@ updateMetaVarRange mId rng mi <- getMetaInfo <$> lookupMeta mId e <- parseExpr rng s - concreteToAbstract (clScope mi) e + -- Andreas, 2019-08-19, issue #4007 + -- We need to be in the TCEnv of the meta variable + -- such that the scope checker can label the clause + -- of a parsed extended lambda as IsAbstract if the + -- interaction point was created in AbstractMode. + withMetaInfo mi $ + concreteToAbstract (clScope mi) e giveExpr :: UseForce -> Maybe InteractionId -> MetaId -> Expr -> TCM () -- When translator from internal to abstract is given, this function might return @@ -107,10 +118,9 @@ -- In the context (incl. signature) of the meta variable, -- type check expression and assign meta withMetaInfo (getMetaInfo mv) $ do - metaTypeCheck mv (mvJudgement mv) - where - metaTypeCheck mv IsSort{} = __IMPOSSIBLE__ - metaTypeCheck mv (HasType _ t) = do + let t = case mvJudgement mv of + IsSort{} -> __IMPOSSIBLE__ + HasType _ _ t -> t reportSDoc "interaction.give" 20 $ "give: meta type =" TP.<+> prettyTCM t -- Here, we must be in the same context where the meta was created. @@ -118,12 +128,16 @@ ctx <- getContextArgs t' <- t `piApplyM` permute (takeP (length ctx) $ mvPermutation mv) ctx traceCall (CheckExprCall CmpLeq e t') $ do - reportSDoc "interaction.give" 20 $ - "give: instantiated meta type =" TP.<+> prettyTCM t' + reportSDoc "interaction.give" 20 $ do + a <- asksTC envAbstractMode + TP.hsep + [ TP.text ("give(" ++ show a ++ "): instantiated meta type =") + , prettyTCM t' + ] v <- checkExpr e t' case mvInstantiation mv of - InstV xs v' -> unlessM ((Irrelevant ==) <$> asksTC envRelevance) $ do + InstV xs v' -> unlessM ((Irrelevant ==) <$> asksTC getRelevance) $ do reportSDoc "interaction.give" 20 $ TP.sep [ "meta was already set to value v' = " TP.<+> prettyTCM v' TP.<+> " with free variables " TP.<+> return (fsep $ map pretty xs) @@ -145,7 +159,7 @@ _ -> do -- updateMeta mi v reportSLn "interaction.give" 20 "give: meta unassigned, assigning..." args <- getContextArgs - nowSolvingConstraints $ assign DirEq mi args v + nowSolvingConstraints $ assign DirEq mi args v (AsTermsOf t') reportSDoc "interaction.give" 20 $ "give: meta variable updated!" unless (force == WithForce) $ redoChecks mii @@ -157,7 +171,7 @@ -- Double check. reportSDoc "interaction.give" 20 $ "give: double checking" vfull <- instantiateFull v - checkInternal vfull t' + checkInternal vfull CmpLeq t' -- | After a give, redo termination etc. checks for function which was complemented. redoChecks :: Maybe InteractionId -> TCM () @@ -168,7 +182,7 @@ ip <- lookupInteractionPoint ii case ipClause ip of IPNoClause -> return () - IPClause f _ _ -> do + IPClause{ipcQName = f} -> do mb <- mutualBlockOf f terErrs <- localTC (\ e -> e { envMutualBlock = Just mb }) $ termMutual [] unless (null terErrs) $ warning $ TerminationIssue terErrs @@ -239,7 +253,7 @@ ii <- registerInteractionPoint False rng Nothing let info = Info.MetaInfo { Info.metaRange = rng - , Info.metaScope = scope { scopePrecedence = [argumentCtx_] } + , Info.metaScope = set scopePrecedence [argumentCtx_] scope -- Ulf, 2017-09-07: The `argumentCtx_` above is causing #737. -- If we're building an operator application the precedence -- should be something else. @@ -252,16 +266,16 @@ where isX (A.Var y) | x == y = Sum 1 isX _ = mempty - lamView (A.Lam _ (DomainFree x) e) = Just (namedArg x, e) - lamView (A.Lam i (DomainFull (TBind r (x : xs) a)) e) + lamView (A.Lam _ (DomainFree _ x) e) = Just (namedArg x, e) + lamView (A.Lam i (DomainFull (TBind r t (x : xs) a)) e) | null xs = Just (namedArg x, e) - | otherwise = Just (namedArg x, A.Lam i (DomainFull $ TBind r xs a) e) + | otherwise = Just (namedArg x, A.Lam i (DomainFull $ TBind r t xs a) e) lamView _ = Nothing -- reduce beta-redexes where the argument is used at most once smartApp i e arg = - case lamView $ unScope e of - Just (A.BindName x, e) | count x e < 2 -> mapExpr subX e + case fmap (first A.binderName) (lamView $ unScope e) of + Just (A.BindName{unBind = x}, e) | count x e < 2 -> mapExpr subX e where subX (A.Var y) | x == y = namedArg arg subX e = e _ -> App i e arg @@ -299,9 +313,6 @@ -- | Modifier for interactive commands, -- specifying the amount of normalization in the output. -- -data Rewrite = AsIs | Instantiated | HeadNormal | Simplified | Normalised - deriving (Show, Read) - normalForm :: (Reduce t, Simplify t, Normalise t) => Rewrite -> t -> TCM t normalForm AsIs t = return t normalForm Instantiated t = return t -- reify does instantiation @@ -312,9 +323,6 @@ -- | Modifier for the interactive computation command, -- specifying the mode of computation and result display. -- -data ComputeMode = DefaultCompute | IgnoreAbstract | UseShowInstance - deriving (Show, Read, Eq) - computeIgnoreAbstract :: ComputeMode -> Bool computeIgnoreAbstract DefaultCompute = False computeIgnoreAbstract IgnoreAbstract = True @@ -335,36 +343,6 @@ -- | Modifier for interactive commands, -- specifying whether safety checks should be ignored. -data UseForce - = WithForce -- ^ Ignore additional checks, like termination/positivity... - | WithoutForce -- ^ Don't ignore any checks. - deriving (Eq, Read, Show) - -data OutputForm a b = OutputForm Range [ProblemId] (OutputConstraint a b) - deriving (Functor) - -data OutputConstraint a b - = OfType b a | CmpInType Comparison a b b - | CmpElim [Polarity] a [b] [b] - | JustType b | CmpTypes Comparison b b - | CmpLevels Comparison b b - | CmpTeles Comparison b b - | JustSort b | CmpSorts Comparison b b - | Guard (OutputConstraint a b) ProblemId - | Assign b a | TypedAssign b a a | PostponedCheckArgs b [a] a a - | IsEmptyType a - | SizeLtSat a - | FindInstanceOF b a [(a,a)] - | PTSInstance b b - | PostponedCheckFunDef QName a - deriving (Functor) - --- | A subset of 'OutputConstraint'. - -data OutputConstraint' a b = OfType' { ofName :: b - , ofExpr :: a - } - outputFormId :: OutputForm a b -> b outputFormId (OutputForm _ _ o) = out o where @@ -390,9 +368,10 @@ PostponedCheckFunDef{} -> __IMPOSSIBLE__ instance Reify ProblemConstraint (Closure (OutputForm Expr Expr)) where - reify (PConstr pids cl) = enterClosure cl $ \c -> buildClosure =<< (OutputForm (getRange c) (Set.toList pids) <$> reify c) + reify (PConstr pids cl) = withClosure cl $ \ c -> + OutputForm (getRange c) (Set.toList pids) <$> reify c -reifyElimToExpr :: I.Elim -> TCM Expr +reifyElimToExpr :: MonadReify m => I.Elim -> m Expr reifyElimToExpr e = case e of I.IApply _ _ v -> appl "iapply" <$> reify (defaultArg $ v) -- TODO Andrea: endpoints? I.Apply v -> appl "apply" <$> reify v @@ -402,7 +381,9 @@ appl s v = A.App defaultAppInfo_ (A.Lit (LitString noRange s)) $ fmap unnamed v instance Reify Constraint (OutputConstraint Expr Expr) where - reify (ValueCmp cmp t u v) = CmpInType cmp <$> reify t <*> reify u <*> reify v + reify (ValueCmp cmp (AsTermsOf t) u v) = CmpInType cmp <$> reify t <*> reify u <*> reify v + reify (ValueCmp cmp AsSizes u v) = CmpInType cmp <$> (reify =<< sizeType) <*> reify u <*> reify v + reify (ValueCmp cmp AsTypes u v) = CmpTypes cmp <$> reify u <*> reify v reify (ValueCmpOnFace cmp p t u v) = CmpInType cmp <$> (reify =<< ty) <*> reify (lam_o u) <*> reify (lam_o v) where lam_o = I.Lam (setRelevance Irrelevant defaultArgInfo) . NoAbs "_" @@ -414,7 +395,6 @@ CmpElim cmp <$> reify t <*> mapM reifyElimToExpr es1 <*> mapM reifyElimToExpr es2 reify (LevelCmp cmp t t') = CmpLevels cmp <$> reify t <*> reify t' - reify (TypeCmp cmp t t') = CmpTypes cmp <$> reify t <*> reify t' reify (TelCmp a b cmp t t') = CmpTeles cmp <$> (ETel <$> reify t) <*> (ETel <$> reify t') reify (SortCmp cmp s s') = CmpSorts cmp <$> reify s <*> reify s' reify (Guarded c pid) = do @@ -430,15 +410,15 @@ BlockedConst t -> do e <- reify t return $ Assign m' e - PostponedTypeCheckingProblem cl _ -> enterClosure cl $ \p -> case p of + PostponedTypeCheckingProblem cl _ -> enterClosure cl $ \case CheckExpr cmp e a -> do a <- reify a return $ TypedAssign m' e a CheckLambda cmp (Arg ai (xs, mt)) body target -> do domType <- maybe (return underscore) reify mt target <- reify target - let mkN (WithHiding h x) = setHiding h $ defaultNamedArg $ A.BindName x - bs = TBind noRange (map mkN xs) domType + let mkN (WithHiding h x) = setHiding h $ defaultNamedArg $ A.mkBinder_ x + bs = mkTBind noRange (map mkN xs) domType e = A.Lam Info.exprNoRange (DomainFull bs) body return $ TypedAssign m' e target CheckArgs _ _ args t0 t1 _ -> do @@ -464,14 +444,19 @@ return $ PostponedCheckFunDef q a reify (HasBiggerSort a) = OfType <$> reify a <*> reify (UnivSort a) reify (HasPTSRule a b) = do - (a,(x,b)) <- reify (a,b) + (a,(x,b)) <- reify (unDom a,b) return $ PTSInstance a b + reify (CheckMetaInst m) = do + t <- jMetaType . mvJudgement <$> lookupMeta m + OfType <$> reify (MetaV m []) <*> reify t + instance (Pretty a, Pretty b) => Pretty (OutputForm a b) where - pretty (OutputForm r pids c) - | null pids = sep [pretty c, prange r] - | otherwise = sep [pretty pids, nest 2 $ sep [pretty c, prange r]] + pretty (OutputForm r pids c) = sep [pretty c, nest 2 $ prange r, nest 2 $ prPids pids] where + prPids [] = empty + prPids [pid] = parens $ "problem" <+> pretty pid + prPids pids = parens $ "problems" <+> fsep (punctuate "," $ map pretty pids) prange r | null s = empty | otherwise = text $ " [ at " ++ s ++ " ]" where s = prettyShow r @@ -488,7 +473,7 @@ CmpLevels cmp t t' -> pcmp cmp t t' CmpTeles cmp t t' -> pcmp cmp t t' CmpSorts cmp s s' -> pcmp cmp s s' - Guard o pid -> pretty o brackets ("blocked by problem" <+> pretty pid) + Guard o pid -> pretty o parens ("blocked by problem" <+> pretty pid) Assign m e -> bin (pretty m) ":=" (pretty e) TypedAssign m e a -> bin (pretty m) ":=" $ bin (pretty e) ":?" (pretty a) PostponedCheckArgs m es t0 t1 -> @@ -518,17 +503,17 @@ toConcrete (JustType e) = JustType <$> toConcrete e toConcrete (JustSort e) = JustSort <$> toConcrete e toConcrete (CmpInType cmp t e e') = - CmpInType cmp <$> toConcreteCtx TopCtx t <*> toConcreteCtx argumentCtx_ e - <*> toConcreteCtx argumentCtx_ e' + CmpInType cmp <$> toConcreteCtx TopCtx t <*> toConcreteCtx TopCtx e + <*> toConcreteCtx TopCtx e' toConcrete (CmpElim cmp t e e') = CmpElim cmp <$> toConcreteCtx TopCtx t <*> toConcreteCtx TopCtx e <*> toConcreteCtx TopCtx e' - toConcrete (CmpTypes cmp e e') = CmpTypes cmp <$> toConcreteCtx argumentCtx_ e - <*> toConcreteCtx argumentCtx_ e' - toConcrete (CmpLevels cmp e e') = CmpLevels cmp <$> toConcreteCtx argumentCtx_ e - <*> toConcreteCtx argumentCtx_ e' + toConcrete (CmpTypes cmp e e') = CmpTypes cmp <$> toConcreteCtx TopCtx e + <*> toConcreteCtx TopCtx e' + toConcrete (CmpLevels cmp e e') = CmpLevels cmp <$> toConcreteCtx TopCtx e + <*> toConcreteCtx TopCtx e' toConcrete (CmpTeles cmp e e') = CmpTeles cmp <$> toConcrete e <*> toConcrete e' - toConcrete (CmpSorts cmp e e') = CmpSorts cmp <$> toConcreteCtx argumentCtx_ e - <*> toConcreteCtx argumentCtx_ e' + toConcrete (CmpSorts cmp e e') = CmpSorts cmp <$> toConcreteCtx TopCtx e + <*> toConcreteCtx TopCtx e' toConcrete (Guard o pid) = Guard <$> toConcrete o <*> pure pid toConcrete (Assign m e) = noTakenNames $ Assign <$> toConcrete m <*> toConcreteCtx TopCtx e toConcrete (TypedAssign m e a) = TypedAssign <$> toConcrete m <*> toConcreteCtx TopCtx e @@ -550,12 +535,102 @@ ToConcrete (OutputConstraint' a b) (OutputConstraint' c d) where toConcrete (OfType' e t) = OfType' <$> toConcrete e <*> toConcreteCtx TopCtx t +instance Reify a e => Reify (IPBoundary' a) (IPBoundary' e) where + reify = traverse reify + +instance ToConcrete a c => ToConcrete (IPBoundary' a) (IPBoundary' c) where + toConcrete = traverse (toConcreteCtx TopCtx) + +instance Pretty c => Pretty (IPBoundary' c) where + pretty (IPBoundary eqs val meta over) = do + let + xs = map (\ (l,r) -> pretty l <+> "=" <+> pretty r) eqs + rhs = case over of + Overapplied -> "=" <+> pretty meta + NotOverapplied -> mempty + prettyList_ xs <+> "⊢" <+> pretty val <+> rhs + + +prettyConstraints :: [Closure Constraint] -> TCM [OutputForm C.Expr C.Expr] +prettyConstraints cs = do + forM cs $ \ c -> do + cl <- reify (PConstr Set.empty c) + enterClosure cl abstractToConcrete_ + getConstraints :: TCM [OutputForm C.Expr C.Expr] -getConstraints = getConstraints' $ const True +getConstraints = getConstraints' return $ const True -getConstraints' :: (ProblemConstraint -> Bool) -> TCM [OutputForm C.Expr C.Expr] -getConstraints' f = liftTCM $ do - cs <- filter f <$> M.getAllConstraints +namedMetaOf :: OutputConstraint A.Expr a -> a +namedMetaOf (OfType i _) = i +namedMetaOf (JustType i) = i +namedMetaOf (JustSort i) = i +namedMetaOf (Assign i _) = i +namedMetaOf _ = __IMPOSSIBLE__ + +getConstraintsMentioning :: Rewrite -> MetaId -> TCM [OutputForm C.Expr C.Expr] +getConstraintsMentioning norm m = getConstrs instantiateBlockingFull (mentionsMeta m) + -- could be optimized by not doing a full instantiation up front, with a more clever mentionsMeta. + where + instantiateBlockingFull p + = locallyTCState stInstantiateBlocking (const True) $ + instantiateFull p + + -- Trying to find the actual meta application, as long as it's not + -- buried too deep. + -- We could look further but probably not under binders as that would mess with + -- the call to @unifyElimsMeta@ below. + hasHeadMeta c = + case c of + ValueCmp _ _ u v -> isMeta u `mplus` isMeta v + ValueCmpOnFace cmp p t u v -> isMeta u `mplus` isMeta v + -- TODO: extend to other comparisons? + ElimCmp cmp fs t v as bs -> Nothing + LevelCmp cmp u v -> Nothing + TelCmp a b cmp tela telb -> Nothing + SortCmp cmp a b -> Nothing + Guarded c pid -> hasHeadMeta c + UnBlock{} -> Nothing + FindInstance{} -> Nothing + IsEmpty r t -> isMeta (unEl t) + CheckSizeLtSat t -> isMeta t + CheckFunDef{} -> Nothing + HasBiggerSort a -> Nothing + HasPTSRule a b -> Nothing + UnquoteTactic{} -> Nothing + CheckMetaInst{} -> Nothing + + isMeta (MetaV m' es_m) + | m == m' = Just es_m + isMeta _ = Nothing + + getConstrs g f = liftTCM $ do + cs <- stripConstraintPids . filter f <$> (mapM g =<< M.getAllConstraints) + reportSDoc "constr.ment" 20 $ "getConstraintsMentioning" + forM cs $ \(PConstr s c) -> do + c <- normalForm norm c + case allApplyElims =<< hasHeadMeta (clValue c) of + Just as_m -> do + -- unifyElimsMeta tries to move the constraint into + -- (an extension of) the context where @m@ comes from. + unifyElimsMeta m as_m c $ \ eqs c -> do + flip enterClosure abstractToConcrete_ =<< reify . PConstr s =<< buildClosure c + _ -> do + cl <- reify $ PConstr s c + enterClosure cl abstractToConcrete_ + +-- Copied from Agda.TypeChecking.Pretty.Warning.prettyConstraints +stripConstraintPids :: Constraints -> Constraints +stripConstraintPids cs = List.sortBy (compare `on` isBlocked) $ map stripPids cs + where + isBlocked = not . null . blocking . clValue . theConstraint + interestingPids = Set.fromList $ concatMap (blocking . clValue . theConstraint) cs + stripPids (PConstr pids c) = PConstr (Set.intersection pids interestingPids) c + blocking (Guarded c pid) = pid : blocking c + blocking _ = [] + +getConstraints' :: (ProblemConstraint -> TCM ProblemConstraint) -> (ProblemConstraint -> Bool) -> TCM [OutputForm C.Expr C.Expr] +getConstraints' g f = liftTCM $ do + cs <- stripConstraintPids . filter f <$> (mapM g =<< M.getAllConstraints) cs <- forM cs $ \c -> do cl <- reify c enterClosure cl abstractToConcrete_ @@ -568,6 +643,58 @@ let m = QuestionMark emptyMetaInfo{ metaNumber = Just $ fromIntegral ii } ii abstractToConcrete_ $ OutputForm noRange [] $ Assign m e + +getIPBoundary :: Rewrite -> InteractionId -> TCM [IPBoundary' C.Expr] +getIPBoundary norm ii = do + ip <- lookupInteractionPoint ii + case ipClause ip of + IPClause { ipcBoundary = cs } -> do + forM cs $ \ cl -> enterClosure cl $ \ b -> + abstractToConcrete_ =<< reifyUnblocked =<< normalForm norm b + IPNoClause -> return [] + +-- | Goals and Warnings + +getGoals :: TCM Goals +getGoals = do + -- visible metas (as-is) + visibleMetas <- typesOfVisibleMetas AsIs + -- hidden metas (unsolved implicit arguments simplified) + unsolvedNotOK <- not . optAllowUnsolved <$> pragmaOptions + hiddenMetas <- (guard unsolvedNotOK >>) <$> typesOfHiddenMetas Simplified + return (visibleMetas, hiddenMetas) + +-- | Print open metas nicely. +showGoals :: Goals -> TCM String +showGoals (ims, hms) = do + di <- forM ims $ \ i -> + withInteractionId (outputFormId $ OutputForm noRange [] i) $ + prettyATop i + dh <- mapM showA' hms + return $ unlines $ map show di ++ dh + where + showA' :: OutputConstraint A.Expr NamedMeta -> TCM String + showA' m = do + let i = nmid $ namedMetaOf m + r <- getMetaRange i + d <- withMetaId i (prettyATop m) + return $ show d ++ " [ at " ++ show r ++ " ]" + +getWarningsAndNonFatalErrors :: TCM WarningsAndNonFatalErrors +getWarningsAndNonFatalErrors = do + mws <- getMaybeWarnings AllWarnings + let notMetaWarnings = filter (not . isMetaTCWarning) <$> mws + return $ case notMetaWarnings of + SomeWarnings ws@(_:_) -> classifyWarnings ws + _ -> emptyWarningsAndNonFatalErrors + +-- | Collecting the context of the given meta-variable. +getResponseContext + :: Rewrite -- ^ Normalise? + -> InteractionId + -> TCM [ResponseContextEntry] +getResponseContext norm ii = contextOfMeta ii norm + -- | @getSolvedInteractionPoints True@ returns all solutions, -- even if just solved by another, non-interaction meta. -- @@ -588,7 +715,7 @@ v <- instantiate v let isMeta = case v of MetaV{} -> True; _ -> False if isMeta && not all then return [] else do - e <- reify =<< normalForm norm v + e <- blankNotInScope =<< reify =<< normalForm norm v return [(i, m, ScopedExpr scope e)] unsol = return [] case mvInstantiation mv of @@ -606,7 +733,7 @@ where rewriteJudg :: MetaVariable -> Judgement MetaId -> TCM (OutputConstraint Expr NamedMeta) - rewriteJudg mv (HasType i t) = do + rewriteJudg mv (HasType i cmp t) = do ms <- getMetaNameSuggestion i -- Andreas, 2019-03-17, issue #3638: -- Need to put meta type into correct context _before_ normalizing, @@ -626,7 +753,7 @@ ] reportSDoc "interactive.meta.scope" 20 $ TP.text $ show $ getMetaScope mv -- Andreas, 2016-01-19, issue #1783: need piApplyM instead of just piApply - OfType x <$> reify t + OfType x <$> reifyUnblocked t rewriteJudg mv (IsSort i t) = do ms <- getMetaNameSuggestion i return $ JustSort $ NamedMeta ms i @@ -648,34 +775,56 @@ store <- IntMap.filterWithKey (openAndImplicit is . MetaId) <$> getMetaStore mapM (typeOfMetaMI norm . MetaId) $ IntMap.keys store where + openAndImplicit is x m | isJust (mvTwin m) = False openAndImplicit is x m = case mvInstantiation m of M.InstV{} -> False M.Open -> x `notElem` is M.OpenInstance -> x `notElem` is -- OR: True !? - M.BlockedConst{} -> True + M.BlockedConst{} -> False M.PostponedTypeCheckingProblem{} -> False +-- | Create type of application of new helper function that would solve the goal. metaHelperType :: Rewrite -> InteractionId -> Range -> String -> TCM (OutputConstraint' Expr Expr) metaHelperType norm ii rng s = case words s of [] -> failure - f : _ -> do + f : _ -> withInteractionId ii $ do ensureName f A.Application h args <- A.appView . getBody . deepUnscope <$> parseExprIn ii rng ("let " ++ f ++ " = _ in " ++ s) - withInteractionId ii $ do + inCxt <- hasElem <$> getContextNames + cxtArgs <- getContextArgs + a0 <- (`piApply` cxtArgs) <$> (getMetaType =<< lookupInteractionId ii) + case mapM (isVar . namedArg) args >>= \ xs -> xs <$ guard (all inCxt xs) of + + -- Andreas, 2019-10-11 + -- If all arguments are variables, there is no need to abstract. + -- We simply make exactly the given arguments visible and all other hidden. + Just xs -> do + let inXs = hasElem xs + let hideButXs dom = setHiding (if inXs $ fst $ unDom dom then NotHidden else Hidden) dom + tel <- telFromList . map (fmap (first nameToArgName) . hideButXs) . reverse <$> getContext + OfType' h <$> do + -- Andreas, 2019-10-11: I actually prefer pi-types over ->. + localTC (\e -> e { envPrintDomainFreePi = True }) $ reify $ telePiVisible tel a0 + + -- If some arguments are not variables. + Nothing -> do cxtArgs <- getContextArgs -- cleanupType relies on with arguments being named 'w', -- so we'd better rename any actual 'w's to avoid confusion. - tel <- runIdentity . onNamesTel unW <$> getContextTelescope - a <- runIdentity . onNames unW . (`piApply` cxtArgs) <$> (getMetaType =<< lookupInteractionId ii) - (vs, as) <- unzip <$> mapM (inferExpr . namedThing . unArg) args + tel <- runIdentity . onNamesTel unW <$> getContextTelescope + let a = runIdentity . onNames unW $ a0 + vtys <- mapM (\ a -> fmap (WithHiding (getHiding a) . fmap OtherType) $ inferExpr $ namedArg a) args -- Remember the arity of a TelV atel _ <- telView a let arity = size atel - (delta1, delta2, _, a', as', vs') = splitTelForWith tel a (map OtherType as) vs + (delta1, delta2, _, a', vtys') = splitTelForWith tel a vtys a <- localTC (\e -> e { envPrintDomainFreePi = True }) $ do - reify =<< cleanupType arity args =<< normalForm norm =<< fst <$> withFunctionType delta1 vs' as' delta2 a' - reportSDoc "interaction.helper" 10 $ TP.vcat + reify =<< cleanupType arity args =<< normalForm norm =<< fst <$> withFunctionType delta1 vtys' delta2 a' + reportSDoc "interaction.helper" 10 $ TP.vcat $ + let extractOtherType = \case { OtherType a -> a; _ -> __IMPOSSIBLE__ } in + let (vs, as) = unzipWith (fmap extractOtherType . whThing) vtys in + let (vs', as') = unzipWith (fmap extractOtherType . whThing) vtys' in [ "generating helper function" , TP.nest 2 $ "tel = " TP.<+> inTopContext (prettyTCM tel) , TP.nest 2 $ "a = " TP.<+> prettyTCM a @@ -687,26 +836,32 @@ , TP.nest 2 $ "as' = " TP.<+> inTopContext (addContext delta1 $ prettyTCM as') , TP.nest 2 $ "vs' = " TP.<+> inTopContext (addContext delta1 $ prettyTCM vs') ] - return (OfType' h a) + return $ OfType' h a where failure = typeError $ GenericError $ "Expected an argument of the form f e1 e2 .. en" ensureName f = do ce <- parseExpr rng f - case ce of - C.Ident{} -> return () - C.RawApp _ [C.Ident{}] -> return () - _ -> do + flip (caseMaybe $ isName ce) (\ _ -> return ()) $ do reportSLn "interaction.helper" 10 $ "ce = " ++ show ce failure + isName :: C.Expr -> Maybe C.Name + isName = \case + C.Ident (C.QName x) -> Just x + C.RawApp _ [C.Ident (C.QName x)] -> Just x + _ -> Nothing + isVar :: A.Expr -> Maybe A.Name + isVar = \case + A.Var x -> Just x + _ -> Nothing cleanupType arity args t = do -- Get the arity of t TelV ttel _ <- telView t - -- Compute the number or pi-types subject to stripping. + -- Compute the number of pi-types subject to stripping. let n = size ttel - arity -- It cannot be negative, otherwise we would have performed a -- negative number of with-abstractions. unless (n >= 0) __IMPOSSIBLE__ - return $ evalState (renameVars $ hiding args $ stripUnused n t) args + return $ evalState (renameVars $ stripUnused n t) args getBody (A.Let _ _ e) = e getBody _ = __IMPOSSIBLE__ @@ -725,12 +880,6 @@ -- renameVars = onNames (stringToArgName <.> renameVar . argNameToString) renameVars = onNames renameVar - hiding args (El s v) = El s $ hidingTm args v - hidingTm (arg:args) (I.Pi a b) | absName b == "w" = - I.Pi (setHiding (getHiding arg) a) (hiding args <$> b) - hidingTm args (I.Pi a b) = I.Pi a (hiding args <$> b) - hidingTm _ a = a - -- onNames :: Applicative m => (ArgName -> m ArgName) -> Type -> m Type onNames :: Applicative m => (String -> m String) -> Type -> m Type onNames f (El s v) = El s <$> onNamesTm f v @@ -765,36 +914,58 @@ renameVar s = pure s betterName = do - arg : args <- get - put args - return $ case arg of - Arg _ (Named _ (A.Var x)) -> show $ A.nameConcrete x - Arg _ (Named (Just x) _) -> argNameToString $ rangedThing x - _ -> "w" + xs <- get + case xs of + [] -> __IMPOSSIBLE__ + arg : args -> do + put args + return $ if + | Arg _ (Named _ (A.Var x)) <- arg -> prettyShow $ A.nameConcrete x + | Just x <- bareNameOf arg -> argNameToString x + | otherwise -> "w" --- Gives a list of names and corresponding types. +-- | Gives a list of names and corresponding types. +-- This list includes not only the local variables in scope, but also the let-bindings. -contextOfMeta :: InteractionId -> Rewrite -> TCM [OutputConstraint' Expr Name] -contextOfMeta ii norm = do +contextOfMeta :: InteractionId -> Rewrite -> TCM [ResponseContextEntry] +contextOfMeta ii norm = withInteractionId ii $ do info <- getMetaInfo <$> (lookupMeta =<< lookupInteractionId ii) withMetaInfo info $ do + -- List of local variables. cxt <- getContext let n = length cxt localVars = zipWith raise [1..] cxt - mkLet (x, lb) = do - (tm, !dom) <- getOpen lb - return $ (,) x <$> dom - letVars <- mapM mkLet . Map.toDescList =<< asksTC envLetBindings - mapMaybe visible . reverse <$> mapM out (letVars ++ localVars) - where visible (OfType x y) | not (isNoName x) = Just (OfType' x y) - | otherwise = Nothing - visible _ = __IMPOSSIBLE__ - out (Dom{unDom = (x, t)}) = do - t' <- reify =<< normalForm norm t - return $ OfType x t' + -- List of let-bindings. + letVars <- Map.toAscList <$> asksTC envLetBindings + -- Reify the types and filter out bindings without a name. + (++) <$> forMaybeM (reverse localVars) mkVar + <*> forMaybeM letVars mkLet + where + mkVar :: Dom (Name, Type) -> TCM (Maybe ResponseContextEntry) + mkVar Dom{ domInfo = ai, unDom = (name, t) } = do + if shouldHide ai name then return Nothing else Just <$> do + let n = nameConcrete name + x <- abstractToConcrete_ name + let s = C.isInScope x + ty <- reifyUnblocked =<< normalForm norm t + return $ ResponseContextEntry n x (Arg ai ty) Nothing s + mkLet :: (Name, Open (Term, Dom Type)) -> TCM (Maybe ResponseContextEntry) + mkLet (name, lb) = do + (tm, !dom) <- getOpen lb + if shouldHide (domInfo dom) name then return Nothing else Just <$> do + let n = nameConcrete name + x <- abstractToConcrete_ name + let s = C.isInScope x + ty <- reifyUnblocked =<< normalForm norm dom + v <- reifyUnblocked =<< normalForm norm tm + return $ ResponseContextEntry n x ty (Just v) s + + shouldHide :: ArgInfo -> A.Name -> Bool + shouldHide ai n = not (isInstance ai) && (isNoName n || nameIsRecordName n) + -- | Returns the type of the expression in the current environment -- We wake up irrelevant variables just in case the user want to -- invoke that command in an irrelevant context. @@ -802,7 +973,7 @@ typeInCurrent norm e = do (_,t) <- wakeIrrelevantVars $ inferExpr e v <- normalForm norm t - reify v + reifyUnblocked v @@ -834,7 +1005,7 @@ mi <- lookupInteractionId ii mv <- lookupMeta mi withMetaInfo (getMetaInfo mv) $ case mvJudgement mv of - HasType _ t -> do + HasType _ _ t -> do t <- reduce =<< piApplyM t =<< getContextArgs -- Andreas, 2013-03-05 Issue 810: skip hidden domains in introduction -- of constructor. @@ -910,8 +1081,8 @@ introRec d = do hfs <- getRecordFieldNames d fs <- ifM showImplicitArguments - (return $ map unArg hfs) - (return [ unArg a | a <- hfs, visible a ]) + (return $ map unDom hfs) + (return [ unDom a | a <- hfs, visible a ]) let e = C.Rec noRange $ for fs $ \ f -> Left $ C.FieldAssignment f $ C.QuestionMark noRange Nothing return [ prettyShow e ] @@ -945,7 +1116,8 @@ -- Unfortunately, referring to let-bound variables -- from the top level module telescope will for now result in a not-in-scope error. let names :: [A.Name] - names = map localVar $ filter ((LetBound /=) . localBinder) $ map snd $ reverse $ scopeLocals scope + names = map localVar $ filter ((LetBound /=) . localBindingSource) + $ map snd $ reverse $ scope ^. scopeLocals -- Andreas, 2016-12-31, issue #2371 -- The following is an unnecessary complication, as shadowed locals -- are not in scope anyway (they are ambiguous). @@ -1032,7 +1204,7 @@ (q, vs, defn) <- fromMaybeM notRecordType $ isRecordType t case defn of Record{ recFields = fs, recTel = rtel } -> do - let xs = map (nameConcrete . qnameName . unArg) fs + let xs = map (nameConcrete . qnameName . unDom) fs tel = apply rtel vs doms = flattenTel tel -- Andreas, 2019-04-10, issue #3687: use flattenTel @@ -1075,6 +1247,6 @@ whyInScope s = do x <- parseName noRange s scope <- getScope - return ( lookup x $ map (first C.QName) $ scopeLocals scope + return ( lookup x $ map (first C.QName) $ scope ^. scopeLocals , scopeLookup x scope , scopeLookup x scope ) diff --git a/src/full/Agda/Interaction/CommandLine.hs b/src/full/Agda/Interaction/CommandLine.hs --- a/src/full/Agda/Interaction/CommandLine.hs +++ b/src/full/Agda/Interaction/CommandLine.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} module Agda.Interaction.CommandLine where @@ -7,6 +6,7 @@ import qualified Data.List as List import Data.Maybe +import Agda.Interaction.Base hiding (Command) import Agda.Interaction.BasicOps as BasicOps hiding (parseExpr) import Agda.Interaction.Monad @@ -33,7 +33,6 @@ import Agda.Utils.Monad import Agda.Utils.Pretty -#include "undefined.h" import Agda.Utils.Impossible data ExitCode a = Continue | ContinueIn TCEnv | Return a @@ -265,7 +264,7 @@ i <- InteractionId <$> readM meta mi <- lookupMeta =<< lookupInteractionId i withMetaInfo (getMetaInfo mi) $ do - ctx <- List.map unDom . telToList <$> getContextTelescope + ctx <- List.map I.unDom . telToList <$> getContextTelescope zipWithM_ display ctx $ reverse $ zipWith const [1..] ctx where display (x, t) n = do @@ -273,7 +272,7 @@ ["normal"] -> normalise $ raise n t _ -> return $ raise n t d <- prettyTCM t - liftIO $ print $ text (I.argNameToString x) <+> ":" <+> d + liftIO $ print $ text (argNameToString x) <+> ":" <+> d showContext _ = liftIO $ putStrLn ":Context meta" -- | The logo that prints when Agda is started in interactive mode. diff --git a/src/full/Agda/Interaction/EmacsCommand.hs b/src/full/Agda/Interaction/EmacsCommand.hs --- a/src/full/Agda/Interaction/EmacsCommand.hs +++ b/src/full/Agda/Interaction/EmacsCommand.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} ------------------------------------------------------------------------ -- | Code for instructing Emacs to do things @@ -13,10 +12,6 @@ , clearWarning , displayRunningInfo ) where - -#if MIN_VERSION_base(4,11,0) -import Prelude hiding ((<>)) -#endif import qualified Data.List as List diff --git a/src/full/Agda/Interaction/EmacsTop.hs b/src/full/Agda/Interaction/EmacsTop.hs --- a/src/full/Agda/Interaction/EmacsTop.hs +++ b/src/full/Agda/Interaction/EmacsTop.hs @@ -1,25 +1,44 @@ --- {-# LANGUAGE CPP #-} - module Agda.Interaction.EmacsTop ( mimicGHCi + , namedMetaOf + , showGoals + , showInfoError + , explainWhyInScope + , prettyTypeOfMeta ) where -import Control.Monad.State +import Control.Monad.State hiding (state) import qualified Data.List as List -import Agda.Utils.Maybe -import Agda.Utils.Pretty -import Agda.Utils.String - import Agda.Syntax.Common -import Agda.TypeChecking.Monad +import Agda.Syntax.Position +import Agda.Syntax.Scope.Base +import Agda.Syntax.Abstract.Pretty (prettyATop) +import Agda.Syntax.Abstract as A +import Agda.Syntax.Concrete as C +import Agda.TypeChecking.Errors (prettyError) +import qualified Agda.TypeChecking.Pretty as TCP +import Agda.TypeChecking.Pretty (prettyTCM) +import Agda.TypeChecking.Pretty.Warning (prettyTCWarnings, prettyTCWarnings') +import Agda.TypeChecking.Monad +import Agda.TypeChecking.Warnings (WarningsAndNonFatalErrors(..)) import Agda.Interaction.AgdaTop +import Agda.Interaction.Base +import Agda.Interaction.BasicOps as B import Agda.Interaction.Response as R import Agda.Interaction.EmacsCommand hiding (putResponse) import Agda.Interaction.Highlighting.Emacs import Agda.Interaction.Highlighting.Precise (TokenBased(..)) - +import Agda.Interaction.InteractionTop (localStateCommandM) +import Agda.Interaction.Imports (getAllWarningsOfTCErr) +import Agda.Utils.Impossible (__IMPOSSIBLE__) +import Agda.Utils.Function (applyWhen) +import Agda.Utils.Null (empty) +import Agda.Utils.Maybe +import Agda.Utils.Pretty +import Agda.Utils.String +import Agda.Utils.Time (CPUTime) import Agda.VersionCommit ---------------------------------- @@ -30,62 +49,14 @@ -- 'mimicGHCi' reads the Emacs frontend commands from stdin, -- interprets them and print the result into stdout. mimicGHCi :: TCM () -> TCM () -mimicGHCi = repl (liftIO . mapM_ print <=< liftIO . lispifyResponse) "Agda2> " - --- | Given strings of goals, warnings and errors, return a pair of the --- body and the title for the info buffer -formatWarningsAndErrors :: String -> String -> String -> (String, String) -formatWarningsAndErrors g w e = (body, title) - where - isG = not $ null g - isW = not $ null w - isE = not $ null e - title = List.intercalate "," $ catMaybes - [ " Goals" <$ guard isG - , " Errors" <$ guard isE - , " Warnings" <$ guard isW - , " Done" <$ guard (not (isG || isW || isE)) - ] - - body = List.intercalate "\n" $ catMaybes - [ g <$ guard isG - , delimiter "Errors" <$ guard (isE && (isG || isW)) - , e <$ guard isE - , delimiter "Warnings" <$ guard (isW && (isG || isE)) - , w <$ guard isW - ] +mimicGHCi = repl (liftIO . mapM_ print <=< lispifyResponse) "Agda2> " -- | Convert Response to an elisp value for the interactive emacs frontend. -lispifyResponse :: Response -> IO [Lisp String] +lispifyResponse :: Response -> TCM [Lisp String] lispifyResponse (Resp_HighlightingInfo info remove method modFile) = - (:[]) <$> lispifyHighlightingInfo info remove method modFile -lispifyResponse (Resp_DisplayInfo info) = return $ case info of - Info_CompilationOk w e -> f body "*Compilation result*" - where (body, _) = formatWarningsAndErrors "The module was successfully compiled.\n" w e -- abusing the goals field since we ignore the title - Info_Constraints s -> f s "*Constraints*" - Info_AllGoalsWarnings g w e -> f body ("*All" ++ title ++ "*") - where (body, title) = formatWarningsAndErrors g w e - Info_Auto s -> f s "*Auto*" - Info_Error s -> f s "*Error*" - Info_Time s -> f (render s) "*Time*" - Info_NormalForm s -> f (render s) "*Normal Form*" -- show? - Info_InferredType s -> f (render s) "*Inferred Type*" - Info_CurrentGoal s -> f (render s) "*Current Goal*" - Info_GoalType s -> f (render s) "*Goal type etc.*" - Info_ModuleContents s -> f (render s) "*Module contents*" - Info_SearchAbout s -> f (render s) "*Search About*" - Info_WhyInScope s -> f (render s) "*Scope Info*" - Info_Context s -> f (render s) "*Context*" - Info_HelperFunction s -> [ L [ A "agda2-info-action-and-copy" - , A $ quote "*Helper function*" - , A $ quote (render s ++ "\n") - , A "nil" - ] - ] - Info_Intro s -> f (render s) "*Intro*" - Info_Version -> f ("Agda version " ++ versionWithCommitInfo) "*Agda Version*" - where f content bufname = [ display_info' False bufname content ] + (:[]) <$> liftIO (lispifyHighlightingInfo info remove method modFile) +lispifyResponse (Resp_DisplayInfo info) = lispifyDisplayInfo info lispifyResponse (Resp_ClearHighlighting tokenBased) = return [ L $ A "agda2-highlight-clear" : case tokenBased of @@ -94,6 +65,7 @@ [ Q (lispifyTokenBased tokenBased) ] ] lispifyResponse Resp_DoneAborting = return [ L [ A "agda2-abort-done" ] ] +lispifyResponse Resp_DoneExiting = return [ L [ A "agda2-exit-done" ] ] lispifyResponse Resp_ClearRunningInfo = return [ clearRunningInfo ] lispifyResponse (Resp_RunningInfo n s) | n <= 1 = return [ displayRunningInfo s ] @@ -122,7 +94,7 @@ Give_String str -> quote str Give_Paren -> "'paren" Give_NoParen -> "'no-paren" -lispifyResponse (Resp_MakeCase variant pcs) = return +lispifyResponse (Resp_MakeCase ii variant pcs) = return [ lastTag 2 $ L [ A cmd, Q $ L $ map (A . quote) pcs ] ] where cmd = case variant of @@ -135,6 +107,143 @@ where prn (ii,e)= [showNumIId ii, A $ quote $ prettyShow e] +lispifyDisplayInfo :: DisplayInfo -> TCM [Lisp String] +lispifyDisplayInfo info = case info of + Info_CompilationOk ws -> do + warnings <- prettyTCWarnings (tcWarnings ws) + errors <- prettyTCWarnings (nonFatalErrors ws) + -- abusing the goals field since we ignore the title + let (body, _) = formatWarningsAndErrors + "The module was successfully compiled.\n" + warnings + errors + format body "*Compilation result*" + Info_Constraints s -> format (show $ vcat $ map pretty s) "*Constraints*" + Info_AllGoalsWarnings ms ws -> do + goals <- showGoals ms + warnings <- prettyTCWarnings (tcWarnings ws) + errors <- prettyTCWarnings (nonFatalErrors ws) + let (body, title) = formatWarningsAndErrors goals warnings errors + format body ("*All" ++ title ++ "*") + Info_Auto s -> format s "*Auto*" + Info_Error err -> do + s <- showInfoError err + format s "*Error*" + Info_Time s -> format (render $ prettyTimed s) "*Time*" + Info_NormalForm state cmode time expr -> do + exprDoc <- evalStateT prettyExpr state + let doc = maybe empty prettyTimed time $$ exprDoc + format (render doc) "*Normal Form*" + where + prettyExpr = localStateCommandM + $ lift + $ B.atTopLevel + $ allowNonTerminatingReductions + $ (if computeIgnoreAbstract cmode then ignoreAbstractMode else inConcreteMode) + $ (B.showComputed cmode) + $ expr + Info_InferredType state time expr -> do + exprDoc <- evalStateT prettyExpr state + let doc = maybe empty prettyTimed time $$ exprDoc + format (render doc) "*Inferred Type*" + where + prettyExpr = localStateCommandM + $ lift + $ B.atTopLevel + $ TCP.prettyA + $ expr + Info_ModuleContents modules tel types -> do + doc <- localTCState $ do + typeDocs <- addContext tel $ forM types $ \ (x, t) -> do + doc <- prettyTCM t + return (prettyShow x, ":" <+> doc) + return $ vcat + [ "Modules" + , nest 2 $ vcat $ map pretty modules + , "Names" + , nest 2 $ align 10 typeDocs + ] + format (render doc) "*Module contents*" + Info_SearchAbout hits names -> do + hitDocs <- forM hits $ \ (x, t) -> do + doc <- prettyTCM t + return (prettyShow x, ":" <+> doc) + let doc = "Definitions about" <+> + text (List.intercalate ", " $ words names) $$ nest 2 (align 10 hitDocs) + format (render doc) "*Search About*" + Info_WhyInScope s cwd v xs ms -> do + doc <- explainWhyInScope s cwd v xs ms + format (render doc) "*Scope Info*" + Info_Context ii ctx -> do + doc <- localTCState (prettyResponseContext ii False ctx) + format (render doc) "*Context*" + Info_Intro_NotFound -> format "No introduction forms found." "*Intro*" + Info_Intro_ConstructorUnknown ss -> do + let doc = sep [ "Don't know which constructor to introduce of" + , let mkOr [] = [] + mkOr [x, y] = [text x <+> "or" <+> text y] + mkOr (x:xs) = text x : mkOr xs + in nest 2 $ fsep $ punctuate comma (mkOr ss) + ] + format (render doc) "*Intro*" + Info_Version -> format ("Agda version " ++ versionWithCommitInfo) "*Agda Version*" + Info_GoalSpecific ii kind -> lispifyGoalSpecificDisplayInfo ii kind + +lispifyGoalSpecificDisplayInfo :: InteractionId -> GoalDisplayInfo -> TCM [Lisp String] +lispifyGoalSpecificDisplayInfo ii kind = localTCState $ B.withInteractionId ii $ + case kind of + Goal_HelperFunction helperType -> do + doc <- inTopContext $ prettyATop helperType + return [ L [ A "agda2-info-action-and-copy" + , A $ quote "*Helper function*" + , A $ quote (render doc ++ "\n") + , A "nil" + ] + ] + Goal_NormalForm cmode expr -> do + doc <- showComputed cmode expr + format (render doc) "*Normal Form*" -- show? + Goal_GoalType norm aux ctx bndry constraints -> do + ctxDoc <- prettyResponseContext ii True ctx + goalDoc <- prettyTypeOfMeta norm ii + auxDoc <- case aux of + GoalOnly -> return empty + GoalAndHave expr -> do + doc <- prettyATop expr + return $ "Have:" <+> doc + GoalAndElaboration term -> do + doc <- TCP.prettyTCM term + return $ "Elaborates to:" <+> doc + let boundaryDoc + | null bndry = [] + | otherwise = [ text $ delimiter "Boundary" + , vcat $ map pretty bndry + ] + let constraintsDoc = if (null constraints) + then [] + else [ text $ delimiter "Constraints" + , vcat $ map pretty constraints + ] + let doc = vcat $ + [ "Goal:" <+> goalDoc + , auxDoc + , vcat boundaryDoc + , text (replicate 60 '\x2014') + , ctxDoc + ] ++ constraintsDoc + format (render doc) "*Goal type etc.*" + Goal_CurrentGoal norm -> do + doc <- prettyTypeOfMeta norm ii + format (render doc) "*Current Goal*" + Goal_InferredType expr -> do + doc <- prettyATop expr + format (render doc) "*Inferred Type*" + +-- | Format responses of DisplayInfo + +format :: String -> String -> TCM [Lisp String] +format content bufname = return [ display_info' False bufname content ] + -- | Adds a \"last\" tag to a response. lastTag :: Integer -> Lisp String -> Lisp String @@ -144,3 +253,197 @@ showNumIId :: InteractionId -> Lisp String showNumIId = A . show . interactionId + +-------------------------------------------------------------------------------- + +-- | Given strings of goals, warnings and errors, return a pair of the +-- body and the title for the info buffer +formatWarningsAndErrors :: String -> String -> String -> (String, String) +formatWarningsAndErrors g w e = (body, title) + where + isG = not $ null g + isW = not $ null w + isE = not $ null e + title = List.intercalate "," $ catMaybes + [ " Goals" <$ guard isG + , " Errors" <$ guard isE + , " Warnings" <$ guard isW + , " Done" <$ guard (not (isG || isW || isE)) + ] + + body = List.intercalate "\n" $ catMaybes + [ g <$ guard isG + , delimiter "Errors" <$ guard (isE && (isG || isW)) + , e <$ guard isE + , delimiter "Warnings" <$ guard (isW && (isG || isE)) + , w <$ guard isW + ] + + +-- | Serializing Info_Error +showInfoError :: Info_Error -> TCM String +showInfoError (Info_GenericError err) = do + e <- prettyError err + w <- prettyTCWarnings' =<< getAllWarningsOfTCErr err + + let errorMsg = if null w + then e + else delimiter "Error" ++ "\n" ++ e + let warningMsg = List.intercalate "\n" $ delimiter "Warning(s)" + : filter (not . null) w + return $ if null w + then errorMsg + else errorMsg ++ "\n\n" ++ warningMsg +showInfoError (Info_CompilationError warnings) = do + s <- prettyTCWarnings warnings + return $ unlines + [ "You need to fix the following errors before you can compile" + , "the module:" + , "" + , s + ] +showInfoError (Info_HighlightingParseError ii) = + return $ "Highlighting failed to parse expression in " ++ show ii +showInfoError (Info_HighlightingScopeCheckError ii) = + return $ "Highlighting failed to scope check expression in " ++ show ii + +explainWhyInScope :: FilePath + -> String + -> (Maybe LocalVar) + -> [AbstractName] + -> [AbstractModule] + -> TCM Doc +explainWhyInScope s _ Nothing [] [] = TCP.text (s ++ " is not in scope.") +explainWhyInScope s _ v xs ms = TCP.vcat + [ TCP.text (s ++ " is in scope as") + , TCP.nest 2 $ TCP.vcat [variable v xs, modules ms] + ] + where + -- variable :: Maybe _ -> [_] -> TCM Doc + variable Nothing vs = names vs + variable (Just x) vs + | null vs = asVar + | otherwise = TCP.vcat + [ TCP.sep [ asVar, TCP.nest 2 $ shadowing x] + , TCP.nest 2 $ names vs + ] + where + asVar :: TCM Doc + asVar = do + "* a variable bound at" TCP.<+> TCP.prettyTCM (nameBindingSite $ localVar x) + shadowing :: LocalVar -> TCM Doc + shadowing (LocalVar _ _ []) = "shadowing" + shadowing _ = "in conflict with" + names = TCP.vcat . map pName + modules = TCP.vcat . map pMod + + pKind = \case + ConName -> "constructor" + FldName -> "record field" + PatternSynName -> "pattern synonym" + GeneralizeName -> "generalizable variable" + DisallowedGeneralizeName -> "generalizable variable from let open" + MacroName -> "macro name" + QuotableName -> "quotable name" + -- previously DefName: + DataName -> "data type" + RecName -> "record type" + AxiomName -> "postulate" + PrimName -> "primitive function" + FunName -> "defined name" + OtherDefName -> "defined name" + + pName :: AbstractName -> TCM Doc + pName a = TCP.sep + [ "* a" + TCP.<+> pKind (anameKind a) + TCP.<+> TCP.text (prettyShow $ anameName a) + , TCP.nest 2 $ "brought into scope by" + ] TCP.$$ + TCP.nest 2 (pWhy (nameBindingSite $ qnameName $ anameName a) (anameLineage a)) + pMod :: AbstractModule -> TCM Doc + pMod a = TCP.sep + [ "* a module" TCP.<+> TCP.text (prettyShow $ amodName a) + , TCP.nest 2 $ "brought into scope by" + ] TCP.$$ + TCP.nest 2 (pWhy (nameBindingSite $ qnameName $ mnameToQName $ amodName a) (amodLineage a)) + + pWhy :: Range -> WhyInScope -> TCM Doc + pWhy r Defined = "- its definition at" TCP.<+> TCP.prettyTCM r + pWhy r (Opened (C.QName x) w) | isNoName x = pWhy r w + pWhy r (Opened m w) = + "- the opening of" + TCP.<+> TCP.prettyTCM m + TCP.<+> "at" + TCP.<+> TCP.prettyTCM (getRange m) + TCP.$$ + pWhy r w + pWhy r (Applied m w) = + "- the application of" + TCP.<+> TCP.prettyTCM m + TCP.<+> "at" + TCP.<+> TCP.prettyTCM (getRange m) + TCP.$$ + pWhy r w + + +-- | Pretty-prints the context of the given meta-variable. + +prettyResponseContext + :: InteractionId -- ^ Context of this meta-variable. + -> Bool -- ^ Print the elements in reverse order? + -> [ResponseContextEntry] + -> TCM Doc +prettyResponseContext ii rev ctx = withInteractionId ii $ do + mod <- asksTC getModality + align 10 . concat . applyWhen rev reverse <$> do + forM ctx $ \ (ResponseContextEntry n x (Arg ai expr) letv nis) -> do + let + prettyCtxName :: String + prettyCtxName + | n == x = prettyShow x + | isInScope n == InScope = prettyShow n ++ " = " ++ prettyShow x + | otherwise = prettyShow x + + -- Some attributes are useful to report whenever they are not + -- in the default state. + attribute :: String + attribute = c ++ if null c then "" else " " + where c = prettyShow (getCohesion ai) + + extras :: [Doc] + extras = concat $ + [ [ "not in scope" | isInScope nis == C.NotInScope ] + -- Print erased if hypothesis is erased by goal is non-erased. + , [ "erased" | not $ getQuantity ai `moreQuantity` getQuantity mod ] + -- Print irrelevant if hypothesis is strictly less relevant than goal. + , [ "irrelevant" | not $ getRelevance ai `moreRelevant` getRelevance mod ] + -- Print instance if variable is considered by instance search + , [ "instance" | isInstance ai ] + ] + ty <- prettyATop expr + maybeVal <- traverse prettyATop letv + + return $ + [ (attribute ++ prettyCtxName, ":" <+> ty <+> (parenSep extras)) ] ++ + [ (prettyShow x, "=" <+> val) | val <- maybeToList maybeVal ] + + where + parenSep :: [Doc] -> Doc + parenSep docs + | null docs = empty + | otherwise = (" " <+>) $ parens $ fsep $ punctuate comma docs + + +-- | Pretty-prints the type of the meta-variable. + +prettyTypeOfMeta :: Rewrite -> InteractionId -> TCM Doc +prettyTypeOfMeta norm ii = do + form <- B.typeOfMeta norm ii + case form of + OfType _ e -> prettyATop e + _ -> prettyATop form + +-- | Prefix prettified CPUTime with "Time:" +prettyTimed :: CPUTime -> Doc +prettyTimed time = "Time:" <+> pretty time diff --git a/src/full/Agda/Interaction/FindFile.hs b/src/full/Agda/Interaction/FindFile.hs --- a/src/full/Agda/Interaction/FindFile.hs +++ b/src/full/Agda/Interaction/FindFile.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} ------------------------------------------------------------------------ -- | Functions which map between module names and file names. -- @@ -8,10 +7,11 @@ ------------------------------------------------------------------------ module Agda.Interaction.FindFile - ( toIFile + ( SourceFile(..), InterfaceFile(intFilePath) + , toIFile, mkInterfaceFile , FindError(..), findErrorToTypeError , findFile, findFile', findFile'' - , findInterfaceFile + , findInterfaceFile', findInterfaceFile , checkModuleName , moduleName , rootNameModule @@ -20,7 +20,6 @@ import Prelude hiding (null) -import Control.Applicative hiding (empty) import Control.Monad import Control.Monad.Trans import qualified Data.List as List @@ -28,33 +27,62 @@ import qualified Data.Map as Map import System.FilePath -import Agda.Syntax.Common +import Agda.Interaction.Library ( findProjectRoot ) + import Agda.Syntax.Concrete import Agda.Syntax.Parser import Agda.Syntax.Parser.Literate (literateExtsShortList) import Agda.Syntax.Position +import Agda.Interaction.Options ( optLocalInterfaces ) + import Agda.TypeChecking.Monad.Base -import Agda.TypeChecking.Monad.Trace import Agda.TypeChecking.Monad.Benchmark (billTo) import qualified Agda.TypeChecking.Monad.Benchmark as Bench -import {-# SOURCE #-} Agda.TypeChecking.Monad.Options (getIncludeDirs) import Agda.TypeChecking.Warnings (runPM) +import Agda.Utils.Applicative ( (?$>) ) import Agda.Utils.Except import Agda.Utils.FileName -import Agda.Utils.Lens -import Agda.Utils.List ( stripSuffix ) -import Agda.Utils.Null - -#include "undefined.h" +import Agda.Utils.List ( stripSuffix, nubOn ) +import Agda.Utils.Monad ( ifM ) import Agda.Utils.Impossible +import Agda.Version ( version ) +-- | Type aliases for source files and interface files. +-- We may only produce one of these if we know for sure that the file +-- does exist. We can always output an @AbsolutePath@ if we are not sure. + +-- TODO: do not export @SourceFile@ and force users to check the +-- @AbsolutePath@ does exist. +newtype SourceFile = SourceFile { srcFilePath :: AbsolutePath } deriving (Eq, Ord) +newtype InterfaceFile = InterfaceFile { intFilePath :: AbsolutePath } + +-- | Makes an interface file from an AbsolutePath candidate. +-- If the file does not exist, then fail by returning @Nothing@. + +mkInterfaceFile + :: AbsolutePath -- ^ Path to the candidate interface file + -> IO (Maybe InterfaceFile) -- ^ Interface file iff it exists +mkInterfaceFile fp = do + ex <- doesFileExistCaseSensitive $ filePath fp + pure (ex ?$> InterfaceFile fp) + -- | Converts an Agda file name to the corresponding interface file --- name. +-- name. Note that we do not guarantee that the file exists. -toIFile :: AbsolutePath -> AbsolutePath -toIFile = replaceModuleExtension ".agdai" +toIFile :: SourceFile -> TCM AbsolutePath +toIFile (SourceFile src) = do + let fp = filePath src + mroot <- ifM (optLocalInterfaces <$> commandLineOptions) + {- then -} (pure Nothing) + {- else -} (liftIO $ findProjectRoot $ takeDirectory fp) + pure $ replaceModuleExtension ".agdai" $ case mroot of + Nothing -> src + Just root -> + let buildDir = root "_build" version "agda" + fileName = makeRelative root fp + in mkAbsolute $ buildDir fileName replaceModuleExtension :: String -> AbsolutePath -> AbsolutePath replaceModuleExtension ext@('.':_) = mkAbsolute . (++ ext) . dropAgdaExtension . filePath @@ -65,10 +93,10 @@ -- Invariant: All paths are absolute. data FindError - = NotFound [AbsolutePath] + = NotFound [SourceFile] -- ^ The file was not found. It should have had one of the given -- file names. - | Ambiguous [AbsolutePath] + | Ambiguous [SourceFile] -- ^ Several matching files were found. -- -- Invariant: The list of matching files has at least two @@ -78,16 +106,16 @@ -- converts a 'FindError' to a 'TypeError'. findErrorToTypeError :: TopLevelModuleName -> FindError -> TypeError -findErrorToTypeError m (NotFound files) = FileNotFound m files +findErrorToTypeError m (NotFound files) = FileNotFound m (map srcFilePath files) findErrorToTypeError m (Ambiguous files) = - AmbiguousTopLevelModuleName m files + AmbiguousTopLevelModuleName m (map srcFilePath files) -- | Finds the source file corresponding to a given top-level module -- name. The returned paths are absolute. -- -- Raises an error if the file cannot be found. -findFile :: TopLevelModuleName -> TCM AbsolutePath +findFile :: TopLevelModuleName -> TCM SourceFile findFile m = do mf <- findFile' m case mf of @@ -98,7 +126,7 @@ -- module name. The returned paths are absolute. -- -- SIDE EFFECT: Updates 'stModuleToSource'. -findFile' :: TopLevelModuleName -> TCM (Either FindError AbsolutePath) +findFile' :: TopLevelModuleName -> TCM (Either FindError SourceFile) findFile' m = do dirs <- getIncludeDirs modFile <- useTC stModuleToSource @@ -114,38 +142,45 @@ -> TopLevelModuleName -> ModuleToSource -- ^ Cached invocations of 'findFile'''. An updated copy is returned. - -> IO (Either FindError AbsolutePath, ModuleToSource) + -> IO (Either FindError SourceFile, ModuleToSource) findFile'' dirs m modFile = case Map.lookup m modFile of - Just f -> return (Right f, modFile) + Just f -> return (Right (SourceFile f), modFile) Nothing -> do - files <- fileList acceptableFileExts + files <- fileList acceptableFileExts filesShortList <- fileList parseFileExtsShortList - existingFiles <- - liftIO $ filterM (doesFileExistCaseSensitive . filePath) files - return $ case List.nub existingFiles of + existingFiles <- + liftIO $ filterM (doesFileExistCaseSensitive . filePath . srcFilePath) files + return $ case nubOn id existingFiles of [] -> (Left (NotFound filesShortList), modFile) - [file] -> (Right file, Map.insert m file modFile) + [file] -> (Right file, Map.insert m (srcFilePath file) modFile) files -> (Left (Ambiguous existingFiles), modFile) where - fileList exts = mapM absolute + fileList exts = mapM (fmap SourceFile . absolute) [ filePath dir file | dir <- dirs , file <- map (moduleNameToFileName m) exts ] -- | Finds the interface file corresponding to a given top-level --- module name. The returned paths are absolute. +-- module file. The returned paths are absolute. -- +-- Raises 'Nothing' if the the interface file cannot be found. + +findInterfaceFile' + :: SourceFile -- ^ Path to the source file + -> TCM (Maybe InterfaceFile) -- ^ Maybe path to the interface file +findInterfaceFile' fp = liftIO . mkInterfaceFile =<< toIFile fp + +-- | Finds the interface file corresponding to a given top-level +-- module file. The returned paths are absolute. +-- -- Raises an error if the source file cannot be found, and returns -- 'Nothing' if the source file can be found but not the interface -- file. -findInterfaceFile :: TopLevelModuleName -> TCM (Maybe AbsolutePath) -findInterfaceFile m = do - f <- toIFile <$> findFile m - ex <- liftIO $ doesFileExistCaseSensitive $ filePath f - return $ if ex then Just f else Nothing +findInterfaceFile :: TopLevelModuleName -> TCM (Maybe InterfaceFile) +findInterfaceFile m = findInterfaceFile' =<< findFile m -- | Ensures that the module name matches the file name. The file -- corresponding to the module name (according to the include path) @@ -154,23 +189,24 @@ checkModuleName :: TopLevelModuleName -- ^ The name of the module. - -> AbsolutePath + -> SourceFile -- ^ The file from which it was loaded. -> Maybe TopLevelModuleName -- ^ The expected name, coming from an import statement. -> TCM () -checkModuleName name file mexpected = +checkModuleName name (SourceFile file) mexpected = findFile' name >>= \case Left (NotFound files) -> typeError $ case mexpected of - Nothing -> ModuleNameDoesntMatchFileName name files + Nothing -> ModuleNameDoesntMatchFileName name (map srcFilePath files) Just expected -> ModuleNameUnexpected name expected Left (Ambiguous files) -> typeError $ - AmbiguousTopLevelModuleName name files + AmbiguousTopLevelModuleName name (map srcFilePath files) - Right file' -> do + Right src -> do + let file' = srcFilePath src file <- liftIO $ absolute (filePath file) if file === file' then return () diff --git a/src/full/Agda/Interaction/FindFile.hs-boot b/src/full/Agda/Interaction/FindFile.hs-boot deleted file mode 100644 --- a/src/full/Agda/Interaction/FindFile.hs-boot +++ /dev/null @@ -1,9 +0,0 @@ -module Agda.Interaction.FindFile where - -import Agda.Syntax.Concrete (Module) -import Agda.Syntax.Concrete.Name (TopLevelModuleName) -import Agda.TypeChecking.Monad.Base (TCM) -import Agda.Utils.FileName (AbsolutePath) - -moduleName :: AbsolutePath -> Module -> TCM TopLevelModuleName -checkModuleName :: TopLevelModuleName -> AbsolutePath -> Maybe TopLevelModuleName -> TCM () diff --git a/src/full/Agda/Interaction/Highlighting/Common.hs b/src/full/Agda/Interaction/Highlighting/Common.hs --- a/src/full/Agda/Interaction/Highlighting/Common.hs +++ b/src/full/Agda/Interaction/Highlighting/Common.hs @@ -5,7 +5,6 @@ , chooseHighlightingMethod ) where -import Agda.Interaction.Options import Agda.Interaction.Highlighting.Precise import Agda.Syntax.Common import Agda.TypeChecking.Monad (HighlightingMethod(..)) diff --git a/src/full/Agda/Interaction/Highlighting/Dot.hs b/src/full/Agda/Interaction/Highlighting/Dot.hs --- a/src/full/Agda/Interaction/Highlighting/Dot.hs +++ b/src/full/Agda/Interaction/Highlighting/Dot.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} -- | Generate an import dependency graph for a given module. @@ -9,7 +8,6 @@ import qualified Data.Map as M import Data.Map(Map) import Data.Maybe -import Data.Monoid import qualified Data.Set as S import Data.Set (Set) @@ -18,7 +16,6 @@ import Agda.Syntax.Abstract import Agda.TypeChecking.Monad -#include "undefined.h" import Agda.Utils.Impossible -- | Internal module identifiers for construction of dependency graph. diff --git a/src/full/Agda/Interaction/Highlighting/Emacs.hs b/src/full/Agda/Interaction/Highlighting/Emacs.hs --- a/src/full/Agda/Interaction/Highlighting/Emacs.hs +++ b/src/full/Agda/Interaction/Highlighting/Emacs.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} -- | Functions which give precise syntax highlighting info to Emacs. @@ -21,7 +20,6 @@ import qualified Data.Map as Map import Data.Maybe -#include "undefined.h" import Agda.Utils.Impossible ------------------------------------------------------------------------ diff --git a/src/full/Agda/Interaction/Highlighting/Generate.hs b/src/full/Agda/Interaction/Highlighting/Generate.hs --- a/src/full/Agda/Interaction/Highlighting/Generate.hs +++ b/src/full/Agda/Interaction/Highlighting/Generate.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} -- | Generates data used for precise syntax highlighting. @@ -12,7 +11,7 @@ , printUnsolvedInfo , printHighlightingInfo , highlightAsTypeChecked - , warningHighlighting + , highlightWarning, warningHighlighting , computeUnsolvedMetaWarnings , computeUnsolvedConstraints , storeDisambiguatedName, disambiguateRecordFields @@ -21,33 +20,33 @@ import Prelude hiding (null) import Control.Monad -import Control.Monad.Trans -import Control.Monad.Reader import Control.Arrow (second) -import Data.Monoid import Data.Generics.Geniplate import qualified Data.Map as Map import Data.Maybe -import Data.List ((\\), isPrefixOf) +import Data.List ((\\)) import qualified Data.List as List import qualified Data.Foldable as Fold (fold, foldMap, toList) import qualified Data.IntMap as IntMap +import Data.HashMap.Strict (HashMap) +import qualified Data.HashMap.Strict as HMap import Data.Sequence (Seq) import qualified Data.Set as Set import qualified Data.Text.Lazy as T import Data.Void -import Agda.Interaction.Response (Response(Resp_HighlightingInfo)) -import Agda.Interaction.Highlighting.Precise -import Agda.Interaction.Highlighting.Range import Agda.Interaction.Response - (RemoveTokenBasedHighlighting(KeepHighlighting)) + ( Response( Resp_HighlightingInfo ) + , RemoveTokenBasedHighlighting( KeepHighlighting ) + ) +import Agda.Interaction.Highlighting.Precise as P +import Agda.Interaction.Highlighting.Range (rToR, minus) -- Range is ambiguous import qualified Agda.TypeChecking.Errors as E import Agda.TypeChecking.MetaVars (isBlockedTerm) import Agda.TypeChecking.Monad - hiding (MetaInfo, Primitive, Constructor, Record, Function, Datatype) + hiding (ModuleInfo, MetaInfo, Primitive, Constructor, Record, Function, Datatype) import qualified Agda.TypeChecking.Monad as M import Agda.TypeChecking.Positivity.Occurrence import Agda.TypeChecking.Warnings (runPM) @@ -55,19 +54,18 @@ import Agda.Syntax.Abstract (IsProjP(..)) import qualified Agda.Syntax.Abstract as A import Agda.Syntax.Concrete (FieldAssignment'(..)) -import Agda.Syntax.Concrete.Definitions ( DeclarationWarning(..) ) +import Agda.Syntax.Concrete.Definitions as W ( DeclarationWarning(..) ) import qualified Agda.Syntax.Common as Common import qualified Agda.Syntax.Concrete.Name as C -import qualified Agda.Syntax.Concrete as C import Agda.Syntax.Fixity import Agda.Syntax.Notation -import qualified Agda.Syntax.Info as SI +import Agda.Syntax.Info ( ModuleInfo(..), defMacro ) import qualified Agda.Syntax.Internal as I import qualified Agda.Syntax.Literal as L import qualified Agda.Syntax.Parser as Pa import qualified Agda.Syntax.Parser.Tokens as T import qualified Agda.Syntax.Position as P -import Agda.Syntax.Position (getRange) +import Agda.Syntax.Position (Range, HasRange, getRange, noRange) import Agda.Utils.FileName import Agda.Utils.Function @@ -78,67 +76,9 @@ import qualified Agda.Utils.Maybe.Strict as Strict import Agda.Utils.Null import Agda.Utils.Pretty -import Agda.Utils.HashMap (HashMap) -import qualified Agda.Utils.HashMap as HMap -#include "undefined.h" import Agda.Utils.Impossible --- | @highlightAsTypeChecked rPre r m@ runs @m@ and returns its --- result. Additionally, some code may be highlighted: --- --- * If @r@ is non-empty and not a sub-range of @rPre@ (after --- 'P.continuousPerLine' has been applied to both): @r@ is --- highlighted as being type-checked while @m@ is running (this --- highlighting is removed if @m@ completes /successfully/). --- --- * Otherwise: Highlighting is removed for @rPre - r@ before @m@ --- runs, and if @m@ completes successfully, then @rPre - r@ is --- highlighted as being type-checked. - -highlightAsTypeChecked - :: MonadTCM tcm - => P.Range - -> P.Range - -> tcm a - -> tcm a -highlightAsTypeChecked rPre r m - | r /= P.noRange && delta == rPre' = wrap r' highlight clear - | otherwise = wrap delta clear highlight - where - rPre' = rToR (P.continuousPerLine rPre) - r' = rToR (P.continuousPerLine r) - delta = rPre' `minus` r' - clear = mempty - highlight = parserBased { otherAspects = Set.singleton TypeChecks } - - wrap rs x y = do - p rs x - v <- m - p rs y - return v - where - p rs x = printHighlightingInfo KeepHighlighting (singletonC rs x) - --- | Lispify and print the given highlighting information. - -printHighlightingInfo :: - MonadTCM tcm => - RemoveTokenBasedHighlighting -> - HighlightingInfo -> - tcm () -printHighlightingInfo remove info = do - modToSrc <- useTC stModuleToSource - method <- viewTC eHighlightingMethod - liftTCM $ reportSLn "highlighting" 50 $ unlines - [ "Printing highlighting info:" - , show info - , " modToSrc = " ++ show modToSrc - ] - unless (null $ ranges info) $ do - liftTCM $ appInteractionOutputCallback $ - Resp_HighlightingInfo info remove method modToSrc - -- | Highlighting levels. data Level @@ -149,6 +89,14 @@ -- ^ Highlighting without disambiguation of overloaded -- constructors. +-- | Highlight a warning. +highlightWarning :: TCWarning -> TCM () +highlightWarning tcwarn = do + let h = compress $ warningHighlighting tcwarn + modifyTCLens stSyntaxInfo (h <>) + ifTopLevelAndHighlightingLevelIs NonInteractive $ + printHighlightingInfo KeepHighlighting h + -- | Generate syntax highlighting information for the given -- declaration, and (if appropriate) print it. If the boolean is -- 'True', then the state is additionally updated with the new @@ -166,7 +114,7 @@ -> Bool -- ^ Update the state? -> TCM () -generateAndPrintSyntaxInfo decl _ _ | null $ P.getRange decl = return () +generateAndPrintSyntaxInfo decl _ _ | null $ getRange decl = return () generateAndPrintSyntaxInfo decl hlLevel updateState = do file <- getCurrentPath @@ -185,8 +133,11 @@ let nameInfo = mconcat $ map (generate modMap file kinds) names - -- Constructors are only highlighted after type checking, since they - -- can be overloaded. + -- After the code has been type checked more information may be + -- available for overloaded constructors, and + -- generateConstructorInfo takes advantage of this information. + -- Note, however, that highlighting for overloaded constructors is + -- included also in nameInfo. constructorInfo <- case hlLevel of Full{} -> generateConstructorInfo modMap file kinds decl _ -> return mempty @@ -194,10 +145,7 @@ cm <- P.rangeFile <$> viewTC eRange reportSLn "highlighting.warning" 60 $ "current path = " ++ show cm - warnInfo <- Fold.foldMap warningHighlighting - . filter ((cm ==) . tcWarningOrigin) <$> useTC stTCWarnings - - let (from, to) = case P.rangeToInterval (P.getRange decl) of + let (from, to) = case P.rangeToInterval (getRange decl) of Nothing -> __IMPOSSIBLE__ Just i -> ( fromIntegral $ P.posPos $ P.iStart i , fromIntegral $ P.posPos $ P.iEnd i) @@ -213,7 +161,6 @@ let syntaxInfo = compress (mconcat [ constructorInfo , theRest modMap file , nameInfo - , warnInfo ]) `mappend` curTokens @@ -234,7 +181,8 @@ universeBi decl -- Bound variables, dotted patterns, record fields, module names, - -- the "as" and "to" symbols. + -- the "as" and "to" symbols and some other things. + theRest :: SourceToModule -> AbsolutePath -> File theRest modMap file = mconcat [ Fold.foldMap getFieldDecl $ universeBi decl , Fold.foldMap getVarAndField $ universeBi decl @@ -251,10 +199,12 @@ , Fold.foldMap getNamedArgP $ universeBi decl , Fold.foldMap getNamedArgB $ universeBi decl , Fold.foldMap getNamedArgL $ universeBi decl + , Fold.foldMap getQuantityAttr$ universeBi decl + , Fold.foldMap getPragma $ universeBi decl ] where - bound (A.BindName n) = - nameToFile modMap file [] (A.nameConcrete n) P.noRange + bound A.BindName{ unBind = n } = + nameToFile modMap file [] (A.nameConcrete n) noRange (\isOp -> parserBased { aspect = Just $ Name (Just Bound) isOp }) (Just $ A.nameBindingSite n) @@ -268,12 +218,14 @@ parserBased { aspect = Just $ Name (Just Macro) isOp } field :: [C.Name] -> C.Name -> File - field m n = nameToFile modMap file m n P.noRange + field m n = nameToFile modMap file m n noRange (\isOp -> parserBased { aspect = Just $ Name (Just Field) isOp }) Nothing + + asName :: C.Name -> File asName n = nameToFile modMap file [] - n P.noRange + n noRange (\isOp -> parserBased { aspect = Just $ Name (Just Module) isOp }) Nothing @@ -283,14 +235,14 @@ -- which defines this module. mod isTopLevelModule n = nameToFile modMap file [] - (A.nameConcrete n) P.noRange + (A.nameConcrete n) noRange (\isOp -> parserBased { aspect = Just $ Name (Just Module) isOp }) (Just $ applyWhen isTopLevelModule P.beginningOfFile $ A.nameBindingSite n) getVarAndField :: A.Expr -> File - getVarAndField (A.Var x) = bound $ A.BindName x + getVarAndField (A.Var x) = bound $ A.mkBindName x -- Andreas, 2018-06-09, issue #3120 -- The highlighting for record field tags is now created by the type checker in -- function disambiguateRecordFields. @@ -314,9 +266,12 @@ getNamedArg :: Common.NamedArg a -> File getNamedArg x = caseMaybe (Common.nameOf $ Common.unArg x) mempty $ \ s -> - singleton (rToR $ P.getRange s) $ + singleton (rToR $ getRange s) $ parserBased { aspect = Just $ Name (Just Argument) False } + getBinder :: A.Binder -> File + getBinder (A.Binder _ n) = bound n + getLet :: A.LetBinding -> File getLet (A.LetBind _ _ x _ _) = bound x getLet A.LetPatBind{} = mempty @@ -325,24 +280,44 @@ getLet (A.LetDeclaredVariable x) = bound x getLam :: A.LamBinding -> File - getLam (A.DomainFree x) = bound $ Common.namedArg x - getLam (A.DomainFull {}) = mempty + getLam (A.DomainFree _ xs) = getBinder (Common.namedArg xs) + getLam (A.DomainFull {}) = mempty getTyped :: A.TypedBinding -> File - getTyped (A.TBind _ xs _) = mconcat $ map (bound . Common.namedArg) xs - getTyped A.TLet{} = mempty + getTyped (A.TBind _ _ xs _) = Fold.foldMap (getBinder . Common.namedArg) xs + getTyped A.TLet{} = mempty getPatSynArgs :: A.Declaration -> File - getPatSynArgs (A.PatternSynDef _ xs _) = mconcat $ map (bound . A.BindName . Common.unArg) xs + getPatSynArgs (A.PatternSynDef _ xs _) = mconcat $ map (bound . A.mkBindName . Common.unArg) xs getPatSynArgs _ = mempty + -- Issue #4361, highlight BUILTINs like NAT, EQUALITY etc. in keyword color. + getPragma :: A.Declaration -> File + getPragma = \case + A.Pragma _ p -> + case p of + A.BuiltinPragma b _ -> keyword b + A.BuiltinNoDefPragma b _ -> keyword b + A.CompilePragma b _ _ -> keyword b + A.RewritePragma r _ -> keyword r + A.OptionsPragma{} -> mempty + A.StaticPragma{} -> mempty + A.EtaPragma{} -> mempty + A.InjectivePragma{} -> mempty + A.InlinePragma{} -> mempty + A.DisplayPragma{} -> mempty + _ -> mempty + + keyword :: HasRange a => a -> File + keyword x = singleton (rToR $ getRange x) $ parserBased { aspect = Just Keyword } + getPattern' :: IsProjP e => A.Pattern' e -> File getPattern' (A.VarP x) = bound x getPattern' (A.AsP _ x _) = bound x getPattern' (A.DotP pi e) | Just _ <- isProjP e = mempty | otherwise = - singleton (rToR $ P.getRange pi) + singleton (rToR $ getRange pi) (parserBased { otherAspects = Set.singleton DottedPattern }) getPattern' (A.PatternSynP _ q _) = patsyn q -- Andreas, 2018-06-09, issue #3120 @@ -387,13 +362,17 @@ Just (C.toTopLevelModuleName $ A.mnameToConcrete m) [] -> False - getModuleInfo :: SI.ModuleInfo -> File - getModuleInfo (SI.ModuleInfo { SI.minfoAsTo = asTo - , SI.minfoAsName = name }) = - singleton (rToR asTo) (parserBased { aspect = Just Symbol }) + getModuleInfo :: ModuleInfo -> File + getModuleInfo (ModuleInfo{ minfoAsTo, minfoAsName }) = + singleton (rToR minfoAsTo) (parserBased { aspect = Just Symbol }) `mappend` - maybe mempty asName name + maybe mempty asName minfoAsName + -- If the Quantity attribute comes with a Range, highlight the + -- corresponding attribute as Symbol. + getQuantityAttr :: Common.Quantity -> File + getQuantityAttr q = singleton (rToR $ getRange q) (parserBased { aspect = Just Symbol }) + -- | Generate and return the syntax highlighting information for the -- tokens in the given file. @@ -419,8 +398,8 @@ -- tokens in the given string, which is assumed to correspond to the -- given range. -generateTokenInfoFromString :: P.Range -> String -> TCM CompressedFile -generateTokenInfoFromString r _ | r == P.noRange = return mempty +generateTokenInfoFromString :: Range -> String -> TCM CompressedFile +generateTokenInfoFromString r _ | r == noRange = return mempty generateTokenInfoFromString r s = do runPM $ tokenHighlighting <$> Pa.parsePosString Pa.tokensParser p s where @@ -437,13 +416,14 @@ merge = CompressedFile . concat . map ranges tokenToCFile :: T.Token -> CompressedFile - tokenToCFile (T.TokSetN (i, _)) = aToF PrimitiveType (P.getRange i) - tokenToCFile (T.TokPropN (i, _)) = aToF PrimitiveType (P.getRange i) - tokenToCFile (T.TokKeyword T.KwSet i) = aToF PrimitiveType (P.getRange i) - tokenToCFile (T.TokKeyword T.KwProp i) = aToF PrimitiveType (P.getRange i) - tokenToCFile (T.TokKeyword T.KwForall i) = aToF Symbol (P.getRange i) - tokenToCFile (T.TokKeyword _ i) = aToF Keyword (P.getRange i) - tokenToCFile (T.TokSymbol _ i) = aToF Symbol (P.getRange i) + tokenToCFile (T.TokSetN (i, _)) = aToF PrimitiveType (getRange i) + tokenToCFile (T.TokPropN (i, _)) = aToF PrimitiveType (getRange i) + tokenToCFile (T.TokKeyword T.KwSet i) = aToF PrimitiveType (getRange i) + tokenToCFile (T.TokKeyword T.KwProp i) = aToF PrimitiveType (getRange i) + tokenToCFile (T.TokKeyword T.KwForall i) = aToF Symbol (getRange i) + tokenToCFile (T.TokKeyword T.KwREWRITE _) = mempty -- #4361, REWRITE is not always a Keyword + tokenToCFile (T.TokKeyword _ i) = aToF Keyword (getRange i) + tokenToCFile (T.TokSymbol _ i) = aToF Symbol (getRange i) tokenToCFile (T.TokLiteral (L.LitNat r _)) = aToF Number r tokenToCFile (T.TokLiteral (L.LitWord64 r _)) = aToF Number r tokenToCFile (T.TokLiteral (L.LitFloat r _)) = aToF Number r @@ -451,12 +431,12 @@ tokenToCFile (T.TokLiteral (L.LitChar r _)) = aToF String r tokenToCFile (T.TokLiteral (L.LitQName r _)) = aToF String r tokenToCFile (T.TokLiteral (L.LitMeta r _ _)) = aToF String r - tokenToCFile (T.TokComment (i, _)) = aToF Comment (P.getRange i) - tokenToCFile (T.TokTeX (i, _)) = aToF Background (P.getRange i) - tokenToCFile (T.TokMarkup (i, _)) = aToF Markup (P.getRange i) + tokenToCFile (T.TokComment (i, _)) = aToF Comment (getRange i) + tokenToCFile (T.TokTeX (i, _)) = aToF Background (getRange i) + tokenToCFile (T.TokMarkup (i, _)) = aToF Markup (getRange i) tokenToCFile (T.TokId {}) = mempty tokenToCFile (T.TokQId {}) = mempty - tokenToCFile (T.TokString (i,s)) = aToF Pragma (P.getRange i) + tokenToCFile (T.TokString (i,s)) = aToF Pragma (getRange i) tokenToCFile (T.TokDummy {}) = mempty tokenToCFile (T.TokEOF {}) = mempty @@ -473,17 +453,25 @@ -> A.Declaration -> TCM NameKinds nameKinds hlLevel decl = do - imported <- fix <$> useTC stImports + imported <- useTC $ stImports . sigDefinitions local <- case hlLevel of - Full{} -> fix <$> useTC stSignature + Full{} -> useTC $ stSignature . sigDefinitions _ -> return HMap.empty + impPatSyns <- useTC stPatternSynImports + locPatSyns <- case hlLevel of + Full{} -> useTC stPatternSyns + _ -> return empty -- Traverses the syntax tree and constructs a map from qualified -- names to name kinds. TODO: Handle open public. let syntax = foldr ($) HMap.empty $ map declToKind $ universeBi decl - let merged = unions [local, imported, syntax] - return (\n -> HMap.lookup n merged) + return $ \ n -> unionsMaybeWith merge + [ defnToKind . theDef <$> HMap.lookup n local + , con <$ Map.lookup n locPatSyns + , defnToKind . theDef <$> HMap.lookup n imported + , con <$ Map.lookup n impPatSyns + , HMap.lookup n syntax + ] where - fix = HMap.map (defnToKind . theDef) . (^. sigDefinitions) -- | The 'M.Axiom' constructor is used to represent various things -- which are not really axioms, so when maps are merged 'Postulate's @@ -494,7 +482,6 @@ merge _ Macro = Macro -- If the abstract syntax says macro, it's a macro. merge k _ = k - unions = foldr (HMap.unionWith merge) HMap.empty insert = HMap.insertWith merge defnToKind :: Defn -> NameKind @@ -512,8 +499,8 @@ declToKind :: A.Declaration -> HashMap A.QName NameKind -> HashMap A.QName NameKind declToKind (A.Axiom _ i _ _ q _) - | SI.defMacro i == Common.MacroDef = insert q Macro - | otherwise = insert q Postulate + | defMacro i == Common.MacroDef = insert q Macro + | otherwise = insert q Postulate declToKind (A.Field _ q _) = insert q Field -- Function -- Note that the name q can be used both as a field name and as a -- projection function. Highlighting of field names is taken care @@ -526,7 +513,7 @@ declToKind (A.Pragma {}) = id declToKind (A.ScopedDecl {}) = id declToKind (A.Open {}) = id - declToKind (A.PatternSynDef q _ _) = insert q (Constructor Common.Inductive) + declToKind (A.PatternSynDef q _ _) = insert q con declToKind (A.Generalize _ _ _ q _) = insert q Generalizable declToKind (A.FunDef _ q _ _) = insert q Function declToKind (A.UnquoteDecl _ _ qs _) = foldr (\ q f -> insert q Function . f) id qs @@ -534,15 +521,14 @@ declToKind (A.DataSig _ q _ _) = insert q Datatype declToKind (A.DataDef _ q _ _ cs) = \m -> insert q Datatype $ - foldr (\d -> insert (A.axiomName d) - (Constructor Common.Inductive)) + foldr (\d -> insert (A.axiomName d) con) m cs declToKind (A.RecSig _ q _ _) = insert q Record - declToKind (A.RecDef _ q _ _ _ c _ _ _) = insert q Record . - case c of - Nothing -> id - Just q -> insert q (Constructor Common.Inductive) + declToKind (A.RecDef _ q _ _ _ c _ _ _) = insert q Record . maybe id (`insert` con) c + con :: NameKind + con = Constructor Common.Inductive + -- | Generates syntax highlighting information for all constructors -- occurring in patterns and expressions in the given declaration. -- @@ -561,7 +547,7 @@ -- Get boundaries of current declaration. -- @noRange@ should be impossible, but in case of @noRange@ -- it makes sense to return the empty File. - ifNull (P.rangeIntervals $ P.getRange decl) + ifNull (P.rangeIntervals $ getRange decl) (return mempty) $ \is -> do let start = fromIntegral $ P.posPos $ P.iStart $ head is end = fromIntegral $ P.posPos $ P.iEnd $ last is @@ -576,7 +562,7 @@ let files = for constrs $ \ q -> generate modMap file kinds $ I.unambiguous q return $ Fold.fold files -printSyntaxInfo :: P.Range -> TCM () +printSyntaxInfo :: Range -> TCM () printSyntaxInfo r = do syntaxInfo <- useTC stSyntaxInfo ifTopLevelAndHighlightingLevelIs NonInteractive $ @@ -590,13 +576,12 @@ errorHighlighting e -- | Generate highlighting for error. --- Does something special for termination errors. errorHighlighting :: TCErr -> TCM File errorHighlighting e = do -- Erase previous highlighting. - let r = P.getRange e + let r = getRange e erase = singleton (rToR $ P.continuousPerLine r) mempty -- Print new highlighting. @@ -613,23 +598,29 @@ warningHighlighting w = case tcWarning w of TerminationIssue terrs -> terminationErrorHighlighting terrs NotStrictlyPositive d ocs -> positivityErrorHighlighting d ocs - UnreachableClauses{} -> deadcodeHighlighting $ P.getRange w - CoverageIssue{} -> coverageErrorHighlighting $ P.getRange w - CoverageNoExactSplit{} -> catchallHighlighting $ P.getRange w + -- #3965 highlight each unreachable clause independently: they + -- may be interleaved with actually reachable clauses! + UnreachableClauses _ rs -> Fold.foldMap deadcodeHighlighting rs + CoverageIssue{} -> coverageErrorHighlighting $ getRange w + CoverageNoExactSplit{} -> catchallHighlighting $ getRange w UnsolvedConstraints cs -> constraintsHighlighting cs UnsolvedMetaVariables rs -> metasHighlighting rs - AbsurdPatternRequiresNoRHS{} -> deadcodeHighlighting $ P.getRange w - ModuleDoesntExport{} -> deadcodeHighlighting $ P.getRange w + AbsurdPatternRequiresNoRHS{} -> deadcodeHighlighting $ getRange w + ModuleDoesntExport{} -> deadcodeHighlighting $ getRange w + FixityInRenamingModule rs -> Fold.foldMap deadcodeHighlighting rs -- expanded catch-all case to get a warning for new constructors CantGeneralizeOverSorts{} -> mempty UnsolvedInteractionMetas{} -> mempty OldBuiltin{} -> mempty - EmptyRewritePragma{} -> deadcodeHighlighting $ P.getRange w - IllformedAsClause{} -> deadcodeHighlighting $ P.getRange w - UselessPublic{} -> mempty + EmptyRewritePragma{} -> deadcodeHighlighting $ getRange w + IllformedAsClause{} -> deadcodeHighlighting $ getRange w + UselessPublic{} -> deadcodeHighlighting $ getRange w UselessInline{} -> mempty + ClashesViaRenaming _ xs -> Fold.foldMap (deadcodeHighlighting . getRange) xs + -- #4154, TODO: clashing renamings are not dead code, but introduce problems. + -- Should we have a different color? WrongInstanceDeclaration{} -> mempty - InstanceWithExplicitArg{} -> deadcodeHighlighting $ P.getRange w + InstanceWithExplicitArg{} -> deadcodeHighlighting $ getRange w InstanceNoOutputTypeName{} -> mempty InstanceArgWithExplicitArg{} -> mempty ParseWarning{} -> mempty @@ -641,6 +632,9 @@ SafeFlagNonTerminating -> mempty SafeFlagTerminating -> mempty SafeFlagWithoutKFlagPrimEraseEquality -> mempty + SafeFlagEta -> mempty + SafeFlagInjective -> mempty + SafeFlagNoCoverageCheck -> mempty WithoutKFlagPrimEraseEquality -> mempty SafeFlagNoPositivityCheck -> mempty SafeFlagPolarity -> mempty @@ -650,34 +644,45 @@ LibraryWarning{} -> mempty InfectiveImport{} -> mempty CoInfectiveImport{} -> mempty + RewriteNonConfluent{} -> confluenceErrorHighlighting $ getRange w + RewriteMaybeNonConfluent{} -> confluenceErrorHighlighting $ getRange w + PragmaCompileErased{} -> deadcodeHighlighting $ getRange w + NotInScopeW{} -> deadcodeHighlighting $ getRange w NicifierIssue w -> case w of -- we intentionally override the binding of `w` here so that our pattern of - -- using `P.getRange w` still yields the most precise range information we + -- using `getRange w` still yields the most precise range information we -- can get. - NotAllowedInMutual{} -> deadcodeHighlighting $ P.getRange w - EmptyAbstract{} -> deadcodeHighlighting $ P.getRange w - EmptyInstance{} -> deadcodeHighlighting $ P.getRange w - EmptyMacro{} -> deadcodeHighlighting $ P.getRange w - EmptyMutual{} -> deadcodeHighlighting $ P.getRange w - EmptyPostulate{} -> deadcodeHighlighting $ P.getRange w - EmptyPrivate{} -> deadcodeHighlighting $ P.getRange w - EmptyGeneralize{} -> deadcodeHighlighting $ P.getRange w - UselessAbstract{} -> deadcodeHighlighting $ P.getRange w - UselessInstance{} -> deadcodeHighlighting $ P.getRange w - UselessPrivate{} -> deadcodeHighlighting $ P.getRange w + NotAllowedInMutual{} -> deadcodeHighlighting $ getRange w + EmptyAbstract{} -> deadcodeHighlighting $ getRange w + EmptyInstance{} -> deadcodeHighlighting $ getRange w + EmptyMacro{} -> deadcodeHighlighting $ getRange w + EmptyMutual{} -> deadcodeHighlighting $ getRange w + EmptyPostulate{} -> deadcodeHighlighting $ getRange w + EmptyPrimitive{} -> deadcodeHighlighting $ getRange w + EmptyPrivate{} -> deadcodeHighlighting $ getRange w + EmptyGeneralize{} -> deadcodeHighlighting $ getRange w + EmptyField{} -> deadcodeHighlighting $ getRange w + UselessAbstract{} -> deadcodeHighlighting $ getRange w + UselessInstance{} -> deadcodeHighlighting $ getRange w + UselessPrivate{} -> deadcodeHighlighting $ getRange w + InvalidNoPositivityCheckPragma{} -> deadcodeHighlighting $ getRange w + InvalidNoUniverseCheckPragma{} -> deadcodeHighlighting $ getRange w + InvalidTerminationCheckPragma{} -> deadcodeHighlighting $ getRange w + InvalidCoverageCheckPragma{} -> deadcodeHighlighting $ getRange w + OpenPublicAbstract{} -> deadcodeHighlighting $ getRange w + OpenPublicPrivate{} -> deadcodeHighlighting $ getRange w + W.ShadowingInTelescope nrs -> Fold.foldMap + (shadowingTelHighlighting . snd) + nrs + MissingDefinitions{} -> missingDefinitionHighlighting $ getRange w -- TODO: explore highlighting opportunities here! - EmptyPrimitive{} -> mempty - InvalidCatchallPragma{} -> mempty - InvalidNoPositivityCheckPragma{} -> mempty - InvalidNoUniverseCheckPragma{} -> mempty - InvalidTerminationCheckPragma{} -> mempty - MissingDefinitions{} -> mempty + InvalidCatchallPragma{} -> mempty PolarityPragmasButNotPostulates{} -> mempty - PragmaNoTerminationCheck{} -> mempty - PragmaCompiled{} -> mempty - UnknownFixityInMixfixDecl{} -> mempty - UnknownNamesInFixityDecl{} -> mempty - UnknownNamesInPolarityPragmas{} -> mempty + PragmaNoTerminationCheck{} -> mempty + PragmaCompiled{} -> mempty + UnknownFixityInMixfixDecl{} -> mempty + UnknownNamesInFixityDecl{} -> mempty + UnknownNamesInPolarityPragmas{} -> mempty -- | Generate syntax highlighting for termination errors. @@ -694,28 +699,42 @@ -- | Generate syntax highlighting for not-strictly-positive inductive -- definitions. --- TODO: highlight also the problematic occurrences positivityErrorHighlighting :: I.QName -> Seq OccursWhere -> File positivityErrorHighlighting q os = - several (rToR <$> P.getRange q : rs) m + several (rToR <$> getRange q : rs) m where rs = map (\(OccursWhere r _ _) -> r) (Fold.toList os) m = parserBased { otherAspects = Set.singleton PositivityProblem } -deadcodeHighlighting :: P.Range -> File -deadcodeHighlighting r = singleton (rToR $ P.continuousPerLine r) m +deadcodeHighlighting :: Range -> File +deadcodeHighlighting r = singleton (rToR $ P.continuous r) m where m = parserBased { otherAspects = Set.singleton Deadcode } -coverageErrorHighlighting :: P.Range -> File +coverageErrorHighlighting :: Range -> File coverageErrorHighlighting r = singleton (rToR $ P.continuousPerLine r) m where m = parserBased { otherAspects = Set.singleton CoverageProblem } +shadowingTelHighlighting :: [Range] -> File +shadowingTelHighlighting = + -- we do not want to highlight the one variable in scope so we take + -- the @init@ segment of the ranges in question + Fold.foldMap (\r -> singleton (rToR $ P.continuous r) m) . init + where + m = parserBased { otherAspects = + Set.singleton P.ShadowingInTelescope } -catchallHighlighting :: P.Range -> File +catchallHighlighting :: Range -> File catchallHighlighting r = singleton (rToR $ P.continuousPerLine r) m where m = parserBased { otherAspects = Set.singleton CatchallClause } +confluenceErrorHighlighting :: Range -> File +confluenceErrorHighlighting r = singleton (rToR $ P.continuousPerLine r) m + where m = parserBased { otherAspects = Set.singleton ConfluenceProblem } +missingDefinitionHighlighting :: Range -> File +missingDefinitionHighlighting r = singleton (rToR $ P.continuousPerLine r) m + where m = parserBased { otherAspects = Set.singleton MissingDefinition } + -- | Generates and prints syntax highlighting information for unsolved -- meta-variables and certain unsolved constraints. @@ -743,7 +762,7 @@ rs <- mapM getMetaRange (ms \\ is) return $ metasHighlighting rs -metasHighlighting :: [P.Range] -> File +metasHighlighting :: [Range] -> File metasHighlighting rs = several (map (rToR . P.continuousPerLine) rs) $ parserBased { otherAspects = Set.singleton UnsolvedMeta } @@ -763,7 +782,6 @@ Closure{ clValue = IsEmpty r t } -> Just r Closure{ clEnv = e, clValue = ValueCmp{} } -> Just $ getRange (envRange e) Closure{ clEnv = e, clValue = ElimCmp{} } -> Just $ getRange (envRange e) - Closure{ clEnv = e, clValue = TypeCmp{} } -> Just $ getRange (envRange e) Closure{ clEnv = e, clValue = TelCmp{} } -> Just $ getRange (envRange e) Closure{ clEnv = e, clValue = SortCmp{} } -> Just $ getRange (envRange e) Closure{ clEnv = e, clValue = LevelCmp{} } -> Just $ getRange (envRange e) @@ -809,12 +827,12 @@ -- ^ The name qualifier (may be empty). -> C.Name -- ^ The base name. - -> P.Range + -> Range -- ^ The 'Range' of the name in its fixity declaration (if any). -> (Bool -> Aspects) -- ^ Meta information to be associated with the name. -- The argument is 'True' iff the name is an operator. - -> Maybe P.Range + -> Maybe Range -- ^ The definition site of the name. The calculated -- meta information is extended with this information, -- if possible. @@ -829,9 +847,9 @@ mempty where aspects = m $ C.isOperator x - fileNames = mapMaybe (fmap P.srcFile . P.rStart . P.getRange) (x : xs) + fileNames = mapMaybe (fmap P.srcFile . P.rStart . getRange) (x : xs) frFile = singleton (rToR fr) (aspects { definitionSite = notHere <$> mFilePos }) - rs = map P.getRange (x : xs) + rs = map getRange (x : xs) -- The fixity declaration should not get a symbolic anchor. notHere d = d { defSiteHere = False } @@ -853,7 +871,7 @@ { defSiteModule = mod , defSitePos = fromIntegral p -- Is our current position the definition site? - , defSiteHere = r == P.getRange x + , defSiteHere = r == getRange x -- For bound variables etc. we do not create a symbolic anchor name. -- Also not for names that include anonymous modules, -- otherwise, we do not get unique anchors. @@ -903,38 +921,50 @@ file (concreteQualifier x) (concreteBase x) - r + rangeOfFixityDeclaration m (if include then Just $ bindingSite x else Nothing) `mappend` notationFile where - -- Andreas, 2016-09-08, for issue #2140: - -- Range of name from fixity declaration: - fr = theNameRange $ A.nameFixity $ A.qnameName x - -- Somehow we import fixity ranges from other files, we should ignore them. - -- (I do not understand how we get them as they should not be serialized...) - r = if P.rangeFile fr == Strict.Just file then fr else P.noRange + -- TODO: Currently we highlight fixity and syntax declarations by + -- producing highlighting something like once per occurrence of the + -- related name(s) in the file of the declaration (and we explicitly + -- avoid doing this for other files). Perhaps it would be better to + -- only produce this highlighting once. - notationFile = mconcat $ map genPartFile $ theNotation $ A.nameFixity $ A.qnameName x + rangeOfFixityDeclaration = + if P.rangeFile r == Strict.Just file + then r else noRange + where + r = Common.theNameRange $ A.nameFixity $ A.qnameName x + + notationFile = + if P.rangeFile (getRange notation) == Strict.Just file + then mconcat $ map genPartFile notation + else mempty + where + notation = Common.theNotation $ A.nameFixity $ A.qnameName x + boundAspect = parserBased{ aspect = Just $ Name (Just Bound) False } - genPartFile (BindHole r i) = several [rToR r, rToR $ getRange i] boundAspect - genPartFile (NormalHole r i) = several [rToR r, rToR $ getRange i] boundAspect - genPartFile WildHole{} = mempty - genPartFile (IdPart x) = singleton (rToR $ P.getRange x) (m False) + genPartFile (Common.BindHole r i) = several [rToR r, rToR $ getRange i] boundAspect + genPartFile (Common.NormalHole r i) = several [rToR r, rToR $ getRange i] boundAspect + genPartFile Common.WildHole{} = mempty + genPartFile (Common.IdPart x) = singleton (rToR $ getRange x) (m False) + concreteBase :: I.QName -> C.Name concreteBase = A.nameConcrete . A.qnameName concreteQualifier :: I.QName -> [C.Name] concreteQualifier = map A.nameConcrete . A.mnameToList . A.qnameModule -bindingSite :: I.QName -> P.Range +bindingSite :: I.QName -> Range bindingSite = A.nameBindingSite . A.qnameName -- | Remember a name disambiguation (during type checking). -- To be used later during syntax highlighting. storeDisambiguatedName :: A.QName -> TCM () -storeDisambiguatedName q = whenJust (start $ P.getRange q) $ \ i -> +storeDisambiguatedName q = whenJust (start $ getRange q) $ \ i -> stDisambiguatedNames `modifyTCLens` IntMap.insert i q where start r = fromIntegral . P.posPos <$> P.rStart' r diff --git a/src/full/Agda/Interaction/Highlighting/Generate.hs-boot b/src/full/Agda/Interaction/Highlighting/Generate.hs-boot --- a/src/full/Agda/Interaction/Highlighting/Generate.hs-boot +++ b/src/full/Agda/Interaction/Highlighting/Generate.hs-boot @@ -1,10 +1,5 @@ module Agda.Interaction.Highlighting.Generate where -import Agda.TypeChecking.Monad.Base -import Agda.Syntax.Position (Range) -highlightAsTypeChecked - :: MonadTCM tcm - => Range - -> Range - -> tcm a - -> tcm a +import Agda.TypeChecking.Monad.Base (TCM, TCWarning) + +highlightWarning :: TCWarning -> TCM () diff --git a/src/full/Agda/Interaction/Highlighting/HTML.hs b/src/full/Agda/Interaction/Highlighting/HTML.hs --- a/src/full/Agda/Interaction/Highlighting/HTML.hs +++ b/src/full/Agda/Interaction/Highlighting/HTML.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} -- | Function for generating highlighted, hyperlinked HTML from Agda -- sources. @@ -15,12 +14,10 @@ ) where import Prelude hiding ((!!), concatMap) -import Control.Arrow ((***)) import Control.Monad import Control.Monad.Trans import Data.Function -import Data.Monoid import Data.Foldable (toList, concatMap) import Data.Maybe import qualified Data.IntMap as IntMap @@ -46,26 +43,18 @@ import Agda.Interaction.Options import Agda.Interaction.Highlighting.Precise -import Agda.Interaction.Highlighting.Common -import Agda.Interaction.Highlighting.Generate - (computeUnsolvedMetaWarnings, computeUnsolvedConstraints) - import qualified Agda.Syntax.Concrete as C import Agda.Syntax.Common -import Agda.Syntax.Abstract.Name (ModuleName) import Agda.TypeChecking.Monad (TCM, useTC) import qualified Agda.TypeChecking.Monad as TCM import Agda.Utils.FileName (filePath) import Agda.Utils.Function -import Agda.Utils.Lens import qualified Agda.Utils.IO.UTF8 as UTF8 -import Agda.Utils.Pretty hiding ((<>)) -import Agda.Utils.Tuple +import Agda.Utils.Pretty -#include "undefined.h" import Agda.Utils.Impossible -- | The name of the default CSS file. @@ -154,8 +143,8 @@ cssFile <- getDataFileName defaultCSSFile copyFile cssFile (dir defaultCSSFile) - TCM.reportSLn "html" 1 $ unlines - [ "" + TCM.reportS "html" 1 + [ "" :: String , "Warning: HTML is currently generated for ALL files which can be" , "reached from the given module, including library files." ] diff --git a/src/full/Agda/Interaction/Highlighting/JSON.hs b/src/full/Agda/Interaction/Highlighting/JSON.hs --- a/src/full/Agda/Interaction/Highlighting/JSON.hs +++ b/src/full/Agda/Interaction/Highlighting/JSON.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} -- | Functions which give precise syntax highlighting info in JSON format. @@ -7,6 +6,7 @@ import Agda.Interaction.Highlighting.Common import Agda.Interaction.Highlighting.Precise hiding (String) import Agda.Interaction.Highlighting.Range (Range(..)) +import Agda.Interaction.JSON import Agda.Interaction.Response import Agda.TypeChecking.Monad (HighlightingMethod(..), ModuleToSource) import Agda.Utils.FileName (filePath) @@ -16,7 +16,6 @@ import qualified Data.ByteString.Lazy.Char8 as BS import qualified Data.Map as Map -#include "undefined.h" import Agda.Utils.Impossible -- | Encode meta information into a JSON Value @@ -37,6 +36,7 @@ , "position" .= position ] +instance EncodeTCM TokenBased where instance ToJSON TokenBased where toJSON TokenBased = String "TokenBased" toJSON NotOnlyTokenBased = String "NotOnlyTokenBased" diff --git a/src/full/Agda/Interaction/Highlighting/LaTeX.hs b/src/full/Agda/Interaction/Highlighting/LaTeX.hs --- a/src/full/Agda/Interaction/Highlighting/LaTeX.hs +++ b/src/full/Agda/Interaction/Highlighting/LaTeX.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE BangPatterns #-} {-# LANGUAGE CPP #-} {-# LANGUAGE ViewPatterns #-} @@ -49,11 +48,8 @@ import Agda.TypeChecking.Monad (TCM, Interface(..)) import qualified Agda.TypeChecking.Monad as TCM import qualified Agda.Interaction.Options as O -import Agda.Compiler.CallCompiler -import qualified Agda.Utils.IO.UTF8 as UTF8 import Agda.Utils.FileName (filePath, AbsolutePath, mkAbsolute) -#include "undefined.h" import Agda.Utils.Impossible ------------------------------------------------------------------------ @@ -321,10 +317,8 @@ -- Polytable, http://www.ctan.org/pkg/polytable, is used for code -- alignment, similar to lhs2TeX's approach. -nl, beginCode, endCode :: Text -nl = "%\n" -beginCode = "\\begin{code}" -endCode = "\\end{code}" +nl :: Text +nl = "%\n" -- | A command that is used when two tokens are put next to each other -- in the same column. @@ -521,7 +515,9 @@ '^' -> "\\textasciicircum{}" '\\' -> "\\textbackslash{}" _ -> [ c ] +#if __GLASGOW_HASKELL__ < 810 escape _ = __IMPOSSIBLE__ +#endif -- | Every element in the list should consist of either one or more -- newline characters, or one or more space characters. Two adjacent @@ -618,7 +614,7 @@ dir <- case O.optGHCiInteraction options of False -> return $ O.optLaTeXDir options True -> do - sourceFile <- Find.findFile mod + sourceFile <- Find.srcFilePath <$> Find.findFile mod return $ filePath (projectRoot sourceFile mod) O.optLaTeXDir options liftIO $ createDirectoryIfMissing True dir @@ -627,7 +623,7 @@ "kpsewhich" [ "--path=" ++ dir, defaultStyFile ] "" when (code /= ExitSuccess) $ do - TCM.reportSLn "compile.latex" 1 $ unlines + TCM.reportS "compile.latex" 1 [ defaultStyFile ++ " was not found. Copying a default version of " ++ defaultStyFile , "into " ++ dir ++ "." @@ -638,7 +634,7 @@ liftIO $ copyFile styFile (dir defaultStyFile) let outPath = modToFile mod - inAbsPath <- liftM filePath (Find.findFile mod) + inAbsPath <- liftM filePath (Find.srcFilePath <$> Find.findFile mod) liftIO $ do latex <- E.encodeUtf8 `fmap` diff --git a/src/full/Agda/Interaction/Highlighting/Precise.hs b/src/full/Agda/Interaction/Highlighting/Precise.hs --- a/src/full/Agda/Interaction/Highlighting/Precise.hs +++ b/src/full/Agda/Interaction/Highlighting/Precise.hs @@ -1,5 +1,4 @@ -{-# LANGUAGE DeriveDataTypeable #-} - +{-# LANGUAGE CPP #-} -- | Types used for precise syntax highlighting. module Agda.Interaction.Highlighting.Precise @@ -38,14 +37,15 @@ , mergeC ) where -import Control.Applicative ((<$>), (<*>)) import Control.Arrow (second) import Control.Monad import Data.Function import qualified Data.List as List import Data.Maybe +#if __GLASGOW_HASKELL__ < 804 import Data.Semigroup +#endif import Data.IntMap (IntMap) import qualified Data.IntMap as IntMap @@ -119,15 +119,20 @@ | Deadcode -- ^ Used for highlighting unreachable clauses, unreachable RHS -- (because of an absurd pattern), etc. + | ShadowingInTelescope + -- ^ Used for shadowed repeated variable names in telescopes. | CoverageProblem | IncompletePattern -- ^ When this constructor is used it is probably a good idea to -- include a 'note' explaining why the pattern is incomplete. | TypeChecks -- ^ Code which is being type-checked. + | MissingDefinition + -- ^ Function declaration without matching definition -- NB: We put CatchallClause last so that it is overwritten by other, -- more important, aspects in the emacs mode. | CatchallClause + | ConfluenceProblem deriving (Eq, Ord, Show, Enum, Bounded) -- | Meta information which can be associated with a @@ -143,7 +148,7 @@ -- the fixity of an operator). , definitionSite :: Maybe DefinitionSite -- ^ The definition site of the annotated thing, if applicable and - -- known. File positions are counted from 1. + -- known. , tokenBased :: !TokenBased -- ^ Is this entry token-based? } @@ -153,7 +158,8 @@ { defSiteModule :: SC.TopLevelModuleName -- ^ The defining module. , defSitePos :: Int - -- ^ The file position in that module. + -- ^ The file position in that module. File positions are + -- counted from 1. , defSiteHere :: Bool -- ^ Has this @DefinitionSite@ been created at the defining site of the name? , defSiteAnchor :: Maybe String diff --git a/src/full/Agda/Interaction/Highlighting/Range.hs b/src/full/Agda/Interaction/Highlighting/Range.hs --- a/src/full/Agda/Interaction/Highlighting/Range.hs +++ b/src/full/Agda/Interaction/Highlighting/Range.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE DeriveDataTypeable #-} -- | Ranges. @@ -16,10 +15,7 @@ , minus ) where -import Control.Applicative ((<$>)) - import qualified Agda.Syntax.Position as P -import Agda.Utils.List -- | Character ranges. The first character in the file has position 1. -- Note that the 'to' position is considered to be outside of the diff --git a/src/full/Agda/Interaction/Highlighting/Vim.hs b/src/full/Agda/Interaction/Highlighting/Vim.hs --- a/src/full/Agda/Interaction/Highlighting/Vim.hs +++ b/src/full/Agda/Interaction/Highlighting/Vim.hs @@ -1,4 +1,3 @@ --- {-# LANGUAGE CPP #-} module Agda.Interaction.Highlighting.Vim where @@ -67,7 +66,7 @@ toVim ns = unlines $ matches mcons micons mdefs midefs mflds miflds where cons = [ x | (x, def:_) <- Map.toList ns, anameKind def == ConName ] - defs = [ x | (x, def:_) <- Map.toList ns, anameKind def == DefName ] + defs = [ x | (x, def:_) <- Map.toList ns, isDefName (anameKind def)] flds = [ x | (x, fld:_) <- Map.toList ns, anameKind fld == FldName ] mcons = map show cons diff --git a/src/full/Agda/Interaction/Imports.hs b/src/full/Agda/Interaction/Imports.hs --- a/src/full/Agda/Interaction/Imports.hs +++ b/src/full/Agda/Interaction/Imports.hs @@ -1,4 +1,4 @@ -{-# LANGUAGE CPP #-} +{-# LANGUAGE CPP #-} {-| This module deals with finding imported modules and loading their interface files. @@ -8,30 +8,25 @@ import Prelude hiding (null) import Control.Arrow -import Control.DeepSeq import Control.Monad.Reader import Control.Monad.State import Control.Monad.Trans.Maybe import qualified Control.Exception as E -import Data.Function (on) import qualified Data.Map as Map import qualified Data.List as List +import Data.Set (Set) import qualified Data.Set as Set -import qualified Data.Foldable as Fold (toList) -import qualified Data.List as List import Data.Maybe import Data.Monoid (mempty, mappend) import Data.Map (Map) -import Data.Set (Set) +import qualified Data.HashMap.Strict as HMap import Data.Text.Lazy (Text) import qualified Data.Text.Lazy as T import System.Directory (doesFileExist, getModificationTime, removeFile) import System.FilePath (()) -import qualified Text.PrettyPrint.Boxes as Boxes - import Agda.Benchmarking import qualified Agda.Syntax.Abstract as A @@ -42,15 +37,14 @@ import Agda.Syntax.Position import Agda.Syntax.Scope.Base import Agda.Syntax.Translation.ConcreteToAbstract -import Agda.Syntax.Internal import Agda.TypeChecking.Errors import Agda.TypeChecking.Warnings import Agda.TypeChecking.Reduce +import Agda.TypeChecking.Rewriting.Confluence ( checkConfluenceOfRules ) import Agda.TypeChecking.MetaVars ( openMetasToPostulates ) import Agda.TypeChecking.Monad import Agda.TypeChecking.Serialise -import Agda.TypeChecking.Telescope import Agda.TypeChecking.Primitive import Agda.TypeChecking.Pretty as P import Agda.TypeChecking.DeadCode @@ -58,32 +52,29 @@ import Agda.TheTypeChecker +import Agda.Interaction.BasicOps (getGoals, showGoals) import Agda.Interaction.FindFile -import {-# SOURCE #-} Agda.Interaction.InteractionTop (showOpenMetas) -import Agda.Interaction.Options -import qualified Agda.Interaction.Options.Lenses as Lens -import Agda.Interaction.Highlighting.Precise - (HighlightingInfo, compress) import Agda.Interaction.Highlighting.Generate +import Agda.Interaction.Highlighting.Precise ( compress ) import Agda.Interaction.Highlighting.Vim +import Agda.Interaction.Options +import qualified Agda.Interaction.Options.Lenses as Lens import Agda.Interaction.Response (RemoveTokenBasedHighlighting(KeepHighlighting)) import Agda.Utils.Except ( MonadError(catchError, throwError) ) import Agda.Utils.FileName import Agda.Utils.Lens +import Agda.Utils.List import Agda.Utils.Maybe import qualified Agda.Utils.Maybe.Strict as Strict import Agda.Utils.Monad import Agda.Utils.Null import Agda.Utils.IO.Binary import Agda.Utils.Pretty hiding (Mode) -import Agda.Utils.Time import Agda.Utils.Hash -import qualified Agda.Utils.HashMap as HMap import qualified Agda.Utils.Trie as Trie -#include "undefined.h" import Agda.Utils.Impossible -- | Some information about the source code. @@ -97,17 +88,18 @@ -- | Computes a 'SourceInfo' record for the given file. -sourceInfo :: AbsolutePath -> TCM SourceInfo -sourceInfo f = Bench.billTo [Bench.Parsing] $ do +sourceInfo :: SourceFile -> TCM SourceInfo +sourceInfo (SourceFile f) = Bench.billTo [Bench.Parsing] $ do source <- runPM $ readFilePM f (parsedMod, fileType) <- runPM $ parseFile moduleParser f $ T.unpack source moduleName <- moduleName f parsedMod - return $ SourceInfo { siSource = source - , siFileType = fileType - , siModule = parsedMod - , siModuleName = moduleName - } + return SourceInfo + { siSource = source + , siFileType = fileType + , siModule = parsedMod + , siModuleName = moduleName + } -- | Is the aim to type-check the top-level module, or only to -- scope-check it? @@ -145,7 +137,7 @@ bi = Map.fromList [ (x,Builtin t) | (x,Builtin t) <- builtin ] warns = iWarnings i bs <- getsTC stBuiltinThings - reportSLn "import.iface.merge" 10 $ "Merging interface" + reportSLn "import.iface.merge" 10 "Merging interface" reportSLn "import.iface.merge" 20 $ " Current builtins " ++ show (Map.keys bs) ++ "\n" ++ " New builtins " ++ show (Map.keys bi) @@ -158,22 +150,32 @@ Just b1 = Map.lookup b bs Just b2 = Map.lookup b bi mapM_ check (map fst $ Map.toList $ Map.intersection bs bi) - addImportedThings sig bi (iPatternSyns i) (iDisplayForms i) (iUserWarnings i) warns + addImportedThings sig bi (iPatternSyns i) (iDisplayForms i) (iUserWarnings i) (iPartialDefs i) warns reportSLn "import.iface.merge" 20 $ " Rebinding primitives " ++ show prim mapM_ rebind prim + whenM (optConfluenceCheck <$> pragmaOptions) $ do + reportSLn "import.iface.confluence" 20 $ " Checking confluence of imported rewrite rules" + checkConfluenceOfRules $ concat $ HMap.elems $ sig ^. sigRewriteRules where rebind (x, q) = do PrimImpl _ pf <- lookupPrimitiveFunction x stImportedBuiltins `modifyTCLens` Map.insert x (Prim pf{ primFunName = q }) -addImportedThings :: - Signature -> BuiltinThings PrimFun -> - A.PatternSynDefns -> DisplayForms -> Map A.QName String -> [TCWarning] -> TCM () -addImportedThings isig ibuiltin patsyns display userwarn warnings = do +addImportedThings + :: Signature + -> BuiltinThings PrimFun + -> A.PatternSynDefns + -> DisplayForms + -> Map A.QName String -- ^ Imported user warnings + -> Set QName -- ^ Name of imported definitions which are partial + -> [TCWarning] + -> TCM () +addImportedThings isig ibuiltin patsyns display userwarn partialdefs warnings = do stImports `modifyTCLens` \ imp -> unionSignatures [imp, isig] stImportedBuiltins `modifyTCLens` \ imp -> Map.union imp ibuiltin stImportedUserWarnings `modifyTCLens` \ imp -> Map.union imp userwarn + stImportedPartialDefs `modifyTCLens` \ imp -> Set.union imp partialdefs stPatternSynImports `modifyTCLens` \ imp -> Map.union imp patsyns stImportedDisplayForms `modifyTCLens` \ imp -> HMap.unionWith (++) imp display stTCWarnings `modifyTCLens` \ imp -> List.union imp warnings @@ -193,6 +195,10 @@ -- we need to reimburse her account. i <- Bench.billTo [] $ getInterface x addImport x + + -- If that interface was supposed to raise a warning on import, do so. + whenJust (iImportWarning i) $ warning . UserWarning + -- let s = publicModules $ iInsideScope i let s = iScope i return (iModuleName i `withRangesOfQ` mnameToConcrete x, s) @@ -236,7 +242,7 @@ let i = miInterface mi -- Check that imported options are compatible with current ones, -- but give primitive modules a pass - optsCompat <- if miPrimitive mi then return True else do + optsCompat <- if miPrimitive mi then return True else ifM (asksTC envCheckOptionConsistency) {-then-} (checkOptionsCompatible currentOptions (iOptionsUsed i) (iModuleName i)) @@ -249,7 +255,7 @@ r@(i, wt) <- getIface reportSLn "import.visit" 5 $ " Now we've looked at " ++ prettyShow x unless (isMain == MainInterface ScopeCheck) $ - visitModule $ ModuleInfo + visitModule ModuleInfo { miInterface = i , miWarnings = hasWarnings wt , miPrimitive = False -- will be updated later for primitive modules @@ -271,7 +277,7 @@ -- complete interface is returned. typeCheckMain - :: AbsolutePath + :: SourceFile -- ^ The path to the file. -> Mode -- ^ Should the file be type-checked, or only scope-checked? @@ -281,7 +287,7 @@ typeCheckMain f mode si = do -- liftIO $ putStrLn $ "This is typeCheckMain " ++ prettyShow f -- liftIO . putStrLn . show =<< getVerbosity - reportSLn "import.main" 10 $ "Importing the primitive modules." + reportSLn "import.main" 10 "Importing the primitive modules." libdir <- liftIO defaultLibDir let libdirPrim = libdir "prim" reportSLn "import.main" 20 $ "Library dir = " ++ show libdir @@ -294,7 +300,7 @@ -- We don't want to generate highlighting information for Agda.Primitive. withHighlightingLevel None $ withoutOptionsChecking $ forM_ (Set.map (libdirPrim ) Lens.primitiveModules) $ \f -> do - let file = mkAbsolute f + let file = SourceFile $ mkAbsolute f si <- sourceInfo file checkModuleName' (siModuleName si) file _ <- getInterface_ (siModuleName si) (Just si) @@ -355,8 +361,8 @@ -> Maybe SourceInfo -- ^ Optional information about the source code. -> TCM (Interface, MaybeWarnings) -getInterface' x isMain msi = do - withIncreasedModuleNestingLevel $ do +getInterface' x isMain msi = + withIncreasedModuleNestingLevel $ -- Preserve the pragma options unless we are checking the main -- interface. bracket_ (useTC stPragmaOptions) @@ -379,17 +385,18 @@ uptodate <- Bench.billTo [Bench.Import] $ do ignore <- (ignoreInterfaces `and2M` - (not <$> Lens.isBuiltinModule (filePath file))) + (not <$> Lens.isBuiltinModule (filePath $ srcFilePath file))) `or2M` ignoreAllInterfaces cached <- runMaybeT $ isCached x file -- If it's cached ignoreInterfaces has no effect; -- to avoid typechecking a file more than once. sourceH <- case msi of - Nothing -> liftIO $ hashTextFile file + Nothing -> liftIO $ hashTextFile (srcFilePath file) Just si -> return $ hashText (siSource si) - ifaceH <- - case cached of - Nothing -> fmap fst <$> getInterfaceFileHashes (filePath $ toIFile file) + ifaceH <- case cached of + Nothing -> do + mifile <- toIFile file + fmap fst <$> getInterfaceFileHashes mifile Just i -> return $ Just $ iSourceHash i let unchanged = Just sourceH == ifaceH return $ unchanged && (not ignore || isJust cached) @@ -412,10 +419,10 @@ -- Ensure that the given module name matches the one in the file. let topLevelName = toTopLevelModuleName $ iModuleName i - unless (topLevelName == x) $ do + unless (topLevelName == x) $ -- Andreas, 2014-03-27 This check is now done in the scope checker. -- checkModuleName topLevelName file - typeError $ OverlappingProjects file topLevelName x + typeError $ OverlappingProjects (srcFilePath file) topLevelName x visited <- isVisited x reportSLn "import.iface" 5 $ if visited then " We've been here. Don't merge." @@ -445,6 +452,10 @@ (_, SomeWarnings w) -> return () _ -> storeDecodedModule i + reportS "warning.import" 10 + [ "module: " ++ show (C.moduleNameParts x) + , "WarningOnImport: " ++ show (iImportWarning i) + ] return (i, wt') -- | Check if the options used for checking an imported module are @@ -455,18 +466,18 @@ reportSDoc "import.iface.options" 5 $ P.nest 2 $ "current options =" P.<+> showOptions current reportSDoc "import.iface.options" 5 $ P.nest 2 $ "imported options =" P.<+> showOptions imported forM_ coinfectiveOptions $ \ (opt, optName) -> do - unless ((opt current) `implies` (opt imported)) $ do + unless (opt current `implies` opt imported) $ do put False warning (CoInfectiveImport optName importedModule) forM_ infectiveOptions $ \ (opt, optName) -> do - unless ((opt imported) `implies` (opt current)) $ do + unless (opt imported `implies` opt current) $ do put False warning (InfectiveImport optName importedModule) where implies :: Bool -> Bool -> Bool p `implies` q = p <= q - showOptions opts = P.prettyList (map (\ (o, n) -> P.text n P.<> ": " P.<+> (P.pretty $ o opts)) + showOptions opts = P.prettyList (map (\ (o, n) -> (P.text n <> ": ") P.<+> (P.pretty $ o opts)) (coinfectiveOptions ++ infectiveOptions)) -- | Check whether interface file exists and is in cache @@ -475,21 +486,18 @@ isCached :: C.TopLevelModuleName -- ^ Module name of file we process. - -> AbsolutePath + -> SourceFile -- ^ File we process. -> MaybeT TCM Interface isCached x file = do - let ifile = filePath $ toIFile file - - -- Make sure the file exists in the case sensitive spelling. - guardM $ liftIO $ doesFileExistCaseSensitive ifile + ifile <- MaybeT $ findInterfaceFile' file -- Check that we have cached the module. mi <- MaybeT $ getDecodedModule x -- Check that the interface file exists and return its hash. - h <- MaybeT $ fmap snd <$> getInterfaceFileHashes ifile + h <- MaybeT $ fmap snd <$> getInterfaceFileHashes' ifile -- Make sure the hashes match. guard $ iFullHash mi == h @@ -501,7 +509,7 @@ getStoredInterface :: C.TopLevelModuleName -- ^ Module name of file we process. - -> AbsolutePath + -> SourceFile -- ^ File we process. -> MainInterface -> Maybe SourceInfo @@ -509,6 +517,7 @@ -> TCM (Bool, (Interface, MaybeWarnings)) -- ^ @Bool@ is: do we have to merge the interface? getStoredInterface x file isMain msi = do + let fp = filePath $ srcFilePath file -- If something goes wrong (interface outdated etc.) -- we revert to fresh type checking. let fallback = typeCheck x file isMain msi @@ -516,7 +525,8 @@ -- Examine the hash of the interface file. If it is different from the -- stored version (in stDecodedModules), or if there is no stored version, -- read and decode it. Otherwise use the stored version. - let ifile = filePath $ toIFile file + ifile <- toIFile file + let ifp = filePath ifile h <- fmap snd <$> getInterfaceFileHashes ifile mm <- getDecodedModule x (cached, mi) <- Bench.billTo [Bench.Deserialization] $ case mm of @@ -526,19 +536,19 @@ dropDecodedModule x reportSLn "import.iface" 50 $ " cached hash = " ++ show (iFullHash mi) reportSLn "import.iface" 50 $ " stored hash = " ++ show h - reportSLn "import.iface" 5 $ " file is newer, re-reading " ++ ifile + reportSLn "import.iface" 5 $ " file is newer, re-reading " ++ ifp (False,) <$> readInterface ifile else do - reportSLn "import.iface" 5 $ " using stored version of " ++ ifile + reportSLn "import.iface" 5 $ " using stored version of " ++ ifp return (True, Just mi) Nothing -> do - reportSLn "import.iface" 5 $ " no stored version, reading " ++ ifile + reportSLn "import.iface" 5 $ " no stored version, reading " ++ ifp (False,) <$> readInterface ifile -- Check that it's the right version case mi of Nothing -> do - reportSLn "import.iface" 5 $ " bad interface, re-type checking" + reportSLn "import.iface" 5 " bad interface, re-type checking" fallback Just i -> do reportSLn "import.iface" 5 $ " imports: " ++ show (iImportedModules i) @@ -552,14 +562,19 @@ -- Check that options that matter haven't changed compared to -- current options (issue #2487) optionsChanged <-ifM ((not <$> asksTC envCheckOptionConsistency) `or2M` - Lens.isBuiltinModule (filePath file)) + Lens.isBuiltinModule fp) {-then-} (return False) {-else-} $ do currentOptions <- useTC stPragmaOptions let disagreements = [ optName | (opt, optName) <- restartOptions, - (opt currentOptions) /= (opt (iOptionsUsed i))] + opt currentOptions /= opt (iOptionsUsed i) ] if null disagreements then return False else do - reportSLn "import.iface.options" 4 $ " Changes in the following options in " ++ prettyShow (filePath file) ++ ", re-typechecking: " ++ prettyShow disagreements + reportSLn "import.iface.options" 4 $ concat + [ " Changes in the following options in " + , prettyShow fp + , ", re-typechecking: " + , prettyShow disagreements + ] return True if optionsChanged then fallback else do @@ -568,14 +583,12 @@ -- If any of the imports are newer we need to retype check if hs /= map snd (iImportedModules i) - then do - -- liftIO close -- Close the interface file. See above. - fallback + then fallback else do unless cached $ do - chaseMsg "Loading " x $ Just ifile + chaseMsg "Loading " x $ Just ifp -- print imported warnings - let ws = filter ((Strict.Just file ==) . tcWarningOrigin) (iWarnings i) + let ws = filter ((Strict.Just (srcFilePath file) ==) . tcWarningOrigin) (iWarnings i) unless (null ws) $ reportSDoc "warning" 1 $ P.vcat $ P.prettyTCM <$> ws return (False, (i, NoWarnings)) @@ -590,7 +603,7 @@ typeCheck :: C.TopLevelModuleName -- ^ Module name of file we process. - -> AbsolutePath + -> SourceFile -- ^ File we process. -> MainInterface -> Maybe SourceInfo @@ -598,18 +611,19 @@ -> TCM (Bool, (Interface, MaybeWarnings)) -- ^ @Bool@ is: do we have to merge the interface? typeCheck x file isMain msi = do + let fp = filePath $ srcFilePath file unless (includeStateChanges isMain) cleanCachedLog let checkMsg = case isMain of MainInterface ScopeCheck -> "Reading " _ -> "Checking" withMsgs = bracket_ - (chaseMsg checkMsg x $ Just $ filePath file) + (chaseMsg checkMsg x $ Just fp) (const $ do ws <- getAllWarnings AllWarnings - let (we, wa) = classifyWarnings ws - let wa' = filter ((Strict.Just file ==) . tcWarningOrigin) wa + let classified = classifyWarnings ws + let wa' = filter ((Strict.Just (srcFilePath file) ==) . tcWarningOrigin) (tcWarnings classified) unless (null wa') $ reportSDoc "warning" 1 $ P.vcat $ P.prettyTCM <$> wa' - when (null we) $ chaseMsg "Finished" x Nothing) + when (null (nonFatalErrors classified)) $ chaseMsg "Finished" x Nothing) -- Do the type checking. @@ -619,18 +633,19 @@ return (True, r) NotMainInterface -> do - ms <- getImportPath - nesting <- asksTC envModuleNestingLevel - range <- asksTC envRange - call <- asksTC envCall - mf <- useTC stModuleToSource - vs <- getVisitedModules - ds <- getDecodedModules - opts <- stPersistentOptions . stPersistentState <$> getTC - isig <- useTC stImports - ibuiltin <- useTC stImportedBuiltins - display <- useTC stImportsDisplayForms - userwarn <- useTC stImportedUserWarnings + ms <- getImportPath + nesting <- asksTC envModuleNestingLevel + range <- asksTC envRange + call <- asksTC envCall + mf <- useTC stModuleToSource + vs <- getVisitedModules + ds <- getDecodedModules + opts <- stPersistentOptions . stPersistentState <$> getTC + isig <- useTC stImports + ibuiltin <- useTC stImportedBuiltins + display <- useTC stImportsDisplayForms + userwarn <- useTC stImportedUserWarnings + partialdefs <- useTC stImportedPartialDefs ipatsyns <- getPatternSynImports ho <- getInteractionOutputCallback -- Every interface is treated in isolation. Note: Some changes to @@ -655,7 +670,7 @@ setInteractionOutputCallback ho stModuleToSource `setTCLens` mf setVisitedModules vs - addImportedThings isig ibuiltin ipatsyns display userwarn [] + addImportedThings isig ibuiltin ipatsyns display userwarn partialdefs [] r <- withMsgs $ createInterface file x isMain msi mf <- useTC stModuleToSource @@ -696,27 +711,34 @@ let maybeFile = caseMaybe file "." $ \ f -> " (" ++ f ++ ")." vLvl | kind == "Checking" = 1 | otherwise = 2 - reportSLn "import.chase" vLvl $ concat $ + reportSLn "import.chase" vLvl $ concat [ indentation, kind, " ", prettyShow x, maybeFile ] - -- | Print the highlighting information contained in the given interface. highlightFromInterface :: Interface - -> AbsolutePath + -> SourceFile -- ^ The corresponding file. -> TCM () highlightFromInterface i file = do reportSLn "import.iface" 5 $ - "Generating syntax info for " ++ filePath file ++ + "Generating syntax info for " ++ filePath (srcFilePath file) ++ " (read from interface)." printHighlightingInfo KeepHighlighting (iHighlighting i) -readInterface :: FilePath -> TCM (Maybe Interface) -readInterface file = do +-- | Read interface file corresponding to a module. + +readInterface :: AbsolutePath -> TCM (Maybe Interface) +readInterface file = runMaybeT $ do + ifile <- MaybeT $ liftIO $ mkInterfaceFile file + MaybeT $ readInterface' ifile + +readInterface' :: InterfaceFile -> TCM (Maybe Interface) +readInterface' file = do + let ifp = filePath $ intFilePath file -- Decode the interface file - (s, close) <- liftIO $ readBinaryFile' file + (s, close) <- liftIO $ readBinaryFile' ifp do mi <- liftIO . E.evaluate =<< decodeInterface s -- Close the file. Note @@ -741,10 +763,13 @@ _ -> throwError e -- | Writes the given interface to the given file. +-- +-- The written interface is decoded and returned. -writeInterface :: FilePath -> Interface -> TCM () -writeInterface file i = do - reportSLn "import.iface.write" 5 $ "Writing interface file " ++ file ++ "." +writeInterface :: AbsolutePath -> Interface -> TCM Interface +writeInterface file i = let fp = filePath file in do + reportSLn "import.iface.write" 5 $ + "Writing interface file " ++ fp ++ "." -- Andreas, 2015-07-13 -- After QName memoization (AIM XXI), scope serialization might be cheap enough. -- -- Andreas, Makoto, 2014-10-18 AIM XX: @@ -756,18 +781,28 @@ -- i <- return $ -- i { iInsideScope = removePrivates $ iInsideScope i -- } - encodeFile file i - reportSLn "import.iface.write" 5 $ "Wrote interface file." - reportSLn "import.iface.write" 50 $ " hash = " ++ show (iFullHash i) ++ "" + reportSLn "import.iface.write" 50 $ + "Writing interface file with hash" ++ show (iFullHash i) ++ "." + i' <- encodeFile fp i + reportSLn "import.iface.write" 5 "Wrote interface file." + i <- +#if __GLASGOW_HASKELL__ >= 804 + Bench.billTo [Bench.Deserialization] (decode i') +#else + return (Just i) +#endif + case i of + Just i -> return i + Nothing -> __IMPOSSIBLE__ `catchError` \e -> do reportSLn "" 1 $ - "Failed to write interface " ++ file ++ "." + "Failed to write interface " ++ fp ++ "." liftIO $ - whenM (doesFileExist file) $ removeFile file + whenM (doesFileExist fp) $ removeFile fp throwError e removePrivates :: ScopeInfo -> ScopeInfo -removePrivates si = si { scopeModules = restrictPrivate <$> scopeModules si } +removePrivates = over scopeModules $ fmap restrictPrivate concreteOptionsToOptionPragmas :: [C.Pragma] -> TCM [OptionsPragma] concreteOptionsToOptionPragmas p = do @@ -785,14 +820,14 @@ -- information. createInterface - :: AbsolutePath -- ^ The file to type check. + :: SourceFile -- ^ The file to type check. -> C.TopLevelModuleName -- ^ The expected module name. -> MainInterface -- ^ Are we dealing with the main module? -> Maybe SourceInfo -- ^ Optional information about the source code. -> TCM (Interface, MaybeWarnings) createInterface file mname isMain msi = Bench.billTo [Bench.TopModule mname] $ - localTC (\e -> e { envCurrentPath = Just file }) $ do + localTC (\e -> e { envCurrentPath = Just (srcFilePath file) }) $ do reportSLn "import.iface.create" 5 $ "Creating interface for " ++ prettyShow mname ++ "." @@ -811,7 +846,7 @@ modFile <- useTC stModuleToSource fileTokenInfo <- Bench.billTo [Bench.Highlighting] $ generateTokenInfoFromSource - file (T.unpack source) + (srcFilePath file) (T.unpack source) stTokens `setTCLens` fileTokenInfo options <- concreteOptionsToOptionPragmas pragmas @@ -819,16 +854,16 @@ -- Scope checking. - reportSLn "import.iface.create" 7 $ "Starting scope checking." + reportSLn "import.iface.create" 7 "Starting scope checking." topLevel <- Bench.billTo [Bench.Scoping] $ - concreteToAbstract_ (TopLevel file mname top) - reportSLn "import.iface.create" 7 $ "Finished scope checking." + concreteToAbstract_ (TopLevel (srcFilePath file) mname top) + reportSLn "import.iface.create" 7 "Finished scope checking." let ds = topLevelDecls topLevel scope = topLevelScope topLevel -- Highlighting from scope checker. - reportSLn "import.iface.create" 7 $ "Starting highlighting from scope." + reportSLn "import.iface.create" 7 "Starting highlighting from scope." Bench.billTo [Bench.Highlighting] $ do -- Generate and print approximate syntax highlighting info. ifTopLevelAndHighlightingLevelIs NonInteractive $ @@ -836,7 +871,7 @@ let onlyScope = isMain == MainInterface ScopeCheck ifTopLevelAndHighlightingLevelIsOr NonInteractive onlyScope $ mapM_ (\ d -> generateAndPrintSyntaxInfo d Partial onlyScope) ds - reportSLn "import.iface.create" 7 $ "Finished highlighting from scope." + reportSLn "import.iface.create" 7 "Finished highlighting from scope." -- Type checking. @@ -859,12 +894,12 @@ case isMain of MainInterface ScopeCheck -> do - reportSLn "import.iface.create" 7 $ "Skipping type checking." + reportSLn "import.iface.create" 7 "Skipping type checking." cacheCurrentLog _ -> do - reportSLn "import.iface.create" 7 $ "Starting type checking." + reportSLn "import.iface.create" 7 "Starting type checking." Bench.billTo [Bench.Typing] $ mapM_ checkDeclCached ds `finally_` cacheCurrentLog - reportSLn "import.iface.create" 7 $ "Finished type checking." + reportSLn "import.iface.create" 7 "Finished type checking." -- Ulf, 2013-11-09: Since we're rethrowing the error, leave it up to the -- code that handles that error to reset the state. @@ -882,7 +917,7 @@ tickN "metas" (fromIntegral n) -- Highlighting from type checker. - reportSLn "import.iface.create" 7 $ "Starting highlighting from type info." + reportSLn "import.iface.create" 7 "Starting highlighting from type info." Bench.billTo [Bench.Highlighting] $ do -- Move any remaining token highlighting to stSyntaxInfo. @@ -894,18 +929,18 @@ -- Grabbing warnings and unsolved metas to highlight them warnings <- getAllWarnings AllWarnings unless (null warnings) $ reportSDoc "import.iface.create" 20 $ - "collected warnings: " P.<> prettyTCM warnings + "collected warnings: " <> prettyTCM warnings unsolved <- getAllUnsolved unless (null unsolved) $ reportSDoc "import.iface.create" 20 $ - "collected unsolved: " P.<> prettyTCM unsolved + "collected unsolved: " <> prettyTCM unsolved let warningInfo = compress $ foldMap warningHighlighting $ unsolved ++ warnings stSyntaxInfo `modifyTCLens` \inf -> (inf `mappend` toks) `mappend` warningInfo whenM (optGenerateVimFile <$> commandLineOptions) $ -- Generate Vim file. - withScope_ scope $ generateVimFile $ filePath file - reportSLn "import.iface.create" 7 $ "Finished highlighting from type info." + withScope_ scope $ generateVimFile $ filePath $ srcFilePath $ file + reportSLn "import.iface.create" 7 "Finished highlighting from type info." setScope scope reportSLn "scope.top" 50 $ "SCOPE " ++ show scope @@ -916,10 +951,9 @@ openMetas <- getOpenMetas unless (null openMetas) $ do reportSLn "import.metas" 10 "We have unsolved metas." - reportSLn "import.metas" 10 . unlines =<< showOpenMetas + reportSLn "import.metas" 10 =<< showGoals =<< getGoals - ifTopLevelAndHighlightingLevelIs NonInteractive $ - printUnsolvedInfo + ifTopLevelAndHighlightingLevelIs NonInteractive printUnsolvedInfo -- Andreas, 2016-08-03, issue #964 -- When open metas are allowed, @@ -932,20 +966,19 @@ -- We do not get here when checking the main module -- (then includeStateChanges is True). when allowUnsolved $ do - reportSLn "import.iface.create" 7 $ "Turning unsolved metas (if any) into postulates." - withCurrentModule (scopeCurrent scope) $ - openMetasToPostulates + reportSLn "import.iface.create" 7 "Turning unsolved metas (if any) into postulates." + withCurrentModule (scope ^. scopeCurrent) openMetasToPostulates -- Clear constraints as they might refer to what -- they think are open metas. stAwakeConstraints `setTCLens` [] stSleepingConstraints `setTCLens` [] -- Serialization. - reportSLn "import.iface.create" 7 $ "Starting serialization." - i <- Bench.billTo [Bench.Serialization, Bench.BuildInterface] $ do + reportSLn "import.iface.create" 7 "Starting serialization." + i <- Bench.billTo [Bench.Serialization, Bench.BuildInterface] $ buildInterface source fileType topLevel options - reportSLn "tc.top" 101 $ unlines $ + reportS "tc.top" 101 $ "Signature:" : [ unlines [ prettyShow x @@ -955,29 +988,29 @@ | (x, def) <- HMap.toList $ iSignature i ^. sigDefinitions, Function{ funCompiled = cc } <- [theDef def] ] - reportSLn "import.iface.create" 7 $ "Finished serialization." + reportSLn "import.iface.create" 7 "Finished serialization." mallWarnings <- getMaybeWarnings' isMain ErrorWarnings - reportSLn "import.iface.create" 7 $ "Considering writing to interface file." - case (mallWarnings, isMain) of + reportSLn "import.iface.create" 7 "Considering writing to interface file." + i <- case (mallWarnings, isMain) of (SomeWarnings allWarnings, _) -> do -- Andreas, 2018-11-15, re issue #3393 -- The following is not sufficient to fix #3393 -- since the replacement of metas by postulates did not happen. -- -- | not (allowUnsolved && all (isUnsolvedWarning . tcWarning) allWarnings) -> do - reportSLn "import.iface.create" 7 $ "We have warnings, skipping writing interface file." - return () + reportSLn "import.iface.create" 7 "We have warnings, skipping writing interface file." + return i (_, MainInterface ScopeCheck) -> do - reportSLn "import.iface.create" 7 $ "We are just scope-checking, skipping writing interface file." - return () + reportSLn "import.iface.create" 7 "We are just scope-checking, skipping writing interface file." + return i _ -> Bench.billTo [Bench.Serialization] $ do - reportSLn "import.iface.create" 7 $ "Actually calling writeInterface." + reportSLn "import.iface.create" 7 "Actually calling writeInterface." -- The file was successfully type-checked (and no warnings were -- encountered), so the interface should be written out. - let ifile = filePath $ toIFile file + ifile <- toIFile file writeInterface ifile i - reportSLn "import.iface.create" 7 $ "Finished (or skipped) writing to interface file." + reportSLn "import.iface.create" 7 "Finished (or skipped) writing to interface file." -- -- Restore the open metas, as we might continue in interaction mode. -- Actually, we do not serialize the metas if checking the MainInterface @@ -990,13 +1023,12 @@ -- and add it to the accumulated statistics. localStatistics <- getStatistics lensAccumStatistics `modifyTCLens` Map.unionWith (+) localStatistics - verboseS "profile" 1 $ do - reportSLn "import.iface" 5 $ "Accumulated statistics." + verboseS "profile" 1 $ reportSLn "import.iface" 5 "Accumulated statistics." return $ first constructIScope (i, mallWarnings) getUniqueMetasRanges :: [MetaId] -> TCM [Range] -getUniqueMetasRanges = fmap List.nub . mapM getMetaRange +getUniqueMetasRanges = fmap (nubOn id) . mapM getMetaRange getUnsolvedMetas :: TCM [Range] getUnsolvedMetas = do @@ -1087,7 +1119,7 @@ reportSLn "import.iface" 5 "Building interface..." let m = topLevelModuleName topLevel scope' <- getScope - let scope = scope' { scopeCurrent = m } + let scope = set scopeCurrent m scope' -- Andreas, 2014-05-03: killRange did not result in significant reduction -- of .agdai file size, and lost a few seconds performance on library-test. -- Andreas, Makoto, 2014-10-18 AIM XX: repeating the experiment @@ -1098,9 +1130,9 @@ -- that introduced this change seems to have made Agda a bit -- faster and interface file sizes a bit smaller, at least for the -- standard library). - builtin <- useTC stLocalBuiltins - ms <- getImports - mhs <- mapM (\ m -> (m,) <$> moduleHash m) $ Set.toList ms + builtin <- useTC stLocalBuiltins + ms <- getImports + mhs <- mapM (\ m -> (m,) <$> moduleHash m) $ Set.toList ms foreignCode <- useTC stForeignCode -- Ulf, 2016-04-12: -- Non-closed display forms are not applicable outside the module anyway, @@ -1108,9 +1140,11 @@ display <- HMap.filter (not . null) . HMap.map (filter isClosed) <$> useTC stImportsDisplayForms -- TODO: Kill some ranges? (display, sig) <- eliminateDeadCode display =<< getSignature - userwarns <- useTC stLocalUserWarnings - syntaxInfo <- useTC stSyntaxInfo - optionsUsed <- useTC stPragmaOptions + userwarns <- useTC stLocalUserWarnings + importwarn <- useTC stWarningOnImport + syntaxInfo <- useTC stSyntaxInfo + optionsUsed <- useTC stPragmaOptions + partialDefs <- useTC stLocalPartialDefs -- Andreas, 2015-02-09 kill ranges in pattern synonyms before -- serialization to avoid error locations pointing to external files @@ -1119,7 +1153,7 @@ let builtin' = Map.mapWithKey (\ x b -> (x,) . primFunName <$> b) builtin warnings <- getAllWarnings AllWarnings reportSLn "import.iface" 7 " instantiating all meta variables" - i <- instantiateFull $ Interface + i <- instantiateFull Interface { iSourceHash = hashText source , iSource = source , iFileType = fileType @@ -1130,6 +1164,7 @@ , iSignature = sig , iDisplayForms = display , iUserWarnings = userwarns + , iImportWarning = importwarn , iBuiltin = builtin' , iForeignCode = foreignCode , iHighlighting = syntaxInfo @@ -1137,19 +1172,26 @@ , iOptionsUsed = optionsUsed , iPatternSyns = patsyns , iWarnings = warnings + , iPartialDefs = partialDefs } reportSLn "import.iface" 7 " interface complete" return i -- | Returns (iSourceHash, iFullHash) -getInterfaceFileHashes :: FilePath -> TCM (Maybe (Hash, Hash)) -getInterfaceFileHashes ifile = do - exist <- liftIO $ doesFileExist ifile - if not exist then return Nothing else do - (s, close) <- liftIO $ readBinaryFile' ifile - let hs = decodeHashes s - liftIO $ maybe 0 (uncurry (+)) hs `seq` close - return hs +-- We do not need to check that the file exist because we only +-- accept @InterfaceFile@ as an input and not arbitrary @AbsolutePath@! +getInterfaceFileHashes :: AbsolutePath -> TCM (Maybe (Hash, Hash)) +getInterfaceFileHashes fp = runMaybeT $ do + mifile <- MaybeT $ liftIO $ mkInterfaceFile fp + MaybeT $ getInterfaceFileHashes' mifile + +getInterfaceFileHashes' :: InterfaceFile -> TCM (Maybe (Hash, Hash)) +getInterfaceFileHashes' fp = do + let ifile = filePath $ intFilePath fp + (s, close) <- liftIO $ readBinaryFile' ifile + let hs = decodeHashes s + liftIO $ maybe 0 (uncurry (+)) hs `seq` close + return hs moduleHash :: ModuleName -> TCM Hash moduleHash m = iFullHash <$> getInterface m diff --git a/src/full/Agda/Interaction/Imports.hs-boot b/src/full/Agda/Interaction/Imports.hs-boot --- a/src/full/Agda/Interaction/Imports.hs-boot +++ b/src/full/Agda/Interaction/Imports.hs-boot @@ -3,13 +3,18 @@ import Agda.Syntax.Abstract.Name ( ModuleName ) import Agda.Syntax.Scope.Base ( Scope ) -import Agda.TypeChecking.Monad.Base ( TCM ) +import Agda.TypeChecking.Monad.Base ( TCM, TCWarning ) +import Agda.TypeChecking.Warnings ( WhichWarnings ) import Data.Map ( Map ) -data Mode +data MaybeWarnings' a = NoWarnings | SomeWarnings a +type MaybeWarnings = MaybeWarnings' [TCWarning] +instance Functor MaybeWarnings' +data Mode data MainInterface = MainInterface Mode | NotMainInterface instance Eq MainInterface scopeCheckImport :: ModuleName -> TCM (ModuleName, Map ModuleName Scope) +getMaybeWarnings :: WhichWarnings -> TCM MaybeWarnings diff --git a/src/full/Agda/Interaction/InteractionTop.hs b/src/full/Agda/Interaction/InteractionTop.hs --- a/src/full/Agda/Interaction/InteractionTop.hs +++ b/src/full/Agda/Interaction/InteractionTop.hs @@ -1,5 +1,3 @@ -{-# LANGUAGE CPP #-} - {-# OPTIONS_GHC -fno-cse #-} {-# OPTIONS_GHC -fno-warn-orphans #-} @@ -11,7 +9,6 @@ import Prelude hiding (null) -import Control.Applicative hiding (empty) import Control.Concurrent import Control.Concurrent.Async import Control.Concurrent.STM.TChan @@ -19,19 +16,13 @@ import qualified Control.Exception as E import Control.Monad.Identity import Control.Monad.Reader -import Control.Monad.State +import Control.Monad.State hiding (state) import Control.Monad.STM import qualified Data.Char as Char -import Data.Foldable (Foldable) import Data.Function import qualified Data.List as List -import Data.Maybe -import Data.Map (Map) import qualified Data.Map as Map -import Data.Monoid -import Data.Traversable (Traversable) -import qualified Data.Traversable as Trav import System.Directory import System.FilePath @@ -42,24 +33,21 @@ import qualified Agda.TypeChecking.Pretty as TCP import Agda.TypeChecking.Rules.Term (checkExpr, isType_) import Agda.TypeChecking.Errors -import Agda.TypeChecking.MetaVars.Mention +import Agda.TypeChecking.Warnings (runPM) import Agda.Syntax.Fixity import Agda.Syntax.Position import Agda.Syntax.Parser import Agda.Syntax.Common -import Agda.Syntax.Literal import Agda.Syntax.Concrete as C -import Agda.Syntax.Concrete.Generic as C -import Agda.Syntax.Concrete.Pretty () import Agda.Syntax.Abstract as A import Agda.Syntax.Abstract.Pretty -import qualified Agda.Syntax.Internal as I import Agda.Syntax.Info (mkDefInfo) import Agda.Syntax.Translation.ConcreteToAbstract import Agda.Syntax.Translation.AbstractToConcrete hiding (withScope) import Agda.Syntax.Scope.Base +import Agda.Interaction.Base import Agda.Interaction.FindFile import Agda.Interaction.Options import Agda.Interaction.Options.Lenses as Lenses @@ -71,10 +59,8 @@ import Agda.Interaction.BasicOps hiding (whyInScope) import Agda.Interaction.Highlighting.Precise hiding (Error, Postulate) import qualified Agda.Interaction.Imports as Imp -import Agda.TypeChecking.Warnings import Agda.Interaction.Highlighting.Generate import qualified Agda.Interaction.Highlighting.LaTeX as LaTeX -import qualified Agda.Interaction.Highlighting.Range as H import Agda.Compiler.Common (IsMain (..)) import Agda.Compiler.Backend @@ -84,7 +70,7 @@ import Agda.Utils.Except ( ExceptT , mkExceptT - , MonadError(catchError, throwError) + , MonadError(catchError) , runExceptT ) @@ -92,70 +78,20 @@ import Agda.Utils.FileName import Agda.Utils.Function import Agda.Utils.Hash -import qualified Agda.Utils.HashMap as HMap import Agda.Utils.Lens -import Agda.Utils.Maybe import qualified Agda.Utils.Maybe.Strict as Strict import Agda.Utils.Monad import Agda.Utils.Null -import Agda.Utils.Pretty as P +import Agda.Utils.Pretty import Agda.Utils.String import Agda.Utils.Time import Agda.Utils.Tuple -#include "undefined.h" import Agda.Utils.Impossible ------------------------------------------------------------------------ -- The CommandM monad --- | Auxiliary state of an interactive computation. - -data CommandState = CommandState - { theInteractionPoints :: [InteractionId] - -- ^ The interaction points of the buffer, in the order in which - -- they appear in the buffer. The interaction points are - -- recorded in 'theTCState', but when new interaction points are - -- added by give or refine Agda does not ensure that the ranges - -- of later interaction points are updated. - , theCurrentFile :: Maybe (AbsolutePath, ClockTime) - -- ^ The file which the state applies to. Only stored if the - -- module was successfully type checked (potentially with - -- warnings). The 'ClockTime' is the modification time stamp of - -- the file when it was last loaded. - , optionsOnReload :: CommandLineOptions - -- ^ Reset the options on each reload to these. - , oldInteractionScopes :: !OldInteractionScopes - -- ^ We remember (the scope of) old interaction points to make it - -- possible to parse and compute highlighting information for the - -- expression that it got replaced by. - , commandQueue :: !CommandQueue - -- ^ The command queue. - -- - -- This queue should only be manipulated by - -- 'initialiseCommandQueue' and 'maybeAbort'. - } - -type OldInteractionScopes = Map InteractionId ScopeInfo - --- | Initial auxiliary interaction state - -initCommandState :: CommandQueue -> CommandState -initCommandState commandQueue = - CommandState - { theInteractionPoints = [] - , theCurrentFile = Nothing - , optionsOnReload = defaultOptions - , oldInteractionScopes = Map.empty - , commandQueue = commandQueue - } - --- | Monad for computing answers to interactive commands. --- --- 'CommandM' is 'TCM' extended with state 'CommandState'. - -type CommandM = StateT CommandState TCM - -- | Restore both 'TCState' and 'CommandState'. localStateCommandM :: CommandM a -> CommandM a @@ -179,10 +115,10 @@ => (forall c . m c -> st -> k (c, st)) -- ^ run -> (forall b . k b -> m b) -- ^ lift -> (forall x . (m a -> k x) -> k x) -> m a -- ^ reverse lift in double negative position -revLift run lift f = do +revLift run lift' f = do st <- get - (a, st) <- lift $ f (`run` st) - put st + (a, st') <- lift' $ f (`run` st) + put st' return a revLiftTC @@ -190,10 +126,10 @@ => (forall c . m c -> TCState -> k (c, TCState)) -- ^ run -> (forall b . k b -> m b) -- ^ lift -> (forall x . (m a -> k x) -> k x) -> m a -- ^ reverse lift in double negative position -revLiftTC run lift f = do +revLiftTC run lift' f = do st <- getTC - (a, st) <- lift $ f (`run` st) - putTC st + (a, st') <- lift' $ f (`run` st) + putTC st' return a -- | Opposite of 'liftIO' for 'CommandM'. @@ -204,12 +140,12 @@ -- | Lift a TCM action transformer to a CommandM action transformer. -liftCommandMT :: (forall a . TCM a -> TCM a) -> CommandM a -> CommandM a +liftCommandMT :: (forall x . TCM x -> TCM x) -> CommandM a -> CommandM a liftCommandMT f m = revLift runStateT lift $ f . ($ m) -- | Ditto, but restore state. -liftCommandMTLocalState :: (forall a . TCM a -> TCM a) -> CommandM a -> CommandM a +liftCommandMTLocalState :: (forall x . TCM x -> TCM x) -> CommandM a -> CommandM a liftCommandMTLocalState f = liftCommandMT f . localStateCommandM -- | Put a response by the callback function given by 'stInteractionOutputCallback'. @@ -290,7 +226,7 @@ return x -- | Handle every possible kind of error (#637), except for - -- ThreadKilled, which is used to abort Agda. + -- AsyncCancelled, which is used to abort Agda. handleNastyErrors :: CommandM () -> CommandM () handleNastyErrors m = commandMToIO $ \ toIO -> do let handle e = @@ -320,16 +256,13 @@ let info = compress $ mconcat $ -- Errors take precedence over unsolved things. err : if unsolvedNotOK then [meta, constr] else [] - s1 <- lift $ prettyError e - s2 <- lift $ prettyTCWarnings' =<< Imp.getAllWarningsOfTCErr e - let strErr = if null s2 then s1 - else delimiter "Error" ++ "\n" ++ s1 - let strWarn = List.intercalate "\n" $ delimiter "Warning(s)" - : filter (not . null) s2 - let str = if null s2 then strErr else strErr ++ "\n\n" ++ strWarn + + -- TODO: make a better predicate for this + noError <- lift $ null <$> prettyError e + x <- lift $ optShowImplicit <$> useTC stPragmaOptions - unless (null s1) $ mapM_ putResponse $ - [ Resp_DisplayInfo $ Info_Error str ] ++ + unless noError $ mapM_ putResponse $ + [ Resp_DisplayInfo $ Info_Error $ Info_GenericError e ] ++ tellEmacsToJumpToError (getRange e) ++ [ Resp_HighlightingInfo info KeepHighlighting method modFile ] ++ @@ -346,19 +279,19 @@ runInteraction :: IOTCM -> CommandM () runInteraction (IOTCM current highlighting highlightingMethod cmd) = handleCommand inEmacs onFail $ do - current <- liftIO $ absolute current + currentAbs <- liftIO $ absolute current -- Raises an error if the given file is not the one currently -- loaded. cf <- gets theCurrentFile - when (not (independent cmd) && Just current /= (fst <$> cf)) $ + when (not (independent cmd) && Just currentAbs /= (fst <$> cf)) $ lift $ typeError $ GenericError "Error: First load the file." withCurrentFile $ interpret cmd - cf <- gets theCurrentFile + cf' <- gets theCurrentFile when (updateInteractionPointsAfter cmd && - Just current == (fst <$> cf)) $ + Just currentAbs == (fst <$> cf')) $ putResponse . Resp_InteractionPoints =<< gets theInteractionPoints where @@ -374,34 +307,6 @@ ------------------------------------------------------------------------ -- Command queues --- | A generalised command type. - -data Command' a - = Command !a - -- ^ A command. - | Done - -- ^ Stop processing commands. - | Error String - -- ^ An error message for a command that could not be parsed. - deriving Show - --- | IOTCM commands. - -type Command = Command' IOTCM - --- | Command queues. - -data CommandQueue = CommandQueue - { commands :: !(TChan (Integer, Command)) - -- ^ Commands that should be processed, in the order in which they - -- should be processed. Each command is associated with a number, - -- and the numbers are strictly increasing. Abort commands are not - -- put on this queue. - , abort :: !(TVar (Maybe Integer)) - -- ^ When this variable is set to @Just n@ an attempt is made to - -- abort all commands with a command number that is at most @n@. - } - -- | If the next command from the command queue is anything but an -- actual command, then the command is returned. -- @@ -419,8 +324,8 @@ maybeAbort m = do commandState <- get let q = commandQueue commandState - (n, c) <- liftIO $ atomically $ readTChan (commands q) - case c of + (n, cmd) <- liftIO $ atomically $ readTChan (commands q) + case cmd of Done -> return Done Error e -> return (Error e) Command c -> do @@ -430,10 +335,14 @@ (runTCM tcEnv tcState $ runStateT (m c) commandState) (waitForAbort n q) case result of - Left ((x, commandState), tcState) -> do - putTC tcState - put commandState - return (Command (Just x)) + Left ((x, commandState'), tcState') -> do + putTC tcState' + put commandState' + case c of + IOTCM _ _ _ Cmd_exit -> do + putResponse Resp_DoneExiting + return Done + _ -> return (Command (Just x)) Right a -> do liftIO $ popAbortedCommands q a putTC $ initState @@ -466,8 +375,8 @@ atomically $ do a <- readTVar (abort q) case a of - Just a | n <= a -> return a - _ -> retry + Just a' | n <= a' -> return a' + _ -> retry -- | Removes every command for which the command number is at most -- the given number (the "abort number") from the command queue. @@ -480,8 +389,8 @@ popAbortedCommands :: CommandQueue -> Integer -> IO () popAbortedCommands q n = do done <- atomically $ do - c <- tryReadTChan (commands q) - case c of + cmd <- tryReadTChan (commands q) + case cmd of Nothing -> return True Just c -> if fst c <= n then @@ -512,269 +421,18 @@ atomically $ writeTVar abort (Just n) readCommands n _ -> do - n <- return (succ n) - atomically $ writeTChan commands (n, c) + n' <- return (succ n) + atomically $ writeTChan commands (n', c) case c of Done -> return () - _ -> readCommands n + _ -> readCommands n' _ <- forkIO (readCommands 0) return (CommandQueue { .. }) ----------------------------------------------------------------------------- --- | An interactive computation. - -type Interaction = Interaction' Range - -data Interaction' range - -- | @cmd_load m argv@ loads the module in file @m@, using - -- @argv@ as the command-line options. - = Cmd_load FilePath [String] - - -- | @cmd_compile b m argv@ compiles the module in file @m@ using - -- the backend @b@, using @argv@ as the command-line options. - | Cmd_compile CompilerBackend FilePath [String] - - | Cmd_constraints - - -- | Show unsolved metas. If there are no unsolved metas but unsolved constraints - -- show those instead. - | Cmd_metas - - -- | Shows all the top-level names in the given module, along with - -- their types. Uses the top-level scope. - | Cmd_show_module_contents_toplevel - B.Rewrite - String - - -- | Shows all the top-level names in scope which mention all the given - -- identifiers in their type. - | Cmd_search_about_toplevel B.Rewrite String - - -- | Solve (all goals / the goal at point) whose values are determined by - -- the constraints. - | Cmd_solveAll B.Rewrite - | Cmd_solveOne B.Rewrite InteractionId range String - - -- | Solve (all goals / the goal at point) by using Auto. - | Cmd_autoOne InteractionId range String - | Cmd_autoAll - - -- | Parse the given expression (as if it were defined at the - -- top-level of the current module) and infer its type. - | Cmd_infer_toplevel B.Rewrite -- Normalise the type? - String - - - -- | Parse and type check the given expression (as if it were defined - -- at the top-level of the current module) and normalise it. - | Cmd_compute_toplevel B.ComputeMode - String - - ------------------------------------------------------------------------ - -- Syntax highlighting - - -- | @cmd_load_highlighting_info source@ loads syntax highlighting - -- information for the module in @source@, and asks Emacs to apply - -- highlighting info from this file. - -- - -- If the module does not exist, or its module name is malformed or - -- cannot be determined, or the module has not already been visited, - -- or the cached info is out of date, then no highlighting information - -- is printed. - -- - -- This command is used to load syntax highlighting information when a - -- new file is opened, and it would probably be annoying if jumping to - -- the definition of an identifier reset the proof state, so this - -- command tries not to do that. One result of this is that the - -- command uses the current include directories, whatever they happen - -- to be. - | Cmd_load_highlighting_info FilePath - - -- | Tells Agda to compute token-based highlighting information - -- for the file. - -- - -- This command works even if the file's module name does not - -- match its location in the file system, or if the file is not - -- scope-correct. Furthermore no file names are put in the - -- generated output. Thus it is fine to put source code into a - -- temporary file before calling this command. However, the file - -- extension should be correct. - -- - -- If the second argument is 'Remove', then the (presumably - -- temporary) file is removed after it has been read. - | Cmd_tokenHighlighting FilePath Remove - - -- | Tells Agda to compute highlighting information for the expression just - -- spliced into an interaction point. - | Cmd_highlight InteractionId range String - - ------------------------------------------------------------------------ - -- Implicit arguments - - -- | Tells Agda whether or not to show implicit arguments. - | ShowImplicitArgs Bool -- Show them? - - - -- | Toggle display of implicit arguments. - | ToggleImplicitArgs - - ------------------------------------------------------------------------ - -- | Goal commands - -- - -- If the range is 'noRange', then the string comes from the - -- minibuffer rather than the goal. - - | Cmd_give UseForce InteractionId range String - - | Cmd_refine InteractionId range String - - | Cmd_intro Bool InteractionId range String - - | Cmd_refine_or_intro Bool InteractionId range String - - | Cmd_context B.Rewrite InteractionId range String - - | Cmd_helper_function B.Rewrite InteractionId range String - - | Cmd_infer B.Rewrite InteractionId range String - - | Cmd_goal_type B.Rewrite InteractionId range String - - -- | Grabs the current goal's type and checks the expression in the hole - -- against it. Returns the elaborated term. - | Cmd_elaborate_give - B.Rewrite InteractionId range String - - -- | Displays the current goal and context. - | Cmd_goal_type_context B.Rewrite InteractionId range String - - -- | Displays the current goal and context /and/ infers the type of an - -- expression. - | Cmd_goal_type_context_infer - B.Rewrite InteractionId range String - - -- | Grabs the current goal's type and checks the expression in the hole - -- against it. - | Cmd_goal_type_context_check - B.Rewrite InteractionId range String - - -- | Shows all the top-level names in the given module, along with - -- their types. Uses the scope of the given goal. - | Cmd_show_module_contents - B.Rewrite InteractionId range String - - | Cmd_make_case InteractionId range String - - | Cmd_compute B.ComputeMode - InteractionId range String - - | Cmd_why_in_scope InteractionId range String - | Cmd_why_in_scope_toplevel String - -- | Displays version of the running Agda - | Cmd_show_version - | Cmd_abort - -- ^ Abort the current computation. - -- - -- Does nothing if no computation is in progress. - deriving (Show, Read, Functor, Foldable, Traversable) - -type IOTCM = IOTCM' Range -data IOTCM' range - = IOTCM - FilePath - -- -^ The current file. If this file does not match - -- 'theCurrentFile, and the 'Interaction' is not - -- \"independent\", then an error is raised. - HighlightingLevel - HighlightingMethod - (Interaction' range) - -- -^ What to do - deriving (Show, Read, Functor, Foldable, Traversable) - --- | Used to indicate whether something should be removed or not. - -data Remove - = Remove - | Keep - deriving (Show, Read) - --------------------------------------------------------- --- Read instances - --- | The 'Parse' monad. --- 'StateT' state holds the remaining input. - -type Parse a = ExceptT String (StateT String Identity) a - --- | Converter from the type of 'reads' to 'Parse' --- The first paramter is part of the error message --- in case the parse fails. - -readsToParse :: String -> (String -> Maybe (a, String)) -> Parse a -readsToParse s f = do - st <- lift get - case f st of - Nothing -> throwError s - Just (a, st) -> do - lift $ put st - return a - -parseToReadsPrec :: Parse a -> Int -> String -> [(a, String)] -parseToReadsPrec p i s = case runIdentity . flip runStateT s . runExceptT $ parens' p of - (Right a, s) -> [(a,s)] - _ -> [] - --- | Demand an exact string. - -exact :: String -> Parse () -exact s = readsToParse (show s) $ fmap (\x -> ((),x)) . List.stripPrefix s . dropWhile (==' ') - -readParse :: Read a => Parse a -readParse = readsToParse "read failed" $ listToMaybe . reads - -parens' :: Parse a -> Parse a -parens' p = do - exact "(" - x <- p - exact ")" - return x - `mplus` - p - -instance Read InteractionId where - readsPrec = parseToReadsPrec $ - fmap InteractionId readParse - --- | Note that the grammar implemented by this instance does not --- necessarily match the current representation of ranges. - -instance Read a => Read (Range' a) where - readsPrec = parseToReadsPrec $ - (exact "intervalsToRange" >> - liftM2 intervalsToRange readParse readParse) - `mplus` - (exact "noRange" >> return noRange) - -instance Read a => Read (Interval' a) where - readsPrec = parseToReadsPrec $ do - exact "Interval" - liftM2 Interval readParse readParse - -instance Read AbsolutePath where - readsPrec = parseToReadsPrec $ do - exact "mkAbsolute" - fmap mkAbsolute readParse - -instance Read a => Read (Position' a) where - readsPrec = parseToReadsPrec $ do - exact "Pn" - liftM4 Pn readParse readParse readParse readParse - ---------------------------------------------------------- - -- | Can the command run even if the relevant file has not been loaded -- into the state? @@ -826,6 +484,7 @@ updateInteractionPointsAfter Cmd_why_in_scope_toplevel{} = False updateInteractionPointsAfter Cmd_show_version{} = False updateInteractionPointsAfter Cmd_abort{} = False +updateInteractionPointsAfter Cmd_exit{} = False -- | Interpret an interaction @@ -834,38 +493,28 @@ interpret (Cmd_load m argv) = cmd_load' m argv True Imp.TypeCheck $ \_ -> interpret Cmd_metas -interpret (Cmd_compile b file argv) = - cmd_load' file argv (b `elem` [LaTeX, QuickLaTeX]) - (if b == QuickLaTeX +interpret (Cmd_compile backend file argv) = + cmd_load' file argv (backend `elem` [LaTeX, QuickLaTeX]) + (if backend == QuickLaTeX then Imp.ScopeCheck else Imp.TypeCheck) $ \(i, mw) -> do - mw <- lift $ Imp.applyFlagsToMaybeWarnings mw - case mw of + mw' <- lift $ Imp.applyFlagsToMaybeWarnings mw + case mw' of Imp.NoWarnings -> do - lift $ case b of + lift $ case backend of LaTeX -> LaTeX.generateLaTeX i QuickLaTeX -> LaTeX.generateLaTeX i OtherBackend "GHCNoMain" -> callBackend "GHC" NotMain i -- for backwards compatibility OtherBackend b -> callBackend b IsMain i - (pwe, pwa) <- interpretWarnings - display_info $ Info_CompilationOk pwa pwe - Imp.SomeWarnings w -> do - pw <- lift $ prettyTCWarnings w - display_info $ Info_Error $ unlines - [ "You need to fix the following errors before you can compile" - , "the module:" - , "" - , pw - ] + display_info . Info_CompilationOk =<< lift getWarningsAndNonFatalErrors + Imp.SomeWarnings w -> display_info $ Info_Error $ Info_CompilationError w interpret Cmd_constraints = - display_info . Info_Constraints . show . vcat . map pretty =<< lift B.getConstraints + display_info . Info_Constraints =<< lift B.getConstraints -interpret Cmd_metas = do -- CL.showMetas [] - unsolvedNotOK <- lift $ not . optAllowUnsolved <$> pragmaOptions - ms <- lift showOpenMetas - (pwe, pwa) <- interpretWarnings - display_info $ Info_AllGoalsWarnings (unlines ms) pwa pwe +interpret Cmd_metas = do + ms <- lift B.getGoals + display_info . Info_AllGoalsWarnings ms =<< lift getWarningsAndNonFatalErrors interpret (Cmd_show_module_contents_toplevel norm s) = liftCommandMT B.atTopLevel $ showModuleContents norm noRange s @@ -884,15 +533,25 @@ Instantiated -> Simplified _ -> norm -interpret (Cmd_infer_toplevel norm s) = - parseAndDoAtToplevel (prettyA <=< B.typeInCurrent norm) Info_InferredType s +interpret (Cmd_infer_toplevel norm s) = do + (time, expr) <- parseAndDoAtToplevel (B.typeInCurrent norm) s + state <- get + display_info $ Info_InferredType state time expr -interpret (Cmd_compute_toplevel cmode s) = - parseAndDoAtToplevel action Info_NormalForm $ computeWrapInput cmode s - where - action = allowNonTerminatingReductions - . (if computeIgnoreAbstract cmode then ignoreAbstractMode else inConcreteMode) - . (B.showComputed cmode <=< B.evalInCurrent) +interpret (Cmd_compute_toplevel cmode s) = do + (time, expr) <- parseAndDoAtToplevel action (computeWrapInput cmode s) + state <- get + display_info $ Info_NormalForm state cmode time expr + where + action = allowNonTerminatingReductions + . (if computeIgnoreAbstract cmode then ignoreAbstractMode else inConcreteMode) + . B.evalInCurrent +-- interpret (Cmd_compute_toplevel cmode s) = +-- parseAndDoAtToplevel action Info_NormalForm $ computeWrapInput cmode s +-- where +-- action = allowNonTerminatingReductions +-- . (if computeIgnoreAbstract cmode then ignoreAbstractMode else inConcreteMode) +-- . (B.showComputed cmode <=< B.evalInCurrent) interpret (ShowImplicitArgs showImpl) = do @@ -917,7 +576,7 @@ resp <- lift $ liftIO . tellToUpdateHighlighting =<< do ex <- liftIO $ doesFileExist source - absSource <- liftIO $ absolute source + absSource <- liftIO $ SourceFile <$> absolute source case ex of False -> return Nothing True -> (do @@ -945,8 +604,8 @@ if l == None then return Nothing else do - source <- liftIO (absolute source) - lift $ (Just <$> generateTokenInfo source) + source' <- liftIO (absolute source) + lift $ (Just <$> generateTokenInfo source') `catchError` \_ -> return Nothing `finally` @@ -954,8 +613,8 @@ Remove -> liftIO $ removeFile source Keep -> return () case info of - Just info -> lift $ printHighlightingInfo RemoveHighlighting info - Nothing -> return () + Just info' -> lift $ printHighlightingInfo RemoveHighlighting info' + Nothing -> return () interpret (Cmd_highlight ii rng s) = do l <- asksTC envHighlightingLevel @@ -963,21 +622,21 @@ scope <- getOldInteractionScope ii removeOldInteractionScope ii handle $ do - e <- try ("Highlighting failed to parse expression in " ++ show ii) $ + parsed <- try (Info_HighlightingParseError ii) $ B.parseExpr rng s - e <- try ("Highlighting failed to scope check expression in " ++ show ii) $ - concreteToAbstract scope e + expr <- try (Info_HighlightingScopeCheckError ii) $ + concreteToAbstract scope parsed lift $ printHighlightingInfo KeepHighlighting =<< generateTokenInfoFromString rng s - lift $ highlightExpr e + lift $ highlightExpr expr where - handle :: ExceptT String TCM () -> CommandM () + handle :: ExceptT Info_Error TCM () -> CommandM () handle m = do res <- lift $ runExceptT m case res of - Left s -> display_info $ Info_Error s + Left err -> display_info $ Info_Error err Right _ -> return () - try :: String -> TCM a -> ExceptT String TCM a + try :: Info_Error -> TCM a -> ExceptT Info_Error TCM a try err m = mkExceptT $ do (mapLeft (const err) <$> freshTCM m) `catchError` \ _ -> return (Left err) -- freshTCM to avoid scope checking creating new interaction points @@ -989,41 +648,35 @@ ss <- lift $ B.introTactic pmLambda ii liftCommandMT (B.withInteractionId ii) $ case ss of [] -> do - display_info $ Info_Intro $ "No introduction forms found." + display_info $ Info_Intro_NotFound [s] -> give_gen WithoutForce ii rng s Intro _:_:_ -> do - display_info $ Info_Intro $ - sep [ "Don't know which constructor to introduce of" - , let mkOr [] = [] - mkOr [x, y] = [text x <+> "or" <+> text y] - mkOr (x:xs) = text x : mkOr xs - in nest 2 $ fsep $ punctuate comma (mkOr ss) - ] + display_info $ Info_Intro_ConstructorUnknown ss interpret (Cmd_refine_or_intro pmLambda ii r s) = interpret $ let s' = trim s in (if null s' then Cmd_intro pmLambda else Cmd_refine) ii r s' -interpret (Cmd_autoOne ii rng s) = do +interpret (Cmd_autoOne ii rng hint) = do -- Andreas, 2014-07-05 Issue 1226: -- Save the state to have access to even those interaction ids -- that Auto solves (since Auto gives the solution right away). st <- getTC - (time , res) <- maybeTimed $ Auto.auto ii rng s + (time , res) <- maybeTimed $ Auto.auto ii rng hint case autoProgress res of Solutions sols -> do lift $ reportSLn "auto" 10 $ "Auto produced the following solutions " ++ show sols - forM_ sols $ \(ii, s) -> do + forM_ sols $ \(ii', sol) -> do -- Andreas, 2014-07-05 Issue 1226: -- For highlighting, Resp_GiveAction needs to access -- the @oldInteractionScope@s of the interaction points solved by Auto. -- We dig them out from the state before Auto was invoked. - insertOldInteractionScope ii =<< liftLocalState (putTC st >> getInteractionScope ii) + insertOldInteractionScope ii' =<< liftLocalState (putTC st >> getInteractionScope ii') -- Andreas, 2014-07-07: NOT TRUE: -- -- Andreas, 2014-07-05: The following should be obsolete, -- -- as Auto has removed the interaction points already: -- modifyTheInteractionPoints $ filter (/= ii) - putResponse $ Resp_GiveAction ii $ Give_String s + putResponse $ Resp_GiveAction ii' $ Give_String sol -- Andreas, 2014-07-07: Remove the interaction points in one go. modifyTheInteractionPoints (List.\\ (map fst sols)) case autoMessage res of @@ -1033,7 +686,7 @@ case autoMessage res of Nothing -> return () Just msg -> display_info $ Info_Auto msg - putResponse $ Resp_MakeCase R.Function cs + putResponse $ Resp_MakeCase ii R.Function cs Refinement s -> give_gen WithoutForce ii rng s Refine maybe (return ()) (display_info . Info_Time) time @@ -1055,19 +708,19 @@ modifyTheInteractionPoints (List.\\ concat solved) interpret (Cmd_context norm ii _ _) = - display_info . Info_Context =<< liftLocalState (prettyContext norm False ii) + display_info . Info_Context ii =<< liftLocalState (getResponseContext norm ii) -interpret (Cmd_helper_function norm ii rng s) = - display_info . Info_HelperFunction =<< liftLocalState (cmd_helper_function norm ii rng s) +interpret (Cmd_helper_function norm ii rng s) = do + -- Create type of application of new helper function that would solve the goal. + helperType <- liftLocalState $ B.withInteractionId ii $ inTopContext $ B.metaHelperType norm ii rng s + display_info $ Info_GoalSpecific ii (Goal_HelperFunction helperType) -interpret (Cmd_infer norm ii rng s) = - display_info . Info_InferredType - =<< liftLocalState (B.withInteractionId ii - (prettyATop =<< B.typeInMeta ii norm =<< B.parseExprIn ii rng s)) +interpret (Cmd_infer norm ii rng s) = do + expr <- liftLocalState $ B.withInteractionId ii $ B.typeInMeta ii norm =<< B.parseExprIn ii rng s + display_info $ Info_GoalSpecific ii (Goal_InferredType expr) interpret (Cmd_goal_type norm ii _ _) = - display_info . Info_CurrentGoal - =<< liftLocalState (B.withInteractionId ii $ prettyTypeOfMeta norm ii) + display_info $ Info_GoalSpecific ii (Goal_CurrentGoal norm) interpret (Cmd_elaborate_give norm ii rng s) = do have <- liftLocalState $ B.withInteractionId ii $ do @@ -1082,28 +735,30 @@ give_gen WithoutForce ii rng have ElaborateGive interpret (Cmd_goal_type_context norm ii rng s) = - cmd_goal_type_context_and empty norm ii rng s + cmd_goal_type_context_and GoalOnly norm ii rng s interpret (Cmd_goal_type_context_infer norm ii rng s) = do -- In case of the empty expression to type, don't fail with -- a stupid parse error, but just fall back to -- Cmd_goal_type_context. - have <- if all Char.isSpace s then return empty else liftLocalState $ do - typ <- B.withInteractionId ii $ - prettyATop =<< B.typeInMeta ii norm =<< B.parseExprIn ii rng s - return $ "Have:" <+> typ - cmd_goal_type_context_and have norm ii rng s + aux <- if all Char.isSpace s + then return GoalOnly + else do + typ <- liftLocalState + $ B.withInteractionId ii + $ B.typeInMeta ii norm =<< B.parseExprIn ii rng s + return (GoalAndHave typ) + cmd_goal_type_context_and aux norm ii rng s interpret (Cmd_goal_type_context_check norm ii rng s) = do - have <- liftLocalState $ B.withInteractionId ii $ do + term <- liftLocalState $ B.withInteractionId ii $ do expr <- B.parseExprIn ii rng s goal <- B.typeOfMeta AsIs ii term <- case goal of OfType _ ty -> checkExpr expr =<< isType_ ty _ -> __IMPOSSIBLE__ - txt <- TCP.prettyTCM =<< normalForm norm term - return $ "Elaborates to:" <+> txt - cmd_goal_type_context_and have norm ii rng s + normalForm norm term + cmd_goal_type_context_and (GoalAndElaboration term) norm ii rng s interpret (Cmd_show_module_contents norm ii rng s) = liftCommandMT (B.withInteractionId ii) $ showModuleContents norm rng s @@ -1111,17 +766,16 @@ interpret (Cmd_why_in_scope_toplevel s) = liftCommandMT B.atTopLevel $ whyInScope s -interpret (Cmd_why_in_scope ii rng s) = +interpret (Cmd_why_in_scope ii _range s) = liftCommandMT (B.withInteractionId ii) $ whyInScope s interpret (Cmd_make_case ii rng s) = do (f, casectxt, cs) <- lift $ makeCase ii rng s liftCommandMT (B.withInteractionId ii) $ do - hidden <- lift $ showImplicitArguments tel <- lift $ lookupSection (qnameModule f) -- don't shadow the names in this telescope unicode <- getsTC $ optUseUnicode . getPragmaOptions pcs :: [Doc] <- lift $ inTopContext $ addContext tel $ mapM prettyA cs - let pcs' :: [String] = List.map (extlam_dropName unicode casectxt . render) pcs + let pcs' :: [String] = List.map (extlam_dropName unicode casectxt . decorate) pcs lift $ reportSDoc "interaction.case" 60 $ TCP.vcat [ "InteractionTop.Cmd_make_case" , TCP.nest 2 $ TCP.vcat @@ -1136,9 +790,9 @@ [ "cs = " TCP.<+> TCP.text (show cs) ] ] - putResponse $ Resp_MakeCase (makeCaseVariant casectxt) pcs' + putResponse $ Resp_MakeCase ii (makeCaseVariant casectxt) pcs' where - render = renderStyle (style { mode = OneLineMode }) + decorate = renderStyle (style { mode = OneLineMode }) makeCaseVariant :: CaseContext -> MakeCaseVariant makeCaseVariant Nothing = R.Function @@ -1158,37 +812,20 @@ replEquals (w : ws) = w : replEquals ws replEquals [] = [] -interpret (Cmd_compute cmode ii rng s) = display_info . Info_NormalForm =<< do - liftLocalState $ do - e <- B.parseExprIn ii rng $ computeWrapInput cmode s - B.withInteractionId ii $ do - showComputed cmode =<< do applyWhen (computeIgnoreAbstract cmode) ignoreAbstractMode $ B.evalInCurrent e - +interpret (Cmd_compute cmode ii rng s) = do + expr <- liftLocalState $ do + e <- B.parseExprIn ii rng (computeWrapInput cmode s) + B.withInteractionId ii $ applyWhen (computeIgnoreAbstract cmode) ignoreAbstractMode $ B.evalInCurrent e + display_info $ Info_GoalSpecific ii (Goal_NormalForm cmode expr) interpret Cmd_show_version = display_info Info_Version interpret Cmd_abort = return () - --- | Show warnings -interpretWarnings :: CommandM (String, String) -interpretWarnings = do - mws <- lift $ Imp.getMaybeWarnings AllWarnings - case filter isNotMeta <$> mws of - Imp.SomeWarnings ws@(_:_) -> do - let (we, wa) = classifyWarnings ws - pwe <- lift $ prettyTCWarnings we - pwa <- lift $ prettyTCWarnings wa - return (pwe, pwa) - _ -> return ("", "") - where isNotMeta w = case tcWarning w of - UnsolvedInteractionMetas{} -> False - UnsolvedMetaVariables{} -> False - _ -> True - +interpret Cmd_exit = return () -- | Solved goals already instantiated internally -- The second argument potentially limits it to one specific goal. -solveInstantiatedGoals :: B.Rewrite -> Maybe InteractionId -> CommandM () +solveInstantiatedGoals :: Rewrite -> Maybe InteractionId -> CommandM () solveInstantiatedGoals norm mii = do -- Andreas, 2016-10-23 issue #2280: throw away meta elims. out <- lift $ localTC (\ e -> e { envPrintMetasBare = True }) $ do @@ -1200,35 +837,8 @@ where prt (i, m, e) = do mi <- getMetaInfo <$> lookupMeta m - e <- withMetaInfo mi $ abstractToConcreteCtx TopCtx e - return (i, e) - - --- | Print open metas nicely. -showOpenMetas :: TCM [String] -showOpenMetas = do - ims <- B.typesOfVisibleMetas B.AsIs - di <- forM ims $ \ i -> - B.withInteractionId (B.outputFormId $ B.OutputForm noRange [] i) $ - prettyATop i - -- Show unsolved implicit arguments simplified. - unsolvedNotOK <- not . optAllowUnsolved <$> pragmaOptions - hms <- (guard unsolvedNotOK >>) <$> B.typesOfHiddenMetas B.Simplified - dh <- mapM showA' hms - return $ map show di ++ dh - where - metaId (B.OfType i _) = i - metaId (B.JustType i) = i - metaId (B.JustSort i) = i - metaId (B.Assign i e) = i - metaId _ = __IMPOSSIBLE__ - showA' :: B.OutputConstraint A.Expr NamedMeta -> TCM String - showA' m = do - let i = nmid $ metaId m - r <- getMetaRange i - d <- B.withMetaId i (prettyATop m) - return $ show d ++ " [ at " ++ show r ++ " ]" - + e' <- withMetaInfo mi $ abstractToConcreteCtx TopCtx e + return (i, e') -- | @cmd_load' file argv unsolvedOk cmd@ -- loads the module in file @file@, @@ -1245,8 +855,8 @@ -> ((Interface, Imp.MaybeWarnings) -> CommandM ()) -> CommandM () cmd_load' file argv unsolvedOK mode cmd = do - f <- liftIO $ absolute file - ex <- liftIO $ doesFileExist $ filePath f + f <- liftIO $ SourceFile <$> absolute file + ex <- liftIO $ doesFileExist $ filePath (srcFilePath f) unless ex $ typeError $ GenericError $ "The file " ++ file ++ " was not found." @@ -1269,7 +879,7 @@ Left err -> lift $ typeError $ GenericError err Right (_, opts) -> do let update o = o { optAllowUnsolved = unsolvedOK && optAllowUnsolved o} - root = projectRoot f (Imp.siModuleName si) + root = projectRoot (srcFilePath f) (Imp.siModuleName si) lift $ TM.setCommandLineOptions' root $ mapPragmaOptions update opts displayStatus @@ -1295,7 +905,7 @@ when (t == t') $ do is <- lift $ sortInteractionPoints =<< getInteractionPoints modify $ \st -> st { theInteractionPoints = is - , theCurrentFile = Just (f, t) + , theCurrentFile = Just (srcFilePath f, t) } cmd ok @@ -1306,25 +916,6 @@ mfile <- fmap fst <$> gets theCurrentFile localTC (\ e -> e { envCurrentPath = mfile }) m --- | Available backends. - -data CompilerBackend = LaTeX | QuickLaTeX | OtherBackend String - deriving (Eq) - -instance Show CompilerBackend where - show LaTeX = "LaTeX" - show QuickLaTeX = "QuickLaTeX" - show (OtherBackend s) = s - -instance Read CompilerBackend where - readsPrec _ s = do - (t, s) <- lex s - let b = case t of - "LaTeX" -> LaTeX - "QuickLaTeX" -> QuickLaTeX - _ -> OtherBackend t - return (b, s) - data GiveRefine = Give | Refine | Intro | ElaborateGive deriving (Eq, Show) @@ -1371,13 +962,13 @@ insertOldInteractionScope ii scope -- sort the new interaction points and put them into the state -- in replacement of the old interaction point - iis <- lift $ sortInteractionPoints iis - modifyTheInteractionPoints $ replace ii iis + iis' <- lift $ sortInteractionPoints iis + modifyTheInteractionPoints $ replace ii iis' -- print abstract expr ce <- lift $ abstractToConcreteScope scope ae - lift $ reportSLn "interaction.give" 30 $ unlines + lift $ reportS "interaction.give" 30 [ "ce = " ++ show ce - , "scopePrecedence = " ++ show (scopePrecedence scope) + , "scopePrecedence = " ++ show (scope ^. scopePrecedence) ] -- if the command was @Give@, use the literal user input; -- Andreas, 2014-01-15, see issue 1020: @@ -1415,9 +1006,9 @@ highlightExpr :: A.Expr -> TCM () highlightExpr e = - localTC (\e -> e { envModuleNestingLevel = 0 - , envHighlightingLevel = NonInteractive - , envHighlightingMethod = Direct }) $ + localTC (\st -> st { envModuleNestingLevel = 0 + , envHighlightingLevel = NonInteractive + , envHighlightingMethod = Direct }) $ generateAndPrintSyntaxInfo decl Full True where dummy = mkName_ (NameId 0 0) ("dummy" :: String) @@ -1432,186 +1023,45 @@ forM is $ \ i -> do (i,) <$> getInteractionRange i --- | Pretty-prints the type of the meta-variable. - -prettyTypeOfMeta :: B.Rewrite -> InteractionId -> TCM Doc -prettyTypeOfMeta norm ii = do - form <- B.typeOfMeta norm ii - case form of - B.OfType _ e -> prettyATop e - _ -> prettyATop form - --- | Pretty-prints the context of the given meta-variable. - -prettyContext - :: B.Rewrite -- ^ Normalise? - -> Bool -- ^ Print the elements in reverse order? - -> InteractionId - -> TCM Doc -prettyContext norm rev ii = B.withInteractionId ii $ do - ctx <- filter (not . shouldHide) <$> B.contextOfMeta ii norm - es <- mapM (prettyATop . B.ofExpr) ctx - xs <- mapM (abstractToConcrete_ . B.ofName) ctx - let ns = map (nameConcrete . B.ofName) ctx - ss = map C.isInScope xs - return $ align 10 $ applyWhen rev reverse $ - zip (zipWith prettyCtxName ns xs) - (zipWith prettyCtxType es ss) - where - shouldHide (OfType' n e) = isNoName n || nameIsRecordName n - prettyCtxName :: C.Name -> C.Name -> String - prettyCtxName n x - | n == x = prettyShow x - | isInScope n == InScope = prettyShow n ++ " = " ++ prettyShow x - | otherwise = prettyShow x - prettyCtxType e nis = ":" <+> (e P.<> notInScopeMarker nis) - notInScopeMarker nis = case isInScope nis of - C.InScope -> "" - C.NotInScope -> " (not in scope)" - --- | Create type of application of new helper function that would solve the goal. - -cmd_helper_function :: B.Rewrite -> InteractionId -> Range -> String -> TCM Doc -cmd_helper_function norm ii r s = B.withInteractionId ii $ inTopContext $ - prettyATop =<< B.metaHelperType norm ii r s - -- | Displays the current goal, the given document, and the current -- context. -- -- Should not modify the state. -cmd_goal_type_context_and :: Doc -> B.Rewrite -> InteractionId -> Range -> - String -> StateT CommandState (TCMT IO) () -cmd_goal_type_context_and doc norm ii _ _ = display_info . Info_GoalType =<< do - lift $ do - goal <- B.withInteractionId ii $ prettyTypeOfMeta norm ii - ctx <- prettyContext norm True ii - m <- lookupInteractionId ii - constr <- vcat . map pretty <$> B.getConstraints' (mentionsMeta m) - let constrDoc = ifNull constr [] $ \constr -> - [ text $ delimiter "Constraints" - , constr - ] - return $ vcat $ - [ "Goal:" <+> goal - , doc - , text (replicate 60 '\x2014') - , ctx - ] ++ constrDoc +cmd_goal_type_context_and :: GoalTypeAux -> Rewrite -> InteractionId -> Range -> + String -> CommandM () +cmd_goal_type_context_and aux norm ii _ _ = do + ctx <- lift $ getResponseContext norm ii + constr <- lift $ lookupInteractionId ii >>= B.getConstraintsMentioning norm + boundary <- lift $ B.getIPBoundary norm ii + display_info $ Info_GoalSpecific ii (Goal_GoalType norm aux ctx boundary constr) -- | Shows all the top-level names in the given module, along with -- their types. -showModuleContents :: B.Rewrite -> Range -> String -> CommandM () -showModuleContents norm rng s = display_info . Info_ModuleContents =<< do - liftLocalState $ do - (modules, tel, types) <- B.moduleContents norm rng s - types' <- addContext tel $ forM types $ \ (x, t) -> do - t <- TCP.prettyTCM t - return (prettyShow x, ":" <+> t) - return $ vcat - [ "Modules" - , nest 2 $ vcat $ map pretty modules - , "Names" - , nest 2 $ align 10 types' - ] +showModuleContents :: Rewrite -> Range -> String -> CommandM () +showModuleContents norm rng s = do + (modules, tel, types) <- lift $ B.moduleContents norm rng s + display_info $ Info_ModuleContents modules tel types -- | Shows all the top-level names in scope which mention all the given -- identifiers in their type. -searchAbout :: B.Rewrite -> Range -> String -> CommandM () -searchAbout norm rg nm = do - let tnm = trim nm - unless (null tnm) $ do - fancy <- lift $ B.atTopLevel $ do - hits <- findMentions norm rg tnm - forM hits $ \ (x, t) -> do - t <- TCP.prettyTCM t - return (prettyShow x, ":" <+> t) - display_info $ Info_SearchAbout $ - "Definitions about" <+> text (List.intercalate ", " $ words nm) $$ - nest 2 (align 10 fancy) +searchAbout :: Rewrite -> Range -> String -> CommandM () +searchAbout norm rg names = do + let trimmedNames = trim names + unless (null trimmedNames) $ do + hits <- lift $ B.atTopLevel $ findMentions norm rg trimmedNames + display_info $ Info_SearchAbout hits trimmedNames -- | Explain why something is in scope. whyInScope :: String -> CommandM () -whyInScope s = display_info . Info_WhyInScope =<< do +whyInScope s = do Just (file, _) <- gets theCurrentFile - let cwd = takeDirectory $ filePath file - liftLocalState $ do - (v, xs, ms) <- B.whyInScope s - explanation cwd v xs ms - where - explanation _ Nothing [] [] = TCP.text (s ++ " is not in scope.") - explanation cwd v xs ms = TCP.vcat - [ TCP.text (s ++ " is in scope as") - , TCP.nest 2 $ TCP.vcat [variable v xs, modules ms] - ] - where - prettyRange :: Range -> TCM Doc - prettyRange r = pretty . (fmap . fmap) mkRel <$> do - return r - mkRel = makeRelative cwd . filePath - - -- variable :: Maybe _ -> [_] -> TCM Doc - variable Nothing xs = names xs - variable (Just x) xs - | null xs = asVar - | otherwise = TCP.vcat - [ TCP.sep [ asVar, TCP.nest 2 $ shadowing x] - , TCP.nest 2 $ names xs - ] - where - asVar :: TCM Doc - asVar = do - "* a variable bound at" TCP.<+> TCP.prettyTCM (nameBindingSite $ localVar x) - shadowing :: LocalVar -> TCM Doc - shadowing (LocalVar _ _ []) = "shadowing" - shadowing _ = "in conflict with" - names xs = TCP.vcat $ map pName xs - modules ms = TCP.vcat $ map pMod ms - - pKind DefName = "defined name" - pKind ConName = "constructor" - pKind FldName = "record field" - pKind PatternSynName = "pattern synonym" - pKind GeneralizeName = "generalizable variable" - pKind DisallowedGeneralizeName = "generalizable variable from let open" - pKind MacroName = "macro name" - pKind QuotableName = "quotable name" - - pName :: AbstractName -> TCM Doc - pName a = TCP.sep - [ "* a" - TCP.<+> pKind (anameKind a) - TCP.<+> TCP.text (prettyShow $ anameName a) - , TCP.nest 2 $ "brought into scope by" - ] TCP.$$ - TCP.nest 2 (pWhy (nameBindingSite $ qnameName $ anameName a) (anameLineage a)) - pMod :: AbstractModule -> TCM Doc - pMod a = TCP.sep - [ "* a module" TCP.<+> TCP.text (prettyShow $ amodName a) - , TCP.nest 2 $ "brought into scope by" - ] TCP.$$ - TCP.nest 2 (pWhy (nameBindingSite $ qnameName $ mnameToQName $ amodName a) (amodLineage a)) - - pWhy :: Range -> WhyInScope -> TCM Doc - pWhy r Defined = "- its definition at" TCP.<+> TCP.prettyTCM r - pWhy r (Opened (C.QName x) w) | isNoName x = pWhy r w - pWhy r (Opened m w) = - "- the opening of" - TCP.<+> TCP.prettyTCM m - TCP.<+> "at" - TCP.<+> TCP.prettyTCM (getRange m) - TCP.$$ - pWhy r w - pWhy r (Applied m w) = - "- the application of" - TCP.<+> TCP.prettyTCM m - TCP.<+> "at" - TCP.<+> TCP.prettyTCM (getRange m) - TCP.$$ - pWhy r w + let cwd = takeDirectory (filePath file) + (v, xs, ms) <- liftLocalState (B.whyInScope s) + display_info $ Info_WhyInScope s cwd v xs ms -- | Sets the command line options and updates the status information. @@ -1666,41 +1116,30 @@ displayStatus putResponse $ Resp_DisplayInfo info -refreshStr :: [String] -> String -> ([String], String) -refreshStr taken s = go nameModifiers where - go (m:mods) = let s' = s ++ m in - if s' `elem` taken then go mods else (s':taken, s') - go _ = __IMPOSSIBLE__ - -nameModifiers :: [String] -nameModifiers = "" : "'" : "''" : [show i | i <-[3..]] - - -- | Parses and scope checks an expression (using the \"inside scope\" -- as the scope), performs the given command with the expression as --- input, and displays the result. +-- input, and returns the result and the time it takes. parseAndDoAtToplevel - :: (A.Expr -> TCM Doc) + :: (A.Expr -> TCM a) -- ^ The command to perform. - -> (Doc -> DisplayInfo) - -- ^ The name to use for the buffer displaying the output. -> String -- ^ The expression to parse. - -> CommandM () -parseAndDoAtToplevel cmd title s = do - (time, res) <- localStateCommandM $ do + -> CommandM (Maybe CPUTime, a) +parseAndDoAtToplevel cmd s = do + localStateCommandM $ do e <- lift $ runPM $ parse exprParser s maybeTimed $ lift $ B.atTopLevel $ do cmd =<< concreteToAbstract_ e - display_info $ title $ fromMaybe empty time $$ res -maybeTimed :: CommandM a -> CommandM (Maybe Doc, a) +maybeTimed :: CommandM a -> CommandM (Maybe CPUTime, a) maybeTimed work = do doTime <- lift $ hasVerbosity "profile.interactive" 10 - if not doTime then (Nothing,) <$> work else do - (r, time) <- measureTime work - return (Just $ "Time:" <+> pretty time, r) + if not doTime + then (Nothing,) <$> work + else do + (r, time) <- measureTime work + return (Just time, r) -- | Tell to highlight the code using the given highlighting -- info (unless it is @Nothing@). diff --git a/src/full/Agda/Interaction/InteractionTop.hs-boot b/src/full/Agda/Interaction/InteractionTop.hs-boot deleted file mode 100644 --- a/src/full/Agda/Interaction/InteractionTop.hs-boot +++ /dev/null @@ -1,5 +0,0 @@ -module Agda.Interaction.InteractionTop where - -import Agda.TypeChecking.Monad.Base (TCM) - -showOpenMetas :: TCM [String] diff --git a/src/full/Agda/Interaction/JSON.hs b/src/full/Agda/Interaction/JSON.hs new file mode 100644 --- /dev/null +++ b/src/full/Agda/Interaction/JSON.hs @@ -0,0 +1,125 @@ +{-# LANGUAGE OverloadedStrings #-} + +-- | Encoding stuff into JSON values in TCM + +module Agda.Interaction.JSON + ( EncodeTCM(..) + , obj, kind, kind' + , (@=), (#=) + , (>=>), (<=<) + -- , ToRep(..), rep + ) where + +import Control.Monad ((>=>), (<=<), sequence, liftM2) +import Data.Aeson +import Data.Aeson.Types (Pair) +import Data.Text (Text) +import GHC.Int (Int32) + +-- import qualified Agda.Syntax.Translation.InternalToAbstract as I2A +-- import qualified Agda.Syntax.Translation.AbstractToConcrete as A2C + +-- import qualified Agda.Syntax.Concrete as C +-- import qualified Agda.Syntax.Internal as I +import Agda.TypeChecking.Monad +import Agda.TypeChecking.Pretty (PrettyTCM(..)) +import Agda.Utils.Pretty +import qualified Agda.Utils.FileName as File +import qualified Agda.Utils.Maybe.Strict as Strict + +--------------------------------------------------------------------------- +-- * The EncodeTCM class + +-- | The JSON version of`PrettyTCM`, for encoding JSON value in TCM +class EncodeTCM a where + encodeTCM :: a -> TCM Value + default encodeTCM :: ToJSON a => a -> TCM Value + encodeTCM = pure . toJSON + +-- | TCM monadic version of object +obj :: [TCM Pair] -> TCM Value +obj = (object <$>) . sequence + +-- | Pairs a key with a value wrapped in TCM +(#=) :: (ToJSON a) => Text -> TCM a -> TCM Pair +(#=) key boxed = do + value <- boxed + pure $ key .= toJSON value + +-- | Abbreviation of `_ #= encodeTCM _` +(@=) :: (EncodeTCM a) => Text -> a -> TCM Pair +(@=) key value = do + encoded <- encodeTCM value + pure $ key .= encoded + +-- | A handy alternative of `obj` with kind specified +kind :: Text -> [TCM Pair] -> TCM Value +kind k = obj . (("kind" @= String k) :) + +-- | A handy alternative of `object` with kind specified +kind' :: Text -> [Pair] -> Value +kind' k = object . (("kind" .= String k) :) + +-- --------------------------------------------------------------------------- +-- -- * The Rep & ToRep class +-- +-- -- | Translates internal types to concrete types +-- class ToRep i c | i -> c where +-- toRep :: i -> TCM c +-- +-- instance ToRep I.Term C.Expr where +-- toRep internal = I2A.reify internal >>= A2C.abstractToConcrete_ +-- +-- instance ToRep I.Type C.Expr where +-- toRep internal = I2A.reify internal >>= A2C.abstractToConcrete_ +-- +-- data Rep internal concrete = Rep +-- { internalRep :: internal +-- , concreteRep :: concrete +-- } +-- +-- instance (ToJSON i, ToJSON c) => ToJSON (Rep i c) where +-- toJSON (Rep i c) = object +-- [ "internal" .= i +-- , "concrete" .= c +-- ] +-- +-- rep :: (ToRep i c) => i -> TCM (Rep i c) +-- rep internal = do +-- concrete <- toRep internal +-- return $ Rep +-- { internalRep = internal +-- , concreteRep = concrete +-- } + +-------------------------------------------------------------------------------- +-- Instances of ToJSON or EncodeTCM + +encodeListTCM :: EncodeTCM a => [a] -> TCM Value +encodeListTCM = mapM encodeTCM >=> return . toJSONList + +instance EncodeTCM a => EncodeTCM [a] where + encodeTCM = mapM encodeTCM >=> return . toJSONList + +-- overlaps with the instance declared above +instance {-# OVERLAPPING #-} EncodeTCM String + +instance EncodeTCM Bool where +instance EncodeTCM Int where +instance EncodeTCM Int32 where +instance EncodeTCM Value where +instance EncodeTCM Doc where + +instance ToJSON Doc where + toJSON = toJSON . render + +instance EncodeTCM a => EncodeTCM (Maybe a) where + encodeTCM Nothing = return Null + encodeTCM (Just a) = encodeTCM a + +instance ToJSON File.AbsolutePath where + toJSON (File.AbsolutePath path) = toJSON path + +instance ToJSON a => ToJSON (Strict.Maybe a) where + toJSON (Strict.Just a) = toJSON a + toJSON Strict.Nothing = Null diff --git a/src/full/Agda/Interaction/JSONTop.hs b/src/full/Agda/Interaction/JSONTop.hs --- a/src/full/Agda/Interaction/JSONTop.hs +++ b/src/full/Agda/Interaction/JSONTop.hs @@ -2,131 +2,380 @@ ( jsonREPL ) where import Control.Monad.State +import Control.Monad import Data.Aeson hiding (Result(..)) import Data.ByteString.Lazy (ByteString) import qualified Data.ByteString.Lazy.Char8 as BS +import qualified Data.Text as T import Agda.Interaction.AgdaTop +import Agda.Interaction.Base + (CommandState(..), ComputeMode(..), Rewrite(..), OutputForm(..), OutputConstraint(..)) +import qualified Agda.Interaction.BasicOps as B +import Agda.Interaction.EmacsTop +import Agda.Interaction.JSON import Agda.Interaction.Response as R -import Agda.Interaction.EmacsCommand hiding (putResponse) import Agda.Interaction.Highlighting.JSON -import Agda.Interaction.Highlighting.Precise (TokenBased(..)) +import qualified Agda.Syntax.Abstract as A +import Agda.Syntax.Abstract.Pretty (prettyATop) import Agda.Syntax.Common -import Agda.TypeChecking.Monad -import Agda.Utils.Pretty +import qualified Agda.Syntax.Concrete as C +import Agda.Syntax.Concrete.Name (NameInScope(..), Name) +import Agda.Syntax.Internal (telToList, Dom'(..), Dom) +import Agda.Syntax.Position (noRange, Range, rangeIntervals, Interval'(..), Position'(..)) import Agda.VersionCommit ----------------------------------- +import Agda.TypeChecking.Monad (Comparison(..), inTopContext, ProblemId(..), TCM) +import Agda.TypeChecking.Monad.MetaVars (getInteractionRange) +import Agda.TypeChecking.Pretty (PrettyTCM(..), prettyTCM) +-- borrowed from EmacsTop, for temporarily serialising stuff +import Agda.TypeChecking.Pretty.Warning (prettyTCWarnings, prettyTCWarnings') +import Agda.TypeChecking.Warnings (WarningsAndNonFatalErrors(..)) +import Agda.Utils.Pretty (Pretty(..), render) +import Agda.Utils.Time (CPUTime(..)) +-------------------------------------------------------------------------------- + -- | 'jsonREPL' is a interpreter like 'mimicGHCi', but outputs JSON-encoded strings. -- -- 'jsonREPL' reads Haskell values (that starts from 'IOTCM' ...) from stdin, -- interprets them, and outputs JSON-encoded strings. into stdout. jsonREPL :: TCM () -> TCM () -jsonREPL = repl (liftIO . BS.putStrLn <=< liftIO . jsonifyResponse) "JSON> " +jsonREPL = repl (liftIO . BS.putStrLn <=< jsonifyResponse) "JSON> " +instance EncodeTCM NameInScope where +instance ToJSON NameInScope where + toJSON InScope = toJSON True + toJSON NotInScope = toJSON False + +instance EncodeTCM Status where instance ToJSON Status where toJSON status = object [ "showImplicitArguments" .= sShowImplicitArguments status - , "checked" .= sChecked status + , "checked" .= sChecked status ] +instance EncodeTCM CommandState where +instance ToJSON CommandState where + toJSON commandState = object + [ "interactionPoints" .= theInteractionPoints commandState + , "currentFile" .= theCurrentFile commandState + -- more? + ] + +instance EncodeTCM ResponseContextEntry where + encodeTCM entry = obj + [ "originalName" @= encodePretty (respOrigName entry) + , "reifiedName" @= encodePretty (respReifName entry) + , "binding" #= encodePrettyTCM (respType entry) + , "inScope" @= respInScope entry + ] + +instance EncodeTCM (Position' ()) where +instance ToJSON (Position' ()) where + toJSON p = object + [ "pos" .= toJSON (posPos p) + , "line" .= toJSON (posLine p) + , "col" .= toJSON (posCol p) + ] + +instance EncodeTCM Range where +instance ToJSON Range where + toJSON = toJSON . map prettyInterval . rangeIntervals + where prettyInterval i = object [ "start" .= iStart i, "end" .= iEnd i ] + +instance EncodeTCM ProblemId where +instance ToJSON ProblemId where + toJSON (ProblemId i) = toJSON i + +instance EncodeTCM InteractionId where + encodeTCM ii@(InteractionId i) = obj + [ "id" @= toJSON i + , "range" #= intervalsTCM + ] + where + intervalsTCM = toJSON <$> getInteractionRange ii instance ToJSON InteractionId where toJSON (InteractionId i) = toJSON i +instance EncodeTCM GiveResult where instance ToJSON GiveResult where - toJSON (Give_String s) = toJSON s - toJSON Give_Paren = toJSON True - toJSON Give_NoParen = toJSON False + toJSON (Give_String s) = object [ "str" .= s ] + toJSON Give_Paren = object [ "paren" .= True ] + toJSON Give_NoParen = object [ "paren" .= False ] +instance EncodeTCM MakeCaseVariant where instance ToJSON MakeCaseVariant where toJSON R.Function = String "Function" toJSON R.ExtendedLambda = String "ExtendedLambda" -instance ToJSON DisplayInfo where - toJSON (Info_CompilationOk warnings errors) = object - [ "kind" .= String "CompilationOk" - , "warnings" .= warnings - , "errors" .= errors - ] - toJSON (Info_Constraints constraints) = object - [ "kind" .= String "Constraints" - , "constraints" .= constraints - ] - toJSON (Info_AllGoalsWarnings goals warnings errors) = object - [ "kind" .= String "AllGoalsWarnings" - , "goals" .= goals - , "warnings" .= warnings - , "errors" .= errors - ] - toJSON (Info_Time doc) = object [ "kind" .= String "Time", "payload" .= render doc ] - toJSON (Info_Error msg) = object [ "kind" .= String "Error", "payload" .= msg ] - toJSON (Info_Intro doc) = object [ "kind" .= String "Intro", "payload" .= render doc ] - toJSON (Info_Auto msg) = object [ "kind" .= String "Auto", "payload" .= msg ] - toJSON (Info_ModuleContents doc) = object [ "kind" .= String "ModuleContents", "payload" .= render doc ] - toJSON (Info_SearchAbout doc) = object [ "kind" .= String "SearchAbout", "payload" .= render doc ] - toJSON (Info_WhyInScope doc) = object [ "kind" .= String "WhyInScope", "payload" .= render doc ] - toJSON (Info_NormalForm doc) = object [ "kind" .= String "NormalForm", "payload" .= render doc ] - toJSON (Info_GoalType doc) = object [ "kind" .= String "GoalType", "payload" .= render doc ] - toJSON (Info_CurrentGoal doc) = object [ "kind" .= String "CurrentGoal", "payload" .= render doc ] - toJSON (Info_InferredType doc) = object [ "kind" .= String "InferredType", "payload" .= render doc ] - toJSON (Info_Context doc) = object [ "kind" .= String "Context", "payload" .= render doc ] - toJSON (Info_HelperFunction doc) = object [ "kind" .= String "HelperFunction", "payload" .= render doc ] - toJSON Info_Version = object - [ "kind" .= String "Version" - , "version" .= (("Agda version " ++ versionWithCommitInfo) :: String) - ] +encodePretty :: Pretty a => a -> Value +encodePretty = encodeShow . pretty --- | Convert Response to an JSON value for interactive editor frontends. -jsonifyResponse :: Response -> IO ByteString -jsonifyResponse (Resp_HighlightingInfo info remove method modFile) = - encode <$> jsonifyHighlightingInfo info remove method modFile -jsonifyResponse (Resp_DisplayInfo info) = return $ encode $ object - [ "kind" .= String "DisplayInfo" - , "info" .= info +encodeShow :: Show a => a -> Value +encodeShow = String . T.pack . show + +encodePrettyTCM :: PrettyTCM a => a -> TCM Value +encodePrettyTCM = (encodeShow <$>) . prettyTCM + +instance EncodeTCM Rewrite where +instance ToJSON Rewrite where toJSON = encodeShow + +instance EncodeTCM CPUTime where +instance ToJSON CPUTime where toJSON = encodePretty + +instance EncodeTCM ComputeMode where +instance ToJSON ComputeMode where toJSON = encodeShow + +encodeOCCmp :: (a -> Value) + -> Comparison -> a -> a -> T.Text + -> TCM Value +encodeOCCmp f c i j k = kind k + [ "comparison" @= encodeShow c + , "constraintObjs" @= map f [i, j] ] -jsonifyResponse (Resp_ClearHighlighting tokenBased) = return $ encode $ object - [ "kind" .= String "ClearHighlighting" - , "tokenBased" .= tokenBased + + -- Goals +encodeOC :: (a -> Value) + -> (b -> TCM Value) + -> OutputConstraint b a + -> TCM Value +encodeOC f encodePrettyTCM = \case + OfType i a -> kind "OfType" + [ "constraintObj" @= f i + , "type" #= encodePrettyTCM a ] -jsonifyResponse Resp_DoneAborting = return $ encode $ object [ "kind" .= String "DoneAborting" ] -jsonifyResponse Resp_ClearRunningInfo = return $ encode $ object [ "kind" .= String "ClearRunningInfo" ] -jsonifyResponse (Resp_RunningInfo debugLevel msg) = return $ encode $ object - [ "kind" .= String "RunningInfo" - , "debugLevel" .= debugLevel - , "message" .= msg + CmpInType c a i j -> kind "CmpInType" + [ "comparison" @= encodeShow c + , "type" #= encodePrettyTCM a + , "constraintObjs" @= map f [i, j] ] -jsonifyResponse (Resp_Status status) = return $ encode $ object - [ "kind" .= String "Status" - , "status" .= status + CmpElim ps a is js -> kind "CmpElim" + [ "polarities" @= map encodeShow ps + , "type" #= encodePrettyTCM a + , "constraintObjs" @= map (map f) [is, js] ] -jsonifyResponse (Resp_JumpToError filepath position) = return $ encode $ object - [ "kind" .= String "JumpToError" - , "filepath" .= filepath - , "position" .= position + JustType a -> kind "JustType" + [ "constraintObj" @= f a ] -jsonifyResponse (Resp_InteractionPoints interactionPoints) = return $ encode $ object - [ "kind" .= String "InteractionPoints" - , "interactionPoints" .= interactionPoints + JustSort a -> kind "JustSort" + [ "constraintObj" @= f a ] -jsonifyResponse (Resp_GiveAction i giveResult) = return $ encode $ object - [ "kind" .= String "GiveAction" - , "interactionPoint" .= i - , "giveResult" .= giveResult + CmpTypes c i j -> encodeOCCmp f c i j "CmpTypes" + CmpLevels c i j -> encodeOCCmp f c i j "CmpLevels" + CmpTeles c i j -> encodeOCCmp f c i j "CmpTeles" + CmpSorts c i j -> encodeOCCmp f c i j "CmpSorts" + Guard oc a -> kind "Guard" + [ "constraint" #= encodeOC f encodePrettyTCM oc + , "problem" @= a ] -jsonifyResponse (Resp_MakeCase variant clauses) = return $ encode $ object - [ "kind" .= String "MakeCase" - , "variant" .= variant - , "clauses" .= clauses + Assign i a -> kind "Assign" + [ "constraintObj" @= f i + , "value" #= encodePrettyTCM a ] -jsonifyResponse (Resp_SolveAll solutions) = return $ encode $ object - [ "kind" .= String "SolveAll" - , "solutions" .= map encodeSolution solutions + TypedAssign i v t -> kind "TypedAssign" + [ "constraintObj" @= f i + , "value" #= encodePrettyTCM v + , "type" #= encodePrettyTCM t ] + PostponedCheckArgs i es t0 t1 -> kind "PostponedCheckArgs" + [ "constraintObj" @= f i + , "ofType" #= encodePrettyTCM t0 + , "arguments" #= forM es encodePrettyTCM + , "type" #= encodePrettyTCM t1 + ] + IsEmptyType a -> kind "IsEmptyType" + [ "type" #= encodePrettyTCM a + ] + SizeLtSat a -> kind "SizeLtSat" + [ "type" #= encodePrettyTCM a + ] + FindInstanceOF i t cs -> kind "FindInstanceOF" + [ "constraintObj" @= f i + , "candidates" #= forM cs encodeKVPairs + , "type" #= encodePrettyTCM t + ] + where encodeKVPairs (v, t) = obj + [ "value" #= encodePrettyTCM v + , "type" #= encodePrettyTCM t + ] + PTSInstance a b -> kind "PTSInstance" + [ "constraintObjs" @= map f [a, b] + ] + PostponedCheckFunDef name a -> kind "PostponedCheckFunDef" + [ "name" @= encodePretty name + , "type" #= encodePrettyTCM a + ] + +encodeNamedPretty :: PrettyTCM a => (Name, a) -> TCM Value +encodeNamedPretty (name, a) = obj + [ "name" @= encodePretty name + , "term" #= encodePrettyTCM a + ] + +instance EncodeTCM (OutputForm C.Expr C.Expr) where + encodeTCM (OutputForm range problems oc) = obj + [ "range" @= range + , "problems" @= problems + , "constraint" #= encodeOC encodeShow (pure . encodeShow) oc + ] + +instance EncodeTCM DisplayInfo where + encodeTCM (Info_CompilationOk wes) = kind "CompilationOk" + [ "warnings" #= prettyTCWarnings (tcWarnings wes) + , "errors" #= prettyTCWarnings (nonFatalErrors wes) + ] + encodeTCM (Info_Constraints constraints) = kind "Constraints" + [ "constraints" #= forM constraints encodeTCM + ] + encodeTCM (Info_AllGoalsWarnings (vis, invis) wes) = kind "AllGoalsWarnings" + [ "visibleGoals" #= forM vis (encodeOC toJSON encodePrettyTCM) + , "invisibleGoals" #= forM invis (encodeOC encodePretty encodePrettyTCM) + , "warnings" #= prettyTCWarnings (tcWarnings wes) + , "errors" #= prettyTCWarnings (nonFatalErrors wes) + ] + encodeTCM (Info_Time time) = kind "Time" + [ "time" @= time + ] + encodeTCM (Info_Error msg) = kind "Error" + [ "message" #= showInfoError msg + ] + encodeTCM Info_Intro_NotFound = kind "IntroNotFound" [] + encodeTCM (Info_Intro_ConstructorUnknown introductions) = kind "IntroConstructorUnknown" + [ "constructors" @= map toJSON introductions + ] + encodeTCM (Info_Auto info) = kind "Auto" + [ "info" @= toJSON info + ] + encodeTCM (Info_ModuleContents names tele contents) = kind "ModuleContents" + [ "contents" #= forM contents encodeNamedPretty + , "telescope" #= forM (telToList tele) encodeDomType + , "names" @= map encodePretty names + ] + where + encodeDomType :: PrettyTCM a => Dom (ArgName, a) -> TCM Value + encodeDomType dom = obj + [ "dom" #= encodePrettyTCM (unDom dom) + , "name" @= fmap encodePretty (bareNameOf dom) + , "finite" @= toJSON (domFinite dom) + , "cohesion" @= encodeShow (modCohesion . argInfoModality $ domInfo dom) + , "relevance" @= encodeShow (modRelevance . argInfoModality $ domInfo dom) + , "hiding" @= case argInfoHiding $ domInfo dom of + Instance o -> show o + o -> show o + ] + encodeTCM (Info_SearchAbout results search) = kind "SearchAbout" + [ "results" #= forM results encodeNamedPretty + , "search" @= toJSON search + ] + encodeTCM (Info_WhyInScope thing path v xs ms) = kind "WhyInScope" + [ "thing" @= thing + , "filepath" @= toJSON path + -- use Emacs message first + , "message" #= explainWhyInScope thing path v xs ms + ] + encodeTCM (Info_NormalForm commandState computeMode time expr) = kind "NormalForm" + [ "commandState" @= commandState + , "computeMode" @= computeMode + , "time" @= time + , "expr" #= encodePrettyTCM expr + ] + encodeTCM (Info_InferredType commandState time expr) = kind "InferredType" + [ "commandState" @= commandState + , "time" @= time + , "expr" #= encodePrettyTCM expr + ] + encodeTCM (Info_Context ii ctx) = kind "Context" + [ "interactionPoint" @= ii + , "context" @= ctx + ] + encodeTCM Info_Version = kind "Version" + [ "version" @= (versionWithCommitInfo :: String) + ] + encodeTCM (Info_GoalSpecific ii info) = kind "GoalSpecific" + [ "interactionPoint" @= ii + , "goalInfo" #= encodeGoalSpecific ii info + ] + +instance EncodeTCM GoalTypeAux where + encodeTCM GoalOnly = kind "GoalOnly" [] + encodeTCM (GoalAndHave expr) = kind "GoalAndHave" + [ "expr" #= encodePrettyTCM expr ] + encodeTCM (GoalAndElaboration term) = kind "GoalAndElaboration" + [ "term" #= encodePrettyTCM term ] + +encodeGoalSpecific :: InteractionId -> GoalDisplayInfo -> TCM Value +encodeGoalSpecific ii = go where - encodeSolution (i, expr) = object - [ "interactionPoint" .= i - , "expression" .= show expr - ] + go (Goal_HelperFunction helperType) = kind "HelperFunction" + [ "signature" #= inTopContext (prettyATop helperType) + ] + go (Goal_NormalForm computeMode expr) = kind "NormalForm" + [ "computeMode" @= computeMode + , "expr" #= B.showComputed computeMode expr + ] + go (Goal_GoalType rewrite goalType entries boundary outputForms) = kind "GoalType" + [ "rewrite" @= rewrite + , "typeAux" @= goalType + , "type" #= prettyTypeOfMeta rewrite ii + , "entries" @= entries + , "boundary" @= map encodePretty boundary + , "outputForms" @= map encodePretty outputForms + ] + go (Goal_CurrentGoal rewrite) = kind "CurrentGoal" + [ "rewrite" @= rewrite + , "type" #= prettyTypeOfMeta rewrite ii + ] + go (Goal_InferredType expr) = kind "InferredType" + [ "expr" #= prettyATop expr + ] + +instance EncodeTCM Response where + encodeTCM (Resp_HighlightingInfo info remove method modFile) = + liftIO $ jsonifyHighlightingInfo info remove method modFile + encodeTCM (Resp_DisplayInfo info) = kind "DisplayInfo" + [ "info" @= info + ] + encodeTCM (Resp_ClearHighlighting tokenBased) = kind "ClearHighlighting" + [ "tokenBased" @= tokenBased + ] + encodeTCM Resp_DoneAborting = kind "DoneAborting" [] + encodeTCM Resp_DoneExiting = kind "DoneExiting" [] + encodeTCM Resp_ClearRunningInfo = kind "ClearRunningInfo" [] + encodeTCM (Resp_RunningInfo debugLevel msg) = kind "RunningInfo" + [ "debugLevel" @= debugLevel + , "message" @= msg + ] + encodeTCM (Resp_Status status) = kind "Status" + [ "status" @= status + ] + encodeTCM (Resp_JumpToError filepath position) = kind "JumpToError" + [ "filepath" @= filepath + , "position" @= position + ] + encodeTCM (Resp_InteractionPoints interactionPoints) = kind "InteractionPoints" + [ "interactionPoints" @= interactionPoints + ] + encodeTCM (Resp_GiveAction i giveResult) = kind "GiveAction" + [ "interactionPoint" @= i + , "giveResult" @= giveResult + ] + encodeTCM (Resp_MakeCase id variant clauses) = kind "MakeCase" + [ "interactionPoint" @= id + , "variant" @= variant + , "clauses" @= clauses + ] + encodeTCM (Resp_SolveAll solutions) = kind "SolveAll" + [ "solutions" @= map encodeSolution solutions + ] + where + encodeSolution (i, expr) = object + [ "interactionPoint" .= i + , "expression" .= show expr + ] + +-- | Convert Response to an JSON value for interactive editor frontends. +jsonifyResponse :: Response -> TCM ByteString +jsonifyResponse = pure . encode <=< encodeTCM diff --git a/src/full/Agda/Interaction/Library.hs b/src/full/Agda/Interaction/Library.hs --- a/src/full/Agda/Interaction/Library.hs +++ b/src/full/Agda/Interaction/Library.hs @@ -18,7 +18,8 @@ -- @ -- module Agda.Interaction.Library - ( getDefaultLibraries + ( findProjectRoot + , getDefaultLibraries , getInstalledLibraries , libraryIncludePaths , LibName @@ -31,17 +32,14 @@ , findLib' ) where -import Control.Arrow ( (***) ) -import Control.Exception import Control.Monad.Writer import Data.Char import Data.Data ( Data ) import Data.Either import Data.Bifunctor ( first ) +import Data.Foldable ( foldMap ) import Data.Function import qualified Data.List as List -import Data.Maybe -import System.Directory ( getAppUserDataDirectory ) import System.Directory import System.FilePath import System.Environment @@ -51,13 +49,13 @@ import Agda.Interaction.Options.Warnings import Agda.Utils.Environment -import Agda.Utils.Except ( ExceptT, runExceptT, MonadError(throwError) ) +import Agda.Utils.Except ( ExceptT, MonadError(throwError) ) import Agda.Utils.IO ( catchIO ) import Agda.Utils.List import Agda.Utils.Maybe import Agda.Utils.Monad import Agda.Utils.Pretty -import Agda.Utils.String ( trim, ltrim ) +import Agda.Utils.String ( trim ) import Agda.Version @@ -139,8 +137,9 @@ warnings :: MonadWriter [Either LibError LibWarning] m => [LibWarning] -> m () warnings = tell . map Right -warning :: MonadWriter [Either LibError LibWarning] m => LibWarning -> m () -warning = warnings . pure +-- UNUSED Liang-Ting Chen 2019-07-16 +--warning :: MonadWriter [Either LibError LibWarning] m => LibWarning -> m () +--warning = warnings . pure raiseErrors' :: MonadWriter [Either LibError LibWarning] m => [LibError'] -> m () raiseErrors' = tell . map (Left . (LibError Nothing)) @@ -189,21 +188,33 @@ -- * Get the libraries for the current project ------------------------------------------------------------------------ --- | Get pathes of @.agda-lib@ files in given project root. +-- | Find project root by looking for @.agda-lib@ files. -- -- If there are none, look in the parent directories until one is found. --- -findAgdaLibFiles - :: FilePath -- ^ Project root. - -> IO [FilePath] -- ^ Pathes of @.agda-lib@ files for this project (if any). -findAgdaLibFiles root = do + +findProjectConfig + :: FilePath -- ^ Candidate (init: the directory Agda was called in) + -> IO (Maybe (FilePath, [FilePath])) -- ^ Actual root and @.agda-lib@ files for this project +findProjectConfig root = do libs <- map (root ) . filter ((== ".agda-lib") . takeExtension) <$> getDirectoryContents root case libs of [] -> do up <- canonicalizePath $ root ".." - if up == root then return [] else findAgdaLibFiles up - files -> return files + if up == root then return Nothing else findProjectConfig up + files -> return (Just (root, files)) +-- | Get project root + +findProjectRoot :: FilePath -> IO (Maybe FilePath) +findProjectRoot root = fmap fst <$> findProjectConfig root + +-- | Get pathes of @.agda-lib@ files in given project root. + +findAgdaLibFiles + :: FilePath -- ^ Project root. + -> IO [FilePath] -- ^ Pathes of @.agda-lib@ files for this project (if any). +findAgdaLibFiles root = fromMaybe [] . fmap snd <$> findProjectConfig root + -- | Get dependencies and include paths for given project root: -- -- Look for @.agda-lib@ files according to 'findAgdaLibFiles'. @@ -220,7 +231,9 @@ then (,[]) <$> if optDefaultLibs then (libNameForCurrentDir :) <$> readDefaultsFile else return [] else libsAndPaths <$> parseLibFiles Nothing (map (0,) libs) where - libsAndPaths ls = (concatMap libDepends ls, List.nub (concatMap libIncludes ls)) + libsAndPaths ls = ( concatMap _libDepends ls + , nubOn id (concatMap _libIncludes ls) + ) -- | Return list of libraries to be used by default. -- @@ -263,14 +276,14 @@ -- Returns none if there is no @libraries@ file. -- getInstalledLibraries - :: Maybe FilePath -- ^ Override the default @libraries@ file? + :: Maybe FilePath -- ^ Override the default @libraries@ file? -> LibM [AgdaLibFile] -- ^ Content of library files. (Might have empty @LibName@s.) getInstalledLibraries overrideLibFile = mkLibM [] $ do file <- lift $ getLibrariesFile overrideLibFile if not (lfExists file) then return [] else do ls <- lift $ stripCommentLines <$> readFile (lfPath file) files <- lift $ sequence [ (i, ) <$> expandEnvironmentVariables s | (i, s) <- ls ] - parseLibFiles (Just file) $ List.nubBy ((==) `on` snd) files + parseLibFiles (Just file) $ nubOn snd files `catchIO` \ e -> do raiseErrors' [ OtherError $ unlines ["Failed to read installed libraries.", show e] ] return [] @@ -292,7 +305,7 @@ unless (null errs) $ raiseErrors $ map (\(mc,s) -> LibError mc $ OtherError s) errs - return $ List.nubBy ((==) `on` libFile) $ als + return $ nubOn _libFile als -- | Remove trailing white space and line comments. -- @@ -317,23 +330,27 @@ return $ runWriter $ (dot ++) . incs <$> find file [] xs where (dots, xs) = List.partition (== libNameForCurrentDir) $ map trim xs0 - incs = List.nub . concatMap libIncludes - dot = [ "." | not $ null dots ] + incs = nubOn id . concatMap _libIncludes + dot = [ "." | not $ null dots ] -- | Due to library dependencies, the work list may grow temporarily. find :: LibrariesFile -- ^ Only for error reporting. - -> [LibName] -- ^ Already resolved libraries. - -> [LibName] -- ^ Work list: libraries left to be resolved. + -> [LibName] -- ^ Already resolved libraries. + -> [LibName] -- ^ Work list: libraries left to be resolved. -> Writer [Either LibError LibWarning] [AgdaLibFile] find _ _ [] = pure [] find file visited (x : xs) - | elem x visited = find file visited xs - | otherwise = - case findLib x libs of - [l] -> (l :) <$> find file (x : visited) (libDepends l ++ xs) - [] -> raiseErrors' [LibNotFound file x] >> find file (x : visited) xs - ls -> raiseErrors' [AmbiguousLib x ls] >> find file (x : visited) xs + | x `elem` visited = find file visited xs + | otherwise = do + -- May or may not find the library + ml <- case findLib x libs of + [l] -> pure (Just l) + [] -> Nothing <$ raiseErrors' [LibNotFound file x] + ls -> Nothing <$ raiseErrors' [AmbiguousLib x ls] + -- If it is found, add its dependencies to work list + let xs' = foldMap _libDepends ml ++ xs + mcons ml <$> find file (x : visited) xs' -- | @findLib x libs@ retrieves the matches for @x@ from list @libs@. -- @@ -346,7 +363,7 @@ -- Examples, see 'findLib''. -- findLib :: LibName -> [AgdaLibFile] -> [AgdaLibFile] -findLib = findLib' libName +findLib = findLib' _libName -- | Generalized version of 'findLib' for testing. -- @@ -366,7 +383,8 @@ where -- @LibName@s that match @x@, sorted descendingly. -- The unversioned LibName, if any, will come first. - ls = List.sortBy (flip compare `on` versionMeasure) [ l | l <- libs, x `hasMatch` libName l ] + ls = List.sortBy (flip compare `on` versionMeasure) + [ l | l <- libs, x `hasMatch` libName l ] -- foo > foo-2.2 > foo-2.0.1 > foo-2 > foo-1.0 versionMeasure l = (rx, null vs, vs) @@ -435,13 +453,14 @@ ] ++ map (nest 2) (if null installed then ["(none)"] - else [ sep [ text $ libName l, nest 2 $ parens $ text $ libFile l ] + else [ sep [ text $ _libName l, nest 2 $ parens $ text $ _libFile l ] | l <- installed ]) AmbiguousLib lib tgts -> vcat $ [ sep [ text $ "Ambiguous library '" ++ lib ++ "'." , "Could refer to any one of" ] - ] ++ [ nest 2 $ text (libName l) <+> parens (text $ libFile l) | l <- tgts ] + ] ++ [ nest 2 $ text (_libName l) <+> parens (text $ _libFile l) + | l <- tgts ] OtherError err -> text err diff --git a/src/full/Agda/Interaction/Library/Base.hs b/src/full/Agda/Interaction/Library/Base.hs --- a/src/full/Agda/Interaction/Library/Base.hs +++ b/src/full/Agda/Interaction/Library/Base.hs @@ -2,6 +2,8 @@ module Agda.Interaction.Library.Base where +import Agda.Utils.Lens + -- | A symbolic library name. -- type LibName = String @@ -14,13 +16,32 @@ -- | Content of a @.agda-lib@ file. -- -data AgdaLibFile = AgdaLib - { libName :: LibName -- ^ The symbolic name of the library. - , libFile :: FilePath -- ^ Path to this @.agda-lib@ file (not content of the file). - , libIncludes :: [FilePath] -- ^ Roots where to look for the modules of the library. - , libDepends :: [LibName] -- ^ Dependencies. +data AgdaLibFile = AgdaLibFile + { _libName :: LibName -- ^ The symbolic name of the library. + , _libFile :: FilePath -- ^ Path to this @.agda-lib@ file (not content of the file). + , _libIncludes :: [FilePath] -- ^ Roots where to look for the modules of the library. + , _libDepends :: [LibName] -- ^ Dependencies. } deriving (Show) emptyLibFile :: AgdaLibFile -emptyLibFile = AgdaLib { libName = "", libFile = "", libIncludes = [], libDepends = [] } +emptyLibFile = AgdaLibFile + { _libName = "" + , _libFile = "" + , _libIncludes = [] + , _libDepends = [] + } + +-- | Lenses for AgdaLibFile + +libName :: Lens' LibName AgdaLibFile +libName f a = f (_libName a) <&> \ x -> a { _libName = x } + +libFile :: Lens' FilePath AgdaLibFile +libFile f a = f (_libFile a) <&> \ x -> a { _libFile = x } + +libIncludes :: Lens' [FilePath] AgdaLibFile +libIncludes f a = f (_libIncludes a) <&> \ x -> a { _libIncludes = x } + +libDepends :: Lens' [LibName] AgdaLibFile +libDepends f a = f (_libDepends a) <&> \ x -> a { _libDepends = x } diff --git a/src/full/Agda/Interaction/Library/Parse.hs b/src/full/Agda/Interaction/Library/Parse.hs --- a/src/full/Agda/Interaction/Library/Parse.hs +++ b/src/full/Agda/Interaction/Library/Parse.hs @@ -9,6 +9,7 @@ -- standard-library -- include: . -- src more-src +-- -- @ -- -- Should parse as: @@ -31,7 +32,6 @@ , LibWarning'(..) ) where -import Control.Exception import Control.Monad import Control.Monad.Writer import Data.Char @@ -41,8 +41,11 @@ import Agda.Interaction.Library.Base +import Agda.Utils.Applicative import Agda.Utils.Except ( MonadError(throwError), ExceptT, runExceptT ) import Agda.Utils.IO ( catchIO ) +import Agda.Utils.Lens +import Agda.Utils.List ( duplicates ) import Agda.Utils.String ( ltrim ) -- | Parser monad: Can throw @String@ error messages, and collects @@ -65,42 +68,59 @@ type GenericFile = [GenericEntry] data GenericEntry = GenericEntry - { geHeader :: String -- ^ E.g. field name. @trim@med. - , geContent :: [String] -- ^ E.g. field content. @trim@med. + { geHeader :: String -- ^ E.g. field name. @trim@med. + , _geContent :: [String] -- ^ E.g. field content. @trim@med. } -- | Library file field format format [sic!]. data Field = forall a. Field - { fName :: String -- ^ Name of the field. - , fOptional :: Bool -- ^ Is it optional? - , fParse :: [String] -> P a -- ^ Content parser for this field. - , fSet :: a -> AgdaLibFile -> AgdaLibFile -- ^ Sets parsed content in 'AgdaLibFile' structure. + { fName :: String -- ^ Name of the field. + , fOptional :: Bool -- ^ Is it optional? + , fParse :: [String] -> P a -- ^ Content parser for this field. + , fSet :: LensSet a AgdaLibFile + -- ^ Sets parsed content in 'AgdaLibFile' structure. } +optionalField :: String -> ([String] -> P a) -> Lens' a AgdaLibFile -> Field +optionalField str p l = Field str True p (set l) + -- | @.agda-lib@ file format with parsers and setters. agdaLibFields :: [Field] agdaLibFields = -- Andreas, 2017-08-23, issue #2708, field "name" is optional. - [ Field "name" True parseName $ \ name l -> l { libName = name } - , Field "include" True (pure . concatMap words) $ \ inc l -> l { libIncludes = inc } - , Field "depend" True (pure . concatMap splitCommas) $ \ ds l -> l { libDepends = ds } + [ optionalField "name" parseName libName + , optionalField "include" (pure . concatMap parsePaths) libIncludes + , optionalField "depend" (pure . concatMap splitCommas) libDepends ] where + parseName :: [String] -> P LibName parseName [s] | [name] <- words s = pure name parseName ls = throwError $ "Bad library name: '" ++ unwords ls ++ "'" + parsePaths :: String -> [FilePath] + parsePaths = go id where + fixup acc = let fp = acc [] in not (null fp) ?$> fp + go acc [] = fixup acc + go acc ('\\' : ' ' :cs) = go (acc . (' ':)) cs + go acc ('\\' : '\\' :cs) = go (acc . ('\\':)) cs + go acc ( ' ' :cs) = fixup acc ++ go id cs + go acc (c :cs) = go (acc . (c:)) cs + -- | Parse @.agda-lib@ file. -- --- Sets 'libFile' name and turn mentioned include directories into absolute pathes --- (provided the given 'FilePath' is absolute). +-- Sets 'libFile' name and turn mentioned include directories into absolute +-- pathes (provided the given 'FilePath' is absolute). -- parseLibFile :: FilePath -> IO (P AgdaLibFile) parseLibFile file = (fmap setPath . parseLib <$> readFile file) `catchIO` \e -> - return $ throwError $ "Failed to read library file " ++ file ++ ".\nReason: " ++ show e + return $ throwError $ unlines + [ "Failed to read library file " ++ file ++ "." + , "Reason: " ++ show e + ] where - setPath lib = unrelativise (takeDirectory file) lib{ libFile = file } - unrelativise dir lib = lib { libIncludes = map (dir ) (libIncludes lib) } + setPath lib = unrelativise (takeDirectory file) (set libFile file lib) + unrelativise dir = over libIncludes (map (dir )) -- | Parse file contents. parseLib :: String -> P AgdaLibFile @@ -113,7 +133,9 @@ -- | Given a list of 'Field' descriptors (with their custom parsers), -- parse a 'GenericFile' into the 'AgdaLibFile' structure. -- --- Checks mandatory fields are present; no duplicate fields, no unknown fields. +-- Checks mandatory fields are present; +-- no duplicate fields, no unknown fields. + fromGeneric' :: [Field] -> GenericFile -> P AgdaLibFile fromGeneric' fields fs = do checkFields fields (map geHeader fs) @@ -135,7 +157,7 @@ -- Missing fields. missing = mandatory List.\\ fs -- Duplicate fields. - dup = fs List.\\ List.nub fs + dup = duplicates fs -- Plural s for error message. s xs = if length xs > 1 then "s" else "" list xs = List.intercalate ", " [ "'" ++ f ++ "'" | f <- xs ] diff --git a/src/full/Agda/Interaction/MakeCase.hs b/src/full/Agda/Interaction/MakeCase.hs --- a/src/full/Agda/Interaction/MakeCase.hs +++ b/src/full/Agda/Interaction/MakeCase.hs @@ -1,31 +1,30 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE NondecreasingIndentation #-} module Agda.Interaction.MakeCase where import Prelude hiding (mapM, mapM_, null) -import Control.Applicative hiding (empty) import Control.Monad hiding (mapM, mapM_, forM) -import Control.Monad.Reader (asks) +import Data.Either import qualified Data.Map as Map import qualified Data.List as List import Data.Maybe -import Data.Traversable +import Data.Monoid +import Data.Traversable (mapM, forM) import Agda.Syntax.Common +import Agda.Syntax.Info import Agda.Syntax.Position -import Agda.Syntax.Concrete (NameInScope(..), LensInScope(..)) +import Agda.Syntax.Concrete (NameInScope(..)) import qualified Agda.Syntax.Concrete as C +import qualified Agda.Syntax.Concrete.Pattern as C import qualified Agda.Syntax.Abstract as A -import qualified Agda.Syntax.Abstract.Views as A -import qualified Agda.Syntax.Info as A +import qualified Agda.Syntax.Abstract.Pattern as A import Agda.Syntax.Internal import Agda.Syntax.Internal.Pattern -import Agda.Syntax.Scope.Base ( ResolvedName(..), Binder(..), KindOfName(..), allKindsOfNames ) -import Agda.Syntax.Scope.Monad ( resolveName, resolveName' ) -import Agda.Syntax.Translation.ConcreteToAbstract +import Agda.Syntax.Scope.Base ( ResolvedName(..), BindingSource(..), KindOfName(..), exceptKindsOfNames ) +import Agda.Syntax.Scope.Monad ( resolveName' ) import Agda.Syntax.Translation.InternalToAbstract import Agda.TypeChecking.Monad @@ -33,28 +32,22 @@ import Agda.TypeChecking.Coverage.Match ( SplitPatVar(..) , SplitPattern , applySplitPSubst , fromSplitPatterns ) import Agda.TypeChecking.Empty ( isEmptyTel ) import Agda.TypeChecking.Pretty -import Agda.TypeChecking.RecordPatterns import Agda.TypeChecking.Reduce -import Agda.TypeChecking.Substitute -import Agda.TypeChecking.Irrelevance -import Agda.TypeChecking.Rules.LHS.Implicit -import Agda.TheTypeChecker +import Agda.TypeChecking.Rules.Def (checkClauseLHS) +import Agda.TypeChecking.Rules.LHS (LHSResult(..)) +import Agda.TypeChecking.Rules.Term (isModuleFreeVar) import Agda.Interaction.Options import Agda.Interaction.BasicOps import Agda.Utils.Function import Agda.Utils.Functor -import Agda.Utils.Lens import Agda.Utils.List import Agda.Utils.Monad import Agda.Utils.Null import qualified Agda.Utils.Pretty as P -import Agda.Utils.Singleton import Agda.Utils.Size -import qualified Agda.Utils.HashMap as HMap -#include "undefined.h" import Agda.Utils.Impossible type CaseContext = Maybe ExtLamInfo @@ -85,8 +78,9 @@ -- We might be under some lambdas, in which case the context -- is bigger than the number of pattern variables. - let nlocals = n - size tel - unless (nlocals >= 0) __IMPOSSIBLE__ + let nPatVars = size tel + let nlocals = n - nPatVars + unless (nlocals >= 0) __IMPOSSIBLE__ -- cannot be negative fv <- getDefFreeVars f reportSDoc "interaction.case" 20 $ do @@ -122,13 +116,11 @@ "Cannot split on variable " ++ s ++ ", because let-declarations may not be defined by pattern-matching" + let cname = C.QName $ C.Name r C.InScope $ C.stringNameParts s + -- Note: the range in the concrete name is only approximate. -- Jesper, 2018-12-19: Don't consider generalizable names since -- they can be shadowed by hidden variables. - let kinds = List.delete GeneralizeName allKindsOfNames - cname = C.QName $ C.Name r C.InScope $ C.stringNameParts s - -- Note: the range in the concrete name is only approximate. - resName <- resolveName' kinds Nothing cname - case resName of + resolveName' (exceptKindsOfNames [GeneralizeName]) Nothing cname >>= \case -- Fail if s is a name, but not of a variable. DefinedName{} -> failNotVar @@ -164,9 +156,14 @@ -- Andreas, 2018-05-28, issue #3095 -- We want to act on an ambiguous name if it corresponds to only one local index. let xs'' = mapMaybe (\ (_,i) -> if i < nlocals then Nothing else Just $ i - nlocals) xs' - when (null xs'') $ failLocal + when (null xs'') $ typeError $ GenericError $ + "Cannot make hidden lambda-bound variable " ++ s ++ " visible" -- Filter out variable bound by parent function or module. - let xs''' = mapMaybe (\ i -> if i < fv then Nothing else Just i) xs'' + params <- moduleParamsToApply $ qnameModule f + let isParam i = any ((== var i) . unArg) params + xs''' = filter (not . isParam) xs'' + when (null xs''') $ typeError $ GenericError $ + "Cannot make hidden module parameter " ++ s ++ " visible" case xs''' of [] -> failModuleBound [i] -> return (i , C.NotInScope) @@ -198,10 +195,24 @@ ] __IMPOSSIBLE__ +recheckAbstractClause :: Type -> Maybe Substitution -> A.SpineClause -> TCM Clause +recheckAbstractClause t sub cl = checkClauseLHS t sub cl $ \ lhs -> + return Clause{ clauseLHSRange = getRange cl + , clauseFullRange = getRange cl + , clauseTel = lhsVarTele lhs + , namedClausePats = lhsPatterns lhs + , clauseBody = Nothing -- We don't need the body for make case + , clauseType = Just (lhsBodyType lhs) + , clauseCatchall = False + , clauseRecursive = Nothing + , clauseUnreachable = Nothing + , clauseEllipsis = lhsEllipsis $ A.spLhsInfo $ A.clauseLHS cl + } + -- | Entry point for case splitting tactic. makeCase :: InteractionId -> Range -> String -> TCM (QName, CaseContext, [A.Clause]) -makeCase hole rng s = withInteractionId hole $ do +makeCase hole rng s = withInteractionId hole $ locallyTC eMakeCase (const True) $ do -- Jesper, 2018-12-10: print unsolved metas in dot patterns as _ localTC (\ e -> e { envPrintMetasBare = True }) $ do @@ -209,14 +220,27 @@ -- Get function clause which contains the interaction point. InteractionPoint { ipMeta = mm, ipClause = ipCl} <- lookupInteractionPoint hole let meta = fromMaybe __IMPOSSIBLE__ mm - (f, clauseNo, rhs) <- case ipCl of - IPClause f clauseNo rhs -> return (f, clauseNo, rhs) - IPNoClause -> typeError $ GenericError $ + (f, clauseNo, clTy, clWithSub, absCl@A.Clause{ clauseRHS = rhs }, clClos) <- case ipCl of + IPClause f i t sub cl clo _ -> return (f, i, t, sub, cl, clo) + IPNoClause -> typeError $ GenericError $ "Cannot split here, as we are not in a function definition" - (casectxt, (prevClauses, clause, follClauses)) <- getClauseZipperForIP f clauseNo + (casectxt, (prevClauses0, _clause, follClauses0)) <- getClauseZipperForIP f clauseNo + + -- Instead of using the actual internal clause, we retype check the abstract clause (with + -- eMakeCase = True). This disables the forcing translation in the unifier, which allows us to + -- split on forced variables. + clause <- enterClosure clClos $ \ _ -> locallyTC eMakeCase (const True) $ + recheckAbstractClause clTy clWithSub absCl + + let (prevClauses, follClauses) = killRange (prevClauses0, follClauses0) + -- Andreas, 2019-08-08, issue #3966 + -- Kill the ranges of the existing clauses to prevent wrong error + -- location to be set by the coverage checker (via isCovered) + -- for test/interaction/Issue191 let perm = fromMaybe __IMPOSSIBLE__ $ clausePerm clause tel = clauseTel clause ps = namedClausePats clause + ell = clauseEllipsis clause reportSDoc "interaction.case" 10 $ vcat [ "splitting clause:" , nest 2 $ vcat @@ -225,8 +249,19 @@ , "tel =" <+> (inTopContext . prettyTCM) tel , "perm =" <+> text (show perm) , "ps =" <+> prettyTCMPatternList ps + , "ell =" <+> text (show ell) ] ] + reportSDoc "interaction.case" 60 $ vcat + [ "splitting clause:" + , nest 2 $ vcat + [ "f =" <+> (text . show) f + , "context =" <+> ((inTopContext . (text . show)) =<< getContextTelescope) + , "tel =" <+> (text . show) tel + , "perm =" <+> text (show perm) + , "ps =" <+> (text . show) ps + ] + ] -- Check split variables. @@ -236,7 +271,7 @@ -- This will expand an ellipsis, if present. if concat vars == "." then do - cl <- makeAbstractClause f rhs $ clauseToSplitClause clause + cl <- makeAbstractClause f rhs NoEllipsis $ clauseToSplitClause clause return (f, casectxt, [cl]) -- If we have no split variables, split on result. @@ -247,7 +282,7 @@ -- we need to print them postfix. let postProjInExtLam = applyWhen (isJust casectxt) $ withPragmaOptions $ \ opt -> opt { optPostfixProjections = True } - (piTel, sc) <- fixTarget $ clauseToSplitClause clause + (piTel, sc) <- insertTrailingArgs $ clauseToSplitClause clause -- Andreas, 2015-05-05 If we introduced new function arguments -- do not split on result. This might be more what the user wants. -- To split on result, he can then C-c C-c again. @@ -285,39 +320,62 @@ -- mapM (snd <.> fixTarget) $ splitClauses cov return cov checkClauseIsClean ipCl - (f, casectxt,) <$> mapM (makeAbstractClause f rhs) scs + (f, casectxt,) <$> mapM (makeAbstractClause f rhs ell) scs else do -- split on variables xs <- parseVariables f tel hole rng vars reportSLn "interaction.case" 30 $ "parsedVariables: " ++ show (zip xs vars) -- Variables that are not in scope yet are brought into scope (@toShow@) -- The other variables are split on (@toSplit@). - let (toShow, toSplit) = flip mapEither (zip xs vars) $ \ ((x,nis), s) -> + let (toShow, toSplit) = partitionEithers $ for (zip xs vars) $ \ ((x,nis), s) -> if (nis == C.NotInScope) then Left x else Right x let sc = makePatternVarsVisible toShow $ clauseToSplitClause clause scs <- split f toSplit sc reportSLn "interaction.case" 70 $ "makeCase: survived the splitting" + -- If any of the split variables is hidden by the ellipsis, we + -- should force the expansion of the ellipsis. + splitNames <- mapM nameOfBV toSplit + shouldExpandEllipsis <- return (not $ null toShow) `or2M` anyEllipsisVar f absCl splitNames + let ell' | shouldExpandEllipsis = NoEllipsis + | otherwise = ell + -- CLEAN UP OF THE GENERATED CLAUSES - -- 1. filter out clauses that are already covered - scs <- filterM (not <.> isCovered f prevClauses . fst) scs + -- 1. filter out the generated clauses that are already covered + -- we consider a generated clause already covered if it is covered by: + -- a. a pre-existing clause defined before the one we splitted (prevClauses) + -- b. a pre-existing clause defined after the one we splitted (follClauses) + -- under the condition that it did not cover the one we splitted but was + -- covered by it (i.e. it was considered unreachable). + -- The key idea here is: + -- f m zero = ? ---- split on m ---> f (suc m) zero = ? + -- f zero zero = ? f zero zero = ? + -- f _ _ = ? f _ _ = ? + -- because [f zero zero] is already defined. + -- However we ignore [f _ _]: [f m zero] was already a refinement of it, + -- hinting that we considered it more important than the catchall. + let sclause = clauseToSplitClause clause + fcs <- filterM (\ cl -> (isCovered f [clause] (clauseToSplitClause cl)) `and2M` + (not <$> isCovered f [cl] sclause)) + follClauses + scs <- filterM (not <.> isCovered f (prevClauses ++ fcs) . fst) scs reportSLn "interaction.case" 70 $ "makeCase: survived filtering out already covered clauses" -- 2. filter out trivially impossible clauses not asked for by the user cs <- catMaybes <$> do forM scs $ \ (sc, isAbsurd) -> if isAbsurd -- absurd clause coming from a split asked for by the user - then Just <$> makeAbsurdClause f sc + then Just <$> makeAbsurdClause f ell' sc -- trivially empty clause due to the refined patterns else ifM (liftTCM $ isEmptyTel (scTel sc)) {- then -} (pure Nothing) - {- else -} (Just <$> makeAbstractClause f rhs sc) + {- else -} (Just <$> makeAbstractClause f rhs ell' sc) reportSLn "interaction.case" 70 $ "makeCase: survived filtering out impossible clauses" -- 3. If the cleanup removed everything then we know that none of the clauses where -- absurd but that all of them were trivially empty. In this case we rewind and -- insert all the clauses (garbage in, garbage out!) cs <- if not (null cs) then pure cs - else mapM (makeAbstractClause f rhs . fst) scs + else mapM (makeAbstractClause f rhs ell' . fst) scs reportSDoc "interaction.case" 65 $ vcat [ "split result:" @@ -370,13 +428,13 @@ -- We could introduce extra consistency checks, like -- if visible ai then __IMPOSSIBLE__ else -- or passing the parsed name along and comparing it with @x@ - Arg (setOrigin CaseSplit ai) $ Named n $ VarP PatOSplit $ SplitPatVar x i ls + Arg (setOrigin CaseSplit ai) $ Named n $ VarP (PatternInfo PatOSplit []) $ SplitPatVar x i ls mkVis np = np -- | Make clause with no rhs (because of absurd match). -makeAbsurdClause :: QName -> SplitClause -> TCM A.Clause -makeAbsurdClause f (SClause tel sps _ _ t) = do +makeAbsurdClause :: QName -> ExpandedEllipsis -> SplitClause -> TCM A.Clause +makeAbsurdClause f ell (SClause tel sps _ _ t) = do let ps = fromSplitPatterns sps reportSDoc "interaction.case" 10 $ vcat [ "Interaction.MakeCase.makeAbsurdClause: split clause:" @@ -384,6 +442,7 @@ [ "context =" <+> do (inTopContext . prettyTCM) =<< getContextTelescope , "tel =" <+> do inTopContext $ prettyTCM tel , "ps =" <+> do inTopContext $ addContext tel $ prettyTCMPatternList ps -- P.sep <$> prettyTCMPatterns ps + , "ell =" <+> text (show ell) ] ] withCurrentModule (qnameModule f) $ do @@ -391,7 +450,7 @@ -- Contract implicit record patterns before printing. -- c <- translateRecordPatterns $ Clause noRange tel perm ps NoBody t False -- Jesper, 2015-09-19 Don't contract, since we do on-demand splitting - let c = Clause noRange noRange tel ps Nothing t False Nothing + let c = Clause noRange noRange tel ps Nothing (argFromDom <$> t) False Nothing Nothing ell -- Normalise the dot patterns ps <- addContext tel $ normalise $ namedClausePats c reportSDoc "interaction.case" 60 $ "normalized patterns: " <+> prettyTCMPatternList ps @@ -400,13 +459,35 @@ -- | Make a clause with a question mark as rhs. -makeAbstractClause :: QName -> A.RHS -> SplitClause -> TCM A.Clause -makeAbstractClause f rhs cl = do +makeAbstractClause :: QName -> A.RHS -> ExpandedEllipsis -> SplitClause -> TCM A.Clause +makeAbstractClause f rhs ell cl = do - lhs <- A.clauseLHS <$> makeAbsurdClause f cl + lhs <- A.clauseLHS <$> makeAbsurdClause f ell cl reportSDoc "interaction.case" 60 $ "reified lhs: " <+> prettyA lhs return $ A.Clause lhs [] rhs A.noWhereDecls False -- let ii = InteractionId (-1) -- Dummy interaction point since we never type check this. -- -- Can end up in verbose output though (#1842), hence not __IMPOSSIBLE__. -- let info = A.emptyMetaInfo -- metaNumber = Nothing in order to print as ?, not ?n -- return $ A.Clause lhs [] (A.RHS $ A.QuestionMark info ii) [] False + +anyEllipsisVar :: QName -> A.SpineClause -> [Name] -> TCM Bool +anyEllipsisVar f cl xs = do + let lhs = A.clauseLHS cl + ps = A.spLhsPats lhs + ell = lhsEllipsis $ A.spLhsInfo lhs + anyVar :: A.Pattern -> Any -> Any + anyVar p acc = Any $ getAny acc || case p of + A.VarP x -> A.unBind x `elem` xs + _ -> False + case ell of + NoEllipsis -> return False + ExpandedEllipsis _ k -> do + ps' <- snd <$> reifyDisplayFormP f ps [] + let ellipsisPats :: A.Patterns + ellipsisPats = fst $ C.splitEllipsis k ps' + reportSDoc "interaction.case.ellipsis" 40 $ vcat + [ "should we expand the ellipsis?" + , nest 2 $ "xs =" <+> prettyList_ (map prettyA xs) + , nest 2 $ "ellipsisPats =" <+> prettyList_ (map prettyA ellipsisPats) + ] + return $ getAny $ A.foldrAPattern anyVar ellipsisPats diff --git a/src/full/Agda/Interaction/Options.hs b/src/full/Agda/Interaction/Options.hs --- a/src/full/Agda/Interaction/Options.hs +++ b/src/full/Agda/Interaction/Options.hs @@ -6,7 +6,7 @@ , PragmaOptions(..) , OptionsPragma , Flag, OptM, runOptM, OptDescr(..), ArgDescr(..) - , Verbosity + , Verbosity, VerboseKey, VerboseLevel , HtmlHighlight(..) , WarningMode(..) , checkOpts @@ -33,15 +33,13 @@ , getOptSimple ) where -import Control.Monad ( (>=>), when ) +import Control.Monad ( when ) import Control.Monad.Trans import Data.IORef -import Data.Either import Data.Function import Data.Maybe -import Data.List ( isSuffixOf , intercalate ) -import Data.Set ( Set ) +import Data.List ( intercalate ) import qualified Data.Set as Set import System.Console.GetOpt ( getOpt', usageInfo, ArgOrder(ReturnInOrder) @@ -69,7 +67,6 @@ import Agda.Utils.Lens ( Lens', over ) import Agda.Utils.List ( groupOn, wordsBy ) import Agda.Utils.Monad ( ifM, readM ) -import Agda.Utils.String ( indent ) import Agda.Utils.Trie ( Trie ) import qualified Agda.Utils.Trie as Trie import Agda.Utils.WithDefault @@ -78,11 +75,11 @@ -- Paths_Agda.hs is in $(BUILD_DIR)/build/autogen/. import Paths_Agda ( getDataFileName ) -import qualified System.IO.Unsafe as UNSAFE (unsafePerformIO) - -- OptDescr is a Functor -------------------------------------------------- -type Verbosity = Trie String Int +type VerboseKey = String +type VerboseLevel = Int +type Verbosity = Trie VerboseKey VerboseLevel data HtmlHighlight = HighlightAll | HighlightCode | HighlightAuto deriving (Show, Eq) @@ -121,11 +118,13 @@ , optCSSFile :: Maybe FilePath , optIgnoreInterfaces :: Bool , optIgnoreAllInterfaces :: Bool - , optForcing :: Bool + , optLocalInterfaces :: Bool , optPragmaOptions :: PragmaOptions , optOnlyScopeChecking :: Bool -- ^ Should the top-level module only be scope-checked, and not -- type-checked? + , optWithCompiler :: Maybe FilePath + -- ^ Use the compiler at PATH instead of ghc / js / etc. } deriving Show @@ -138,6 +137,7 @@ , optVerbose :: Verbosity , optProp :: Bool , optAllowUnsolved :: Bool + , optAllowIncompleteMatch :: Bool , optDisablePositivity :: Bool , optTerminationCheck :: Bool , optTerminationDepth :: CutOff @@ -145,6 +145,8 @@ , optCompletenessCheck :: Bool , optUniverseCheck :: Bool , optOmegaInOmega :: Bool + , optSubtyping :: WithDefault 'False + , optCumulativity :: Bool , optSizedTypes :: WithDefault 'True , optGuardedness :: WithDefault 'True , optInjectiveTypeConstructors :: Bool @@ -156,17 +158,23 @@ , optPatternMatching :: Bool -- ^ Is pattern matching allowed in the current file? , optExactSplit :: Bool , optEta :: Bool + , optForcing :: Bool -- ^ Perform the forcing analysis on data constructors? + , optProjectionLike :: Bool -- ^ Perform the projection-likeness analysis on functions? , optRewriting :: Bool -- ^ Can rewrite rules be added and used? , optCubical :: Bool , optPostfixProjections :: Bool -- ^ Should system generated projections 'ProjSystem' be printed -- postfix (True) or prefix (False). + , optKeepPatternVariables :: Bool + -- ^ Should case splitting replace variables with dot patterns + -- (False) or keep them as variables (True). , optInstanceSearchDepth :: Int , optOverlappingInstances :: Bool , optInversionMaxDepth :: Int , optSafe :: Bool , optDoubleCheck :: Bool , optSyntacticEquality :: Bool -- ^ Should conversion checker use syntactic equality shortcut? + , optCompareSorts :: Bool -- ^ Should conversion checker compare sorts of types? , optWarningMode :: WarningMode , optCompileNoMain :: Bool , optCaching :: Bool @@ -179,6 +187,10 @@ , optPrintPatternSynonyms :: Bool , optFastReduce :: Bool -- ^ Use the Agda abstract machine (fastReduce)? + , optConfluenceCheck :: Bool + -- ^ Check confluence of rewrite rules? + , optFlatSplit :: Bool + -- ^ Can we split on a (x :{flat} A) argument? } deriving (Show, Eq) @@ -227,9 +239,10 @@ , optCSSFile = Nothing , optIgnoreInterfaces = False , optIgnoreAllInterfaces = False - , optForcing = True + , optLocalInterfaces = False , optPragmaOptions = defaultPragmaOptions , optOnlyScopeChecking = False + , optWithCompiler = Nothing } defaultPragmaOptions :: PragmaOptions @@ -242,12 +255,15 @@ , optExperimentalIrrelevance = False , optIrrelevantProjections = False -- off by default in > 2.5.4, see issue #2170 , optAllowUnsolved = False + , optAllowIncompleteMatch = False , optDisablePositivity = False , optTerminationCheck = True , optTerminationDepth = defaultCutOff , optCompletenessCheck = True , optUniverseCheck = True , optOmegaInOmega = False + , optSubtyping = Default + , optCumulativity = False , optSizedTypes = Default , optGuardedness = Default , optInjectiveTypeConstructors = False @@ -257,15 +273,19 @@ , optPatternMatching = True , optExactSplit = False , optEta = True + , optForcing = True + , optProjectionLike = True , optRewriting = False , optCubical = False , optPostfixProjections = False + , optKeepPatternVariables = False , optInstanceSearchDepth = 500 , optOverlappingInstances = False , optInversionMaxDepth = 50 , optSafe = False , optDoubleCheck = False , optSyntacticEquality = True + , optCompareSorts = True , optWarningMode = defaultWarningMode , optCompileNoMain = False , optCaching = True @@ -273,6 +293,8 @@ , optAutoInline = True , optPrintPatternSynonyms = True , optFastReduce = True + , optConfluenceCheck = False + , optFlatSplit = True } -- | The default termination depth. @@ -362,6 +384,7 @@ unsafePragmaOptions :: PragmaOptions -> [String] unsafePragmaOptions opts = [ "--allow-unsolved-metas" | optAllowUnsolved opts ] ++ + [ "--allow-incomplete-matches" | optAllowIncompleteMatch opts ] ++ [ "--no-positivity-check" | optDisablePositivity opts ] ++ [ "--no-termination-check" | not (optTerminationCheck opts) ] ++ [ "--type-in-type" | not (optUniverseCheck opts) ] ++ @@ -375,6 +398,7 @@ [ "--rewriting" | optRewriting opts ] ++ [ "--cubical and --with-K" | optCubical opts , not (collapseDefault $ optWithoutK opts) ] ++ + [ "--cumulativity" | optCumulativity opts ] ++ [] -- | If any these options have changed, then the file will be @@ -386,10 +410,13 @@ [ (C . optTerminationDepth, "--termination-depth") , (B . not . optUseUnicode, "--no-unicode") , (B . optAllowUnsolved, "--allow-unsolved-metas") + , (B . optAllowIncompleteMatch, "--allow-incomplete-matches") , (B . optDisablePositivity, "--no-positivity-check") , (B . optTerminationCheck, "--no-termination-check") , (B . not . optUniverseCheck, "--type-in-type") , (B . optOmegaInOmega, "--omega-in-omega") + , (B . collapseDefault . optSubtyping, "--subtyping") + , (B . optCumulativity, "--cumulativity") , (B . not . collapseDefault . optSizedTypes, "--no-sized-types") , (B . not . collapseDefault . optGuardedness, "--no-guardedness") , (B . optInjectiveTypeConstructors, "--injective-type-constructors") @@ -406,11 +433,13 @@ , (B . optSafe, "--safe") , (B . optDoubleCheck, "--double-check") , (B . not . optSyntacticEquality, "--no-syntactic-equality") + , (B . not . optCompareSorts, "--no-sort-comparison") , (B . not . optAutoInline, "--no-auto-inline") , (B . not . optFastReduce, "--no-fast-reduce") , (I . optInstanceSearchDepth, "--instance-search-depth") , (I . optInversionMaxDepth, "--inversion-max-depth") , (W . optWarningMode, "--warning") + , (B . optConfluenceCheck, "--confluence-check") ] -- to make all restart options have the same type @@ -436,6 +465,8 @@ , (not . optUniversePolymorphism, "--no-universe-polymorphism") , (not . collapseDefault . optSizedTypes, "--no-sized-types") , (not . collapseDefault . optGuardedness, "--no-guardedness") + , (not . collapseDefault . optSubtyping, "--no-subtyping") + , (not . optCumulativity, "--no-cumulativity") ] inputFlag :: FilePath -> Flag CommandLineOptions @@ -463,12 +494,21 @@ , optSizedTypes = setDefault False sizedTypes } +flatSplitFlag :: Flag PragmaOptions +flatSplitFlag o = return $ o { optFlatSplit = True } + +noFlatSplitFlag :: Flag PragmaOptions +noFlatSplitFlag o = return $ o { optFlatSplit = False } + doubleCheckFlag :: Flag PragmaOptions doubleCheckFlag o = return $ o { optDoubleCheck = True } noSyntacticEqualityFlag :: Flag PragmaOptions noSyntacticEqualityFlag o = return $ o { optSyntacticEquality = False } +noSortComparisonFlag :: Flag PragmaOptions +noSortComparisonFlag o = return $ o { optCompareSorts = False } + sharingFlag :: Bool -> Flag CommandLineOptions sharingFlag _ _ = throwError $ "Feature --sharing has been removed (in favor of the Agda abstract machine)." @@ -497,6 +537,9 @@ ignoreAllInterfacesFlag :: Flag CommandLineOptions ignoreAllInterfacesFlag o = return $ o { optIgnoreAllInterfaces = True } +localInterfacesFlag :: Flag CommandLineOptions +localInterfacesFlag o = return $ o { optLocalInterfaces = True } + allowUnsolvedFlag :: Flag PragmaOptions allowUnsolvedFlag o = do let upd = over warningSet (Set.\\ unsolvedWarnings) @@ -504,6 +547,13 @@ , optWarningMode = upd (optWarningMode o) } +allowIncompleteMatchFlag :: Flag PragmaOptions +allowIncompleteMatchFlag o = do + let upd = over warningSet (Set.\\ incompleteMatchWarnings) + return $ o { optAllowIncompleteMatch = True + , optWarningMode = upd (optWarningMode o) + } + showImplicitFlag :: Flag PragmaOptions showImplicitFlag o = return $ o { optShowImplicit = True } @@ -576,14 +626,33 @@ omegaInOmegaFlag :: Flag PragmaOptions omegaInOmegaFlag o = return $ o { optOmegaInOmega = True } -etaFlag :: Flag PragmaOptions -etaFlag o = return $ o { optEta = True } +subtypingFlag :: Flag PragmaOptions +subtypingFlag o = return $ o { optSubtyping = Value True } +noSubtypingFlag :: Flag PragmaOptions +noSubtypingFlag o = return $ o { optSubtyping = Value False } + +cumulativityFlag :: Flag PragmaOptions +cumulativityFlag o = + return $ o { optCumulativity = True + , optSubtyping = setDefault True $ optSubtyping o + } + +noCumulativityFlag :: Flag PragmaOptions +noCumulativityFlag o = return $ o { optCumulativity = False } + +--UNUSED Liang-Ting Chen 2019-07-16 +--etaFlag :: Flag PragmaOptions +--etaFlag o = return $ o { optEta = True } + noEtaFlag :: Flag PragmaOptions noEtaFlag o = return $ o { optEta = False } sizedTypes :: Flag PragmaOptions -sizedTypes o = return $ o { optSizedTypes = Value True } +sizedTypes o = + return $ o { optSizedTypes = Value True + --, optSubtyping = setDefault True $ optSubtyping o + } noSizedTypes :: Flag PragmaOptions noSizedTypes o = return $ o { optSizedTypes = Value False } @@ -607,9 +676,12 @@ noUniversePolymorphismFlag :: Flag PragmaOptions noUniversePolymorphismFlag o = return $ o { optUniversePolymorphism = False } -noForcingFlag :: Flag CommandLineOptions +noForcingFlag :: Flag PragmaOptions noForcingFlag o = return $ o { optForcing = False } +noProjectionLikeFlag :: Flag PragmaOptions +noProjectionLikeFlag o = return $ o { optProjectionLike = False } + withKFlag :: Flag PragmaOptions withKFlag o = return $ o { optWithoutK = Value False } @@ -652,6 +724,9 @@ postfixProjectionsFlag :: Flag PragmaOptions postfixProjectionsFlag o = return $ o { optPostfixProjections = True } +keepPatternVariablesFlag :: Flag PragmaOptions +keepPatternVariablesFlag o = return $ o { optKeepPatternVariables = True } + instanceDepthFlag :: String -> Flag PragmaOptions instanceDepthFlag s o = do d <- integerArgument "--instance-search-depth" s @@ -709,7 +784,9 @@ overrideLibrariesFileFlag :: String -> Flag CommandLineOptions overrideLibrariesFileFlag s o = do ifM (liftIO $ doesFileExist s) - {-then-} (return $ o { optOverrideLibrariesFile = Just s }) + {-then-} (return $ o { optOverrideLibrariesFile = Just s + , optUseLibs = True + }) {-else-} (throwError $ "Libraries file not found: " ++ s) noDefaultLibsFlag :: Flag CommandLineOptions @@ -742,6 +819,18 @@ return $ o { optTerminationDepth = CutOff $ k-1 } where usage = throwError "argument to termination-depth should be >= 1" +confluenceCheckFlag :: Flag PragmaOptions +confluenceCheckFlag o = return $ o { optConfluenceCheck = True } + +noConfluenceCheckFlag :: Flag PragmaOptions +noConfluenceCheckFlag o = return $ o { optConfluenceCheck = False } + +withCompilerFlag :: FilePath -> Flag CommandLineOptions +withCompilerFlag fp o = case optWithCompiler o of + Nothing -> pure o { optWithCompiler = Just fp } + Just{} -> throwError "only one compiler path allowed" + + integerArgument :: String -> String -> OptM Int integerArgument flag s = readM s `catchError` \_ -> @@ -786,6 +875,8 @@ "generate a Dot file with a module dependency graph" , Option [] ["ignore-interfaces"] (NoArg ignoreInterfacesFlag) "ignore interface files (re-type check everything)" + , Option [] ["local-interfaces"] (NoArg localInterfacesFlag) + "put interface files next to the Agda files they correspond to" , Option ['i'] ["include-path"] (ReqArg includeFlag "DIR") "look for imports in DIR" , Option ['l'] ["library"] (ReqArg libraryFlag "LIB") @@ -796,10 +887,10 @@ "don't use any library files" , Option [] ["no-default-libraries"] (NoArg noDefaultLibsFlag) "don't use default libraries" - , Option [] ["no-forcing"] (NoArg noForcingFlag) - "disable the forcing optimisation" , Option [] ["only-scope-checking"] (NoArg onlyScopeCheckingFlag) "only scope-check the top-level module, do not type-check it" + , Option [] ["with-compiler"] (ReqArg withCompilerFlag "PATH") + "use the compiler available at PATH" ] ++ map (fmap lensPragmaOptions) pragmaOptions -- | Defined locally here since module ''Agda.Interaction.Options.Lenses'' @@ -831,6 +922,8 @@ "set verbosity level to N" , Option [] ["allow-unsolved-metas"] (NoArg allowUnsolvedFlag) "succeed and create interface file regardless of unsolved meta variables" + , Option [] ["allow-incomplete-matches"] (NoArg allowIncompleteMatchFlag) + "succeed and create interface file regardless of incomplete pattern matches" , Option [] ["no-positivity-check"] (NoArg noPositivityFlag) "do not warn about not strictly positive data types" , Option [] ["no-termination-check"] (NoArg dontTerminationCheckFlag) @@ -841,14 +934,26 @@ "ignore universe levels (this makes Agda inconsistent)" , Option [] ["omega-in-omega"] (NoArg omegaInOmegaFlag) "enable typing rule Setω : Setω (this makes Agda inconsistent)" + , Option [] ["subtyping"] (NoArg subtypingFlag) + "enable subtyping rules in general (e.g. for irrelevance and erasure)" + , Option [] ["no-subtyping"] (NoArg noSubtypingFlag) + "disable subtyping rules in general (e.g. for irrelevance and erasure) (default)" + , Option [] ["cumulativity"] (NoArg cumulativityFlag) + "enable subtyping of universes (e.g. Set =< Set₁) (implies --subtyping)" + , Option [] ["no-cumulativity"] (NoArg noCumulativityFlag) + "disable subtyping of universes (default)" , Option [] ["prop"] (NoArg propFlag) "enable the use of the Prop universe" , Option [] ["no-prop"] (NoArg noPropFlag) "disable the use of the Prop universe (default)" , Option [] ["sized-types"] (NoArg sizedTypes) - "enable sized types (default, inconsistent with --guardedness)" + "enable sized types (default, inconsistent with --guardedness, implies --subtyping)" , Option [] ["no-sized-types"] (NoArg noSizedTypes) "disable sized types" + , Option [] ["flat-split"] (NoArg flatSplitFlag) + "allow split on (x :{flat} A) arguments (default)" + , Option [] ["no-flat-split"] (NoArg noFlatSplitFlag) + "disable split on (x :{flat} A) arguments" , Option [] ["guardedness"] (NoArg guardedness) "enable constructor-based guarded corecursion (default, inconsistent with --sized-types)" , Option [] ["no-guardedness"] (NoArg noGuardedness) @@ -881,12 +986,22 @@ "do not require all clauses in a definition to hold as definitional equalities (default)" , Option [] ["no-eta-equality"] (NoArg noEtaFlag) "default records to no-eta-equality" + , Option [] ["no-forcing"] (NoArg noForcingFlag) + "disable the forcing analysis for data constructors (optimisation)" + , Option [] ["no-projection-like"] (NoArg noProjectionLikeFlag) + "disable the analysis whether function signatures liken those of projections (optimisation)" , Option [] ["rewriting"] (NoArg rewritingFlag) "enable declaration and use of REWRITE rules" + , Option [] ["confluence-check"] (NoArg confluenceCheckFlag) + "enable confluence checking of REWRITE rules" + , Option [] ["no-confluence-check"] (NoArg noConfluenceCheckFlag) + "disalbe confluence checking of REWRITE rules (default)" , Option [] ["cubical"] (NoArg cubicalFlag) "enable cubical features (e.g. overloads lambdas for paths), implies --without-K" , Option [] ["postfix-projections"] (NoArg postfixProjectionsFlag) "make postfix projection notation the default" + , Option [] ["keep-pattern-variables"] (NoArg keepPatternVariablesFlag) + "don't replace variables with dot patterns during case splitting" , Option [] ["instance-search-depth"] (ReqArg instanceDepthFlag "N") "set instance search depth to N (default: 500)" , Option [] ["overlapping-instances"] (NoArg overlappingInstancesFlag) @@ -901,6 +1016,8 @@ "enable double-checking of all terms using the internal typechecker" , Option [] ["no-syntactic-equality"] (NoArg noSyntacticEqualityFlag) "disable the syntactic equality shortcut in the conversion checker" + , Option [] ["no-sort-comparison"] (NoArg noSortComparisonFlag) + "disable the comparison of sorts when checking conversion of types" , Option ['W'] ["warning"] (ReqArg warningModeFlag "FLAG") ("set warning flags. See --help=warning.") , Option [] ["no-main"] (NoArg compileFlagNoMain) diff --git a/src/full/Agda/Interaction/Options/Help.hs b/src/full/Agda/Interaction/Options/Help.hs --- a/src/full/Agda/Interaction/Options/Help.hs +++ b/src/full/Agda/Interaction/Options/Help.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} module Agda.Interaction.Options.Help ( @@ -8,14 +7,8 @@ , allHelpTopics ) where -import Data.Tuple ( swap ) -import Data.Maybe ( fromMaybe ) - import Agda.Interaction.Options.Warnings -#include "undefined.h" -import Agda.Utils.Impossible - -- | Interface to the @help@ function data Help = GeneralHelp @@ -46,5 +39,7 @@ string2HelpTopic :: String -> Maybe HelpTopic string2HelpTopic str = lookup str allHelpTopics -helpTopic2String :: HelpTopic -> String -helpTopic2String w = fromMaybe __IMPOSSIBLE__ $ lookup w (map swap allHelpTopics) +-- UNUSED Liang-Ting Chen 2019-07-15 +--helpTopic2String :: HelpTopic -> String +--helpTopic2String w = fromMaybe __IMPOSSIBLE__ $ lookup w (map swap allHelpTopics) +-- diff --git a/src/full/Agda/Interaction/Options/Lenses.hs b/src/full/Agda/Interaction/Options/Lenses.hs --- a/src/full/Agda/Interaction/Options/Lenses.hs +++ b/src/full/Agda/Interaction/Options/Lenses.hs @@ -146,12 +146,14 @@ , "Agda" "Builtin" "Char" "Properties.agda" , "Agda" "Builtin" "Coinduction.agda" , "Agda" "Builtin" "Cubical" "Glue.agda" + , "Agda" "Builtin" "Cubical" "HCompU.agda" , "Agda" "Builtin" "Cubical" "Id.agda" , "Agda" "Builtin" "Cubical" "Path.agda" , "Agda" "Builtin" "Cubical" "Sub.agda" , "Agda" "Builtin" "Equality" "Erase.agda" , "Agda" "Builtin" "Equality.agda" , "Agda" "Builtin" "Float.agda" + , "Agda" "Builtin" "Float" "Properties.agda" , "Agda" "Builtin" "FromNat.agda" , "Agda" "Builtin" "FromNeg.agda" , "Agda" "Builtin" "FromString.agda" @@ -160,6 +162,7 @@ , "Agda" "Builtin" "List.agda" , "Agda" "Builtin" "Nat.agda" , "Agda" "Builtin" "Reflection.agda" + , "Agda" "Builtin" "Reflection" "Properties.agda" , "Agda" "Builtin" "Sigma.agda" , "Agda" "Builtin" "Size.agda" , "Agda" "Builtin" "Strict.agda" diff --git a/src/full/Agda/Interaction/Options/Warnings.hs b/src/full/Agda/Interaction/Options/Warnings.hs --- a/src/full/Agda/Interaction/Options/Warnings.hs +++ b/src/full/Agda/Interaction/Options/Warnings.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} module Agda.Interaction.Options.Warnings ( @@ -10,6 +9,7 @@ , usualWarnings , noWarnings , unsolvedWarnings + , incompleteMatchWarnings , errorWarnings , defaultWarningMode , warningModeUpdate @@ -24,8 +24,6 @@ import Control.Arrow ( (&&&) ) import Control.Monad ( guard ) -import Data.Traversable ( for ) - import Text.Read ( readMaybe ) import Data.Set (Set) import qualified Data.Set as Set @@ -35,7 +33,6 @@ import Agda.Utils.Lens import Agda.Utils.Maybe -#include "undefined.h" import Agda.Utils.Impossible @@ -94,6 +91,9 @@ , UnsolvedConstraints_ ] +incompleteMatchWarnings :: Set WarningName +incompleteMatchWarnings = Set.fromList [ CoverageIssue_ ] + errorWarnings :: Set WarningName errorWarnings = Set.fromList [ CoverageIssue_ @@ -111,12 +111,17 @@ , SafeFlagNoPositivityCheck_ , SafeFlagPolarity_ , SafeFlagNoUniverseCheck_ + , SafeFlagEta_ + , SafeFlagInjective_ + , SafeFlagNoCoverageCheck_ , TerminationIssue_ , UnsolvedMetaVariables_ , UnsolvedInteractionMetas_ , UnsolvedConstraints_ , InfectiveImport_ , CoInfectiveImport_ + , RewriteNonConfluent_ + , RewriteMaybeNonConfluent_ ] allWarnings :: Set WarningName @@ -126,6 +131,7 @@ usualWarnings = allWarnings Set.\\ Set.fromList [ UnknownFixityInMixfixDecl_ , CoverageNoExactSplit_ + , ShadowingInTelescope_ ] -- | The @WarningName@ data enumeration is meant to have a one-to-one correspondance @@ -139,22 +145,28 @@ | LibUnknownField_ -- Nicifer Warnings | EmptyAbstract_ + | EmptyField_ + | EmptyGeneralize_ | EmptyInstance_ | EmptyMacro_ | EmptyMutual_ | EmptyPostulate_ - | EmptyPrivate_ - | EmptyGeneralize_ | EmptyPrimitive_ + | EmptyPrivate_ + | EmptyRewritePragma_ | InvalidCatchallPragma_ + | InvalidCoverageCheckPragma_ + | InvalidNoPositivityCheckPragma_ | InvalidNoUniverseCheckPragma_ | InvalidTerminationCheckPragma_ - | InvalidNoPositivityCheckPragma_ | MissingDefinitions_ | NotAllowedInMutual_ + | OpenPublicAbstract_ + | OpenPublicPrivate_ | PolarityPragmasButNotPostulates_ - | PragmaNoTerminationCheck_ | PragmaCompiled_ + | PragmaNoTerminationCheck_ + | ShadowingInTelescope_ | UnknownFixityInMixfixDecl_ | UnknownNamesInFixityDecl_ | UnknownNamesInPolarityPragmas_ @@ -162,43 +174,51 @@ | UselessInstance_ | UselessPrivate_ -- Scope and Type Checking Warnings - | OldBuiltin_ - | EmptyRewritePragma_ + | AbsurdPatternRequiresNoRHS_ + | CantGeneralizeOverSorts_ + | ClashesViaRenaming_ -- issue #4154 + | CoverageIssue_ + | CoverageNoExactSplit_ + | DeprecationWarning_ + | FixityInRenamingModule_ + | GenericNonFatalError_ + | GenericWarning_ | IllformedAsClause_ - | UselessPublic_ - | UnreachableClauses_ - | UselessInline_ - | WrongInstanceDeclaration_ + | InstanceArgWithExplicitArg_ | InstanceWithExplicitArg_ | InstanceNoOutputTypeName_ - | InstanceArgWithExplicitArg_ - | GenericWarning_ - | DeprecationWarning_ | InversionDepthReached_ - | TerminationIssue_ - | CoverageIssue_ - | CoverageNoExactSplit_ | ModuleDoesntExport_ + | NotInScope_ | NotStrictlyPositive_ - | UnsolvedMetaVariables_ - | UnsolvedInteractionMetas_ - | UnsolvedConstraints_ - | GenericNonFatalError_ + | OldBuiltin_ + | PragmaCompileErased_ + | RewriteMaybeNonConfluent_ + | RewriteNonConfluent_ + | SafeFlagEta_ + | SafeFlagInjective_ + | SafeFlagNoCoverageCheck_ + | SafeFlagNonTerminating_ + | SafeFlagNoPositivityCheck_ + | SafeFlagNoUniverseCheck_ + | SafeFlagPolarity_ | SafeFlagPostulate_ | SafeFlagPragma_ - | SafeFlagNonTerminating_ | SafeFlagTerminating_ | SafeFlagWithoutKFlagPrimEraseEquality_ - | SafeFlagNoPositivityCheck_ - | SafeFlagPolarity_ - | SafeFlagNoUniverseCheck_ + | TerminationIssue_ + | UnreachableClauses_ + | UnsolvedConstraints_ + | UnsolvedInteractionMetas_ + | UnsolvedMetaVariables_ + | UselessInline_ + | UselessPublic_ | UserWarning_ | WithoutKFlagPrimEraseEquality_ - | CantGeneralizeOverSorts_ - | AbsurdPatternRequiresNoRHS_ + | WrongInstanceDeclaration_ -- Checking consistency of options - | InfectiveImport_ | CoInfectiveImport_ + | InfectiveImport_ deriving (Eq, Ord, Show, Read, Enum, Bounded) -- | The flag corresponding to a warning is precisely the name of the constructor @@ -215,25 +235,28 @@ usageWarning :: String usageWarning = intercalate "\n" - -- Looks like CPP doesn't like multiline string literals - [ concat [ "The -W or --warning option can be used to disable or enable " - , "different warnings. The flag -W error (or --warning=error) " - , "can be used to turn all warnings into errors, while -W noerror " - , "turns this off again." - ] + [ "The -W or --warning option can be used to disable or enable\ + \ different warnings. The flag -W error (or --warning=error)\ + \ can be used to turn all warnings into errors, while -W noerror\ + \ turns this off again." , "" - , concat [ "A group of warnings can be enabled by -W group, where group is " - , "one of the following:" - ] + , "A group of warnings can be enabled by -W group, where group is\ + \ one of the following:" , "" , untable (fmap (fst &&& snd . snd) warningSets) - , concat [ "Individual warnings can be turned on and off by -W Name and " - , "-W noName respectively. The flags available are:" - ] + , "Individual warnings can be turned on and off by -W Name and\ + \ -W noName, respectively, where Name comes from the following\ + \ list (warnings marked with 'd' are turned on by default, and 'b'\ + \ stands for \"benign warning\"):" , "" , untable $ forMaybe [minBound..maxBound] $ \ w -> let wnd = warningNameDescription w in - (warningName2String w, wnd) <$ guard (not $ null wnd) + ( warningName2String w + , (if w `Set.member` usualWarnings then "d" else " ") ++ + (if not (w `Set.member` errorWarnings) then "b" else " ") ++ + " " ++ + wnd + ) <$ guard (not $ null wnd) ] where @@ -249,67 +272,83 @@ warningNameDescription :: WarningName -> String warningNameDescription w = case w of + -- Parser Warnings OverlappingTokensWarning_ -> "Multi-line comments spanning one or more literate text blocks." -- Library Warnings - LibUnknownField_ -> "Unknown field in library file" + LibUnknownField_ -> "Unknown field in library file." -- Nicifer Warnings EmptyAbstract_ -> "Empty `abstract' blocks." + EmptyField_ -> "Empty `field` blocks." + EmptyGeneralize_ -> "Empty `variable' blocks." EmptyInstance_ -> "Empty `instance' blocks." EmptyMacro_ -> "Empty `macro' blocks." EmptyMutual_ -> "Empty `mutual' blocks." EmptyPostulate_ -> "Empty `postulate' blocks." - EmptyPrivate_ -> "Empty `private' blocks." - EmptyGeneralize_ -> "Empty `variable' blocks." EmptyPrimitive_ -> "Empty `primitive' blocks." + EmptyPrivate_ -> "Empty `private' blocks." + EmptyRewritePragma_ -> "Empty `REWRITE' pragmas." InvalidCatchallPragma_ -> "`CATCHALL' pragmas before a non-function clause." + InvalidCoverageCheckPragma_ -> "Coverage checking pragmas before non-function or `mutual' blocks." InvalidNoPositivityCheckPragma_ -> "No positivity checking pragmas before non-`data', `record' or `mutual' blocks." InvalidNoUniverseCheckPragma_ -> "No universe checking pragmas before non-`data' or `record' declaration." InvalidTerminationCheckPragma_ -> "Termination checking pragmas before non-function or `mutual' blocks." MissingDefinitions_ -> "Declarations not associated to a definition." NotAllowedInMutual_ -> "Declarations not allowed in a mutual block." + OpenPublicAbstract_ -> "'open public' directive in an 'abstract' block." + OpenPublicPrivate_ -> "'open public' directive in a 'private' block." PolarityPragmasButNotPostulates_ -> "Polarity pragmas for non-postulates." - PragmaNoTerminationCheck_ -> "`NO_TERMINATION_CHECK' pragmas are deprecated" PragmaCompiled_ -> "'COMPILE' pragmas not allowed in safe mode." + PragmaNoTerminationCheck_ -> "`NO_TERMINATION_CHECK' pragmas are deprecated" + ShadowingInTelescope_ -> "Repeated variable name in telescope." UnknownFixityInMixfixDecl_ -> "Mixfix names without an associated fixity declaration." UnknownNamesInFixityDecl_ -> "Names not declared in the same scope as their syntax or fixity declaration." UnknownNamesInPolarityPragmas_ -> "Names not declared in the same scope as their polarity pragmas." UselessAbstract_ -> "`abstract' blocks where they have no effect." + UselessInline_ -> "`INLINE' pragmas where they have no effect." UselessInstance_ -> "`instance' blocks where they have no effect." UselessPrivate_ -> "`private' blocks where they have no effect." + UselessPublic_ -> "`public' blocks where they have no effect." -- Scope and Type Checking Warnings - OldBuiltin_ -> "Deprecated `BUILTIN' pragmas." - EmptyRewritePragma_ -> "Empty `REWRITE' pragmas." + AbsurdPatternRequiresNoRHS_ -> "A clause with an absurd pattern does not need a Right Hand Side." + CantGeneralizeOverSorts_ -> "Attempt to generalize over sort metas in 'variable' declaration." + ClashesViaRenaming_ -> "Clashes introduced by `renaming'." -- issue #4154 + CoverageIssue_ -> "Failed coverage checks." + CoverageNoExactSplit_ -> "Failed exact split checks." + DeprecationWarning_ -> "Feature deprecation." + GenericNonFatalError_ -> "" + GenericWarning_ -> "" IllformedAsClause_ -> "Illformed `as'-clauses in `import' statements." - UselessPublic_ -> "`public' blocks where they have no effect." - UselessInline_ -> "`INLINE' pragmas where they have no effect." - WrongInstanceDeclaration_ -> "Terms marked as eligible for instance search should end with a name." - InstanceWithExplicitArg_ -> "`instance` declarations with explicit arguments are never considered by instance search." InstanceNoOutputTypeName_ -> "instance arguments whose type does not end in a named or variable type are never considered by instance search." InstanceArgWithExplicitArg_ -> "instance arguments with explicit arguments are never considered by instance search." - UnreachableClauses_ -> "Unreachable function clauses." - GenericWarning_ -> "" - DeprecationWarning_ -> "Feature deprecation." + InstanceWithExplicitArg_ -> "`instance` declarations with explicit arguments are never considered by instance search." InversionDepthReached_ -> "Inversions of pattern-matching failed due to exhausted inversion depth." - TerminationIssue_ -> "Failed termination checks." - CoverageIssue_ -> "Failed coverage checks." - CoverageNoExactSplit_ -> "Failed exact split checks." ModuleDoesntExport_ -> "Imported name is not actually exported." + FixityInRenamingModule_ -> "Found fixity annotation in renaming directive for module." + NotInScope_ -> "Out of scope name" NotStrictlyPositive_ -> "Failed strict positivity checks." - UnsolvedMetaVariables_ -> "Unsolved meta variables." - UnsolvedInteractionMetas_ -> "Unsolved interaction meta variables." - UnsolvedConstraints_ -> "Unsolved constraints." - GenericNonFatalError_ -> "" - SafeFlagPostulate_ -> "`postulate' blocks with the safe flag" - SafeFlagPragma_ -> "Unsafe `OPTIONS' pragmas with the safe flag." + OldBuiltin_ -> "Deprecated `BUILTIN' pragmas." + PragmaCompileErased_ -> "`COMPILE' pragma targeting an erased symbol." + RewriteMaybeNonConfluent_ -> "Failed confluence checks while computing overlap." + RewriteNonConfluent_ -> "Failed confluence checks while joining critical pairs." + SafeFlagEta_ -> "`ETA' pragmas with the safe flag." + SafeFlagInjective_ -> "`INJECTIVE' pragmas with the safe flag." + SafeFlagNoCoverageCheck_ -> "`NON_COVERING` pragmas with the safe flag." SafeFlagNonTerminating_ -> "`NON_TERMINATING' pragmas with the safe flag." - SafeFlagTerminating_ -> "`TERMINATING' pragmas with the safe flag." - SafeFlagWithoutKFlagPrimEraseEquality_ -> "`primEraseEquality' usages with the safe and without-K flags." SafeFlagNoPositivityCheck_ -> "`NO_POSITIVITY_CHECK' pragmas with the safe flag." - SafeFlagPolarity_ -> "`POLARITY' pragmas with the safe flag." SafeFlagNoUniverseCheck_ -> "`NO_UNIVERSE_CHECK' pragmas with the safe flag." - UserWarning_ -> "User-defined warning added using the 'WARNING_ON_USAGE' pragma." - AbsurdPatternRequiresNoRHS_ -> "A clause with an absurd pattern does not need a Right Hand Side." - CantGeneralizeOverSorts_ -> "Attempt to generalize over sort metas in 'variable' declaration." + SafeFlagPolarity_ -> "`POLARITY' pragmas with the safe flag." + SafeFlagPostulate_ -> "`postulate' blocks with the safe flag." + SafeFlagPragma_ -> "Unsafe `OPTIONS' pragmas with the safe flag." + SafeFlagTerminating_ -> "`TERMINATING' pragmas with the safe flag." + SafeFlagWithoutKFlagPrimEraseEquality_ -> "`primEraseEquality' used with the safe and without-K flags." + TerminationIssue_ -> "Failed termination checks." + UnreachableClauses_ -> "Unreachable function clauses." + UnsolvedConstraints_ -> "Unsolved constraints." + UnsolvedInteractionMetas_ -> "Unsolved interaction meta variables." + UnsolvedMetaVariables_ -> "Unsolved meta variables." + UserWarning_ -> "User-defined warning added using one of the 'WARNING_ON_*' pragmas." WithoutKFlagPrimEraseEquality_ -> "`primEraseEquality' usages with the without-K flags." - InfectiveImport_ -> "Importing a file using e.g. `--cubical' into one which doesn't" - CoInfectiveImport_ -> "Importing a file not using e.g. `--safe' from one which does" + WrongInstanceDeclaration_ -> "Terms marked as eligible for instance search should end with a name." + -- Checking consistency of options + CoInfectiveImport_ -> "Importing a file not using e.g. `--safe' from one which does." + InfectiveImport_ -> "Importing a file using e.g. `--cubical' into one which doesn't." diff --git a/src/full/Agda/Interaction/Response.hs b/src/full/Agda/Interaction/Response.hs --- a/src/full/Agda/Interaction/Response.hs +++ b/src/full/Agda/Interaction/Response.hs @@ -1,5 +1,3 @@ -{-# LANGUAGE CPP #-} - ------------------------------------------------------------------------ -- | Data type for all interactive responses ------------------------------------------------------------------------ @@ -9,24 +7,37 @@ , RemoveTokenBasedHighlighting (..) , MakeCaseVariant (..) , DisplayInfo (..) + , GoalDisplayInfo(..) + , Goals + , WarningsAndNonFatalErrors + , Info_Error(..) + , GoalTypeAux(..) + , ResponseContextEntry(..) , Status (..) , GiveResult (..) , InteractionOutputCallback , defaultInteractionOutputCallback ) where +import Agda.Interaction.Base + (CommandState, OutputForm, ComputeMode, Rewrite, OutputConstraint, OutputConstraint') import Agda.Interaction.Highlighting.Precise +import qualified Agda.Syntax.Abstract as A +import Agda.Syntax.Common (InteractionId(..), Arg) +import Agda.Syntax.Concrete (Expr, Name) +import Agda.Syntax.Concrete.Name (NameInScope) +import Agda.Syntax.Scope.Base (AbstractModule, AbstractName, LocalVar) +import qualified Agda.Syntax.Internal as I import {-# SOURCE #-} Agda.TypeChecking.Monad.Base -import Agda.Syntax.Common (InteractionId(..)) -import Agda.Syntax.Concrete (Expr) -import Agda.Utils.Pretty + (TCM, TCErr, TCWarning, HighlightingMethod, ModuleToSource, NamedMeta, TCWarning, IPBoundary') +import Agda.TypeChecking.Warnings (WarningsAndNonFatalErrors) +import Agda.Utils.Impossible +import Agda.Utils.Time import Control.Monad.Trans import Data.Int import System.IO - -#include "undefined.h" -import Agda.Utils.Impossible +import Agda.Utils.Pretty (Doc) -- | Responses for any interactive interface -- @@ -43,7 +54,8 @@ | Resp_JumpToError FilePath Int32 | Resp_InteractionPoints [InteractionId] | Resp_GiveAction InteractionId GiveResult - | Resp_MakeCase MakeCaseVariant [String] + | Resp_MakeCase InteractionId MakeCaseVariant [String] + -- ^ Response is list of printed clauses. | Resp_SolveAll [(InteractionId, Expr)] -- ^ Solution for one or more meta-variables. | Resp_DisplayInfo DisplayInfo @@ -55,6 +67,9 @@ | Resp_DoneAborting -- ^ A command sent when an abort command has completed -- successfully. + | Resp_DoneExiting + -- ^ A command sent when an exit command is about to be + -- completed. -- | Should token-based highlighting be removed in conjunction with -- the application of new highlighting (in order to reduce the risk of @@ -73,33 +88,67 @@ -- | Info to display at the end of an interactive command data DisplayInfo - = Info_CompilationOk String String - -- ^ Strings are the warnings and the (non-fatal) errors - | Info_Constraints String - | Info_AllGoalsWarnings String String String - -- ^ Strings are the goals, the warnings and the (non-fatal) errors - | Info_Time Doc - | Info_Error String + = Info_CompilationOk WarningsAndNonFatalErrors + | Info_Constraints [OutputForm Expr Expr] + | Info_AllGoalsWarnings Goals WarningsAndNonFatalErrors + | Info_Time CPUTime + | Info_Error Info_Error -- ^ When an error message is displayed this constructor should be -- used, if appropriate. - | Info_Intro Doc - -- ^ 'Info_Intro' denotes two different types of errors - -- TODO: split these into separate constructors + | Info_Intro_NotFound + | Info_Intro_ConstructorUnknown [String] | Info_Auto String -- ^ 'Info_Auto' denotes either an error or a success (when 'Resp_GiveAction' is present) -- TODO: split these into separate constructors - | Info_ModuleContents Doc - | Info_SearchAbout Doc - | Info_WhyInScope Doc - | Info_NormalForm Doc - | Info_GoalType Doc - | Info_CurrentGoal Doc - | Info_InferredType Doc - | Info_Context Doc - | Info_HelperFunction Doc + | Info_ModuleContents [Name] I.Telescope [(Name, I.Type)] + | Info_SearchAbout [(Name, I.Type)] String + | Info_WhyInScope String FilePath (Maybe LocalVar) [AbstractName] [AbstractModule] + | Info_NormalForm CommandState ComputeMode (Maybe CPUTime) A.Expr + | Info_InferredType CommandState (Maybe CPUTime) A.Expr + | Info_Context InteractionId [ResponseContextEntry] | Info_Version - deriving Show + | Info_GoalSpecific InteractionId GoalDisplayInfo +data GoalDisplayInfo + = Goal_HelperFunction (OutputConstraint' A.Expr A.Expr) + | Goal_NormalForm ComputeMode A.Expr + | Goal_GoalType Rewrite GoalTypeAux [ResponseContextEntry] [IPBoundary' Expr] [OutputForm Expr Expr] + | Goal_CurrentGoal Rewrite + | Goal_InferredType A.Expr + +-- | Goals & Warnings +type Goals = ( [OutputConstraint A.Expr InteractionId] -- visible metas (goals) + , [OutputConstraint A.Expr NamedMeta] -- hidden (unsolved) metas + ) + +-- | Errors that goes into Info_Error +-- +-- When an error message is displayed this constructor should be +-- used, if appropriate. +data Info_Error + = Info_GenericError TCErr + | Info_CompilationError [TCWarning] + | Info_HighlightingParseError InteractionId + | Info_HighlightingScopeCheckError InteractionId + +-- | Auxiliary information that comes with Goal Type + +data GoalTypeAux + = GoalOnly + | GoalAndHave A.Expr + | GoalAndElaboration I.Term + +-- | Entry in context. + +data ResponseContextEntry = ResponseContextEntry + { respOrigName :: Name -- ^ The original concrete name. + , respReifName :: Name -- ^ The name reified from abstract syntax. + , respType :: Arg A.Expr -- ^ The type. + , respLetValue :: Maybe A.Expr -- ^ The value (if it is a let-bound variable) + , respInScope :: NameInScope -- ^ Whether the 'respReifName' is in scope. + } + + -- | Status information. data Status = Status @@ -159,3 +208,4 @@ Resp_ClearRunningInfo {} -> __IMPOSSIBLE__ Resp_ClearHighlighting {} -> __IMPOSSIBLE__ Resp_DoneAborting {} -> __IMPOSSIBLE__ + Resp_DoneExiting {} -> __IMPOSSIBLE__ diff --git a/src/full/Agda/Interaction/Response.hs-boot b/src/full/Agda/Interaction/Response.hs-boot new file mode 100644 --- /dev/null +++ b/src/full/Agda/Interaction/Response.hs-boot @@ -0,0 +1,40 @@ +module Agda.Interaction.Response where + +import Data.Int (Int32) + +import Agda.Syntax.Common (InteractionId) +import Agda.Syntax.Concrete (Expr) + +import {-# SOURCE #-} Agda.TypeChecking.Monad.Base + (TCM, ModuleToSource, HighlightingMethod) + +import Agda.Interaction.Highlighting.Precise + (TokenBased, HighlightingInfo) + +data Response + = Resp_HighlightingInfo + HighlightingInfo + RemoveTokenBasedHighlighting + HighlightingMethod + ModuleToSource + | Resp_Status Status + | Resp_JumpToError FilePath Int32 + | Resp_InteractionPoints [InteractionId] + | Resp_GiveAction InteractionId GiveResult + | Resp_MakeCase InteractionId MakeCaseVariant [String] + | Resp_SolveAll [(InteractionId, Expr)] + | Resp_DisplayInfo DisplayInfo + | Resp_RunningInfo Int String + | Resp_ClearRunningInfo + | Resp_ClearHighlighting TokenBased + | Resp_DoneAborting + | Resp_DoneExiting + +data MakeCaseVariant +data DisplayInfo +data RemoveTokenBasedHighlighting +data GiveResult +data Status + +type InteractionOutputCallback = Response -> TCM () +defaultInteractionOutputCallback :: InteractionOutputCallback diff --git a/src/full/Agda/Interaction/SearchAbout.hs b/src/full/Agda/Interaction/SearchAbout.hs --- a/src/full/Agda/Interaction/SearchAbout.hs +++ b/src/full/Agda/Interaction/SearchAbout.hs @@ -14,10 +14,10 @@ import Agda.TypeChecking.Monad.Signature import Agda.TypeChecking.Monad.Env import Agda.Syntax.Internal.Names (namesIn) -import Agda.Interaction.BasicOps (normalForm, Rewrite, parseName) +import Agda.Interaction.Base (Rewrite) +import Agda.Interaction.BasicOps (normalForm, parseName) import qualified Agda.Syntax.Concrete as C -import qualified Agda.Syntax.Abstract as A import qualified Agda.Syntax.Internal as I import Agda.Utils.Pretty ( prettyShow ) @@ -36,13 +36,13 @@ -- We separate the strings from the names by a rough analysis -- and then parse and resolve the names in the current scope let (userSubStrings, nms) = partitionEithers $ isString <$> words nm - rnms <- mapM (parseName rg >=> resolveName) nms + rnms <- mapM (resolveName <=< parseName rg) nms let userIdentifiers = fmap (fmap anameName . anames) rnms -- We then collect all the things in scope, by name. -- Issue #2381: We explicitly filter out pattern synonyms because they -- don't have a type. Looking it up makes Agda panic! - snms <- fmap (nsNames . allThingsInScope) $ currentModule >>= getNamedScope + snms <- fmap (nsNames . allThingsInScope) $ getNamedScope =<< currentModule let namesInScope = filter ((PatternSynName /=) . anameKind . snd) $ concatMap (uncurry $ map . (,)) $ Map.toList snms @@ -53,11 +53,9 @@ -- criteria. ress <- forM namesInScope $ \ (x, n) -> do t <- normalForm norm =<< typeOfConst (anameName n) - let namesInT = Set.toList $ namesIn t - let defName = prettyShow x return $ do - guard $ all (`isInfixOf` defName) userSubStrings - guard $ all (any (`elem` namesInT)) userIdentifiers + guard $ all (`isInfixOf` prettyShow x) userSubStrings + guard $ all (any (`Set.member` namesIn t)) userIdentifiers return (x, t) return $ concat ress diff --git a/src/full/Agda/Main.hs b/src/full/Agda/Main.hs --- a/src/full/Agda/Main.hs +++ b/src/full/Agda/Main.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-| Agda main module. -} @@ -12,10 +11,6 @@ import System.Exit import System.Console.GetOpt -import Agda.Syntax.Position (Range) -import Agda.Syntax.Concrete.Pretty () -import Agda.Syntax.Abstract.Name (toTopLevelModuleName) - import Agda.Interaction.CommandLine import Agda.Interaction.Options import Agda.Interaction.Options.Help (Help (..)) @@ -23,6 +18,7 @@ import Agda.Interaction.EmacsTop (mimicGHCi) import Agda.Interaction.JSONTop (jsonREPL) import Agda.Interaction.Imports (MaybeWarnings'(..)) +import Agda.Interaction.FindFile ( SourceFile(SourceFile) ) import qualified Agda.Interaction.Imports as Imp import qualified Agda.Interaction.Highlighting.Dot as Dot import qualified Agda.Interaction.Highlighting.LaTeX as LaTeX @@ -34,13 +30,11 @@ import Agda.TypeChecking.Warnings import Agda.TypeChecking.Pretty -import Agda.Compiler.Common (IsMain (..)) import Agda.Compiler.MAlonzo.Compiler (ghcBackend) import Agda.Compiler.JS.Compiler (jsBackend) import Agda.Compiler.Backend -import Agda.Utils.Lens import Agda.Utils.Monad import Agda.Utils.String @@ -49,10 +43,7 @@ import qualified Agda.Utils.Benchmark as UtilsBench import Agda.Utils.Except ( MonadError(catchError, throwError) ) import Agda.Utils.Impossible -import Agda.Utils.Lens -#include "undefined.h" - builtinBackends :: [Backend] builtinBackends = [ ghcBackend, jsBackend ] @@ -138,7 +129,7 @@ then Imp.ScopeCheck else Imp.TypeCheck - file <- getInputFile + file <- SourceFile <$> getInputFile (i, mw) <- Imp.typeCheckMain file mode =<< Imp.sourceInfo file -- An interface is only generated if the mode is @@ -164,7 +155,7 @@ LaTeX.generateLaTeX i -- Print accumulated warnings - ws <- (snd . classifyWarnings) <$> Imp.getAllWarnings AllWarnings + ws <- tcWarnings . classifyWarnings <$> Imp.getAllWarnings AllWarnings unless (null ws) $ do let banner = text $ "\n" ++ delimiter "All done; warnings encountered" reportSDoc "warning" 1 $ diff --git a/src/full/Agda/Main.hs-boot b/src/full/Agda/Main.hs-boot new file mode 100644 --- /dev/null +++ b/src/full/Agda/Main.hs-boot @@ -0,0 +1,5 @@ +module Agda.Main where + +import {-# SOURCE #-} Agda.Compiler.Backend + +builtinBackends :: [Backend] diff --git a/src/full/Agda/Syntax/Abstract.hs b/src/full/Agda/Syntax/Abstract.hs --- a/src/full/Agda/Syntax/Abstract.hs +++ b/src/full/Agda/Syntax/Abstract.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} @@ -13,7 +12,7 @@ ) where import Prelude -import Control.Arrow (first, second, (***)) +import Control.Arrow (first)--, second, (***)) import Data.Foldable (Foldable) import qualified Data.Foldable as Fold @@ -24,38 +23,27 @@ import qualified Data.Sequence as Seq import qualified Data.Set as Set import Data.Set (Set) -import Data.Traversable import Data.Void - import Data.Data (Data) import Data.Monoid (mappend) -import Agda.Syntax.Concrete.Name (NumHoles(..)) -import Agda.Syntax.Concrete (FieldAssignment'(..), exprFieldA, HoleContent'(..)) +import Agda.Syntax.Concrete (FieldAssignment'(..), exprFieldA)--, HoleContent'(..)) import qualified Agda.Syntax.Concrete as C -import Agda.Syntax.Concrete.Pretty () - import Agda.Syntax.Abstract.Name import Agda.Syntax.Abstract.Name as A (QNamed) - import qualified Agda.Syntax.Internal as I - import Agda.Syntax.Common import Agda.Syntax.Info -import Agda.Syntax.Fixity ( Fixity' ) import Agda.Syntax.Literal import Agda.Syntax.Position import Agda.Syntax.Scope.Base import Agda.TypeChecking.Positivity.Occurrence -import Agda.Utils.Functor import Agda.Utils.Geniplate import Agda.Utils.Lens -import Agda.Utils.NonemptyList import Agda.Utils.Pretty -#include "undefined.h" import Agda.Utils.Impossible -- | A name in a binding position: we also compare the nameConcrete @@ -67,15 +55,18 @@ -- e.g. in @{_ : A} -> ..@ vs. @{r : A} -> ..@. newtype BindName = BindName { unBind :: Name } - deriving (Show, Data, HasRange, SetRange, KillRange) + deriving (Show, Data, HasRange, KillRange, SetRange) +mkBindName :: Name -> BindName +mkBindName x = BindName x + instance Eq BindName where - (BindName n) == (BindName m) + BindName n == BindName m = ((==) `on` nameId) n m && ((==) `on` nameConcrete) n m instance Ord BindName where - (BindName n) `compare` (BindName m) + BindName n `compare` BindName m = (compare `on` nameId) n m `mappend` (compare `on` nameConcrete) n m @@ -115,13 +106,11 @@ | Rec ExprInfo RecordAssigns -- ^ Record construction. | RecUpdate ExprInfo Expr Assigns -- ^ Record update. | ScopedExpr ScopeInfo Expr -- ^ Scope annotation. - | QuoteGoal ExprInfo Name Expr -- ^ Binds @Name@ to current type in @Expr@. - | QuoteContext ExprInfo -- ^ Returns the current context. | Quote ExprInfo -- ^ Quote an identifier 'QName'. | QuoteTerm ExprInfo -- ^ Quote a term. | Unquote ExprInfo -- ^ The splicing construct: unquote ... - | Tactic ExprInfo Expr [NamedArg Expr] [NamedArg Expr] - -- ^ @tactic e x1 .. xn | y1 | .. | yn@ + | Tactic ExprInfo Expr [NamedArg Expr] + -- ^ @tactic e x1 .. xn@ | DontCare Expr -- ^ For printing @DontCare@ from @Syntax.Internal@. deriving (Data, Show) @@ -200,21 +189,7 @@ | ScopedDecl ScopeInfo [Declaration] -- ^ scope annotation deriving (Data, Show) -class GetDefInfo a where - getDefInfo :: a -> Maybe DefInfo - -instance GetDefInfo Declaration where - getDefInfo (Axiom _ i _ _ _ _) = Just i - getDefInfo (Generalize _ i _ _ _) = Just i - getDefInfo (Field i _ _) = Just i - getDefInfo (Primitive i _ _) = Just i - getDefInfo (ScopedDecl _ (d:_)) = getDefInfo d - getDefInfo (FunDef i _ _ _) = Just i - getDefInfo (DataSig i _ _ _) = Just i - getDefInfo (DataDef i _ _ _ _) = Just i - getDefInfo (RecSig i _ _ _) = Just i - getDefInfo (RecDef i _ _ _ _ _ _ _ _) = Just i - getDefInfo _ = Nothing +type DefInfo = DefInfo' Expr type ImportDirective = ImportDirective' QName ModuleName type Renaming = Renaming' QName ModuleName @@ -229,14 +204,15 @@ data Pragma = OptionsPragma [String] - | BuiltinPragma String ResolvedName + | BuiltinPragma RString ResolvedName -- ^ 'ResolvedName' is not 'UnknownName'. -- Name can be ambiguous e.g. for built-in constructors. - | BuiltinNoDefPragma String QName + | BuiltinNoDefPragma RString QName -- ^ Builtins that do not come with a definition, -- but declare a name for an Agda concept. - | RewritePragma QName - | CompilePragma String QName String + | RewritePragma Range [QName] + -- ^ Range is range of REWRITE keyword. + | CompilePragma RString QName String | StaticPragma QName | EtaPragma QName -- ^ For coinductive records, use pragma instead of regular @@ -269,12 +245,35 @@ type Constructor = TypeSignature type Field = TypeSignature +type TacticAttr = Maybe Expr + +-- A Binder @x\@p@, the pattern is optional +data Binder' a = Binder + { binderPattern :: Maybe Pattern + , binderName :: a + } deriving (Data, Show, Eq, Functor, Foldable, Traversable) + +type Binder = Binder' BindName + +mkBinder :: a -> Binder' a +mkBinder = Binder Nothing + +mkBinder_ :: Name -> Binder +mkBinder_ = mkBinder . mkBindName + +extractPattern :: Binder' a -> Maybe (Pattern, a) +extractPattern (Binder p a) = (,a) <$> p + -- | A lambda binding is either domain free or typed. data LamBinding - = DomainFree (NamedArg BindName) -- ^ . @x@ or @{x}@ or @.x@ or @{x = y}@ - | DomainFull TypedBinding -- ^ . @(xs:e)@ or @{xs:e}@ or @(let Ds)@ + = DomainFree TacticAttr (NamedArg Binder) + -- ^ . @x@ or @{x}@ or @.x@ or @{x = y}@ or @x\@p@ or @(p)@ + | DomainFull TypedBinding + -- ^ . @(xs:e)@ or @{xs:e}@ or @(let Ds)@ deriving (Data, Show, Eq) +mkDomainFree :: NamedArg Binder -> LamBinding +mkDomainFree = DomainFree Nothing -- | A typed binding. Appears in dependent function spaces, typed lambdas, and -- telescopes. It might be tempting to simplify this to only bind a single @@ -291,12 +290,14 @@ -- that the metas of the copy are aliases of the metas of the original. data TypedBinding - = TBind Range [NamedArg BindName] Expr + = TBind Range TacticAttr [NamedArg Binder] Expr -- ^ As in telescope @(x y z : A)@ or type @(x y z : A) -> B@. | TLet Range [LetBinding] -- ^ E.g. @(let x = e)@ or @(let open M)@. deriving (Data, Show, Eq) +mkTBind :: Range -> [NamedArg Binder] -> Expr -> TypedBinding +mkTBind r = TBind r Nothing type Telescope = [TypedBinding] @@ -332,7 +333,7 @@ data ProblemEq = ProblemEq { problemInPat :: Pattern , problemInst :: I.Term - , problemType :: Dom I.Type + , problemType :: I.Dom I.Type } deriving (Data, Show) -- These are not relevant for caching purposes @@ -361,6 +362,7 @@ type Clause = Clause' LHS type SpineClause = Clause' SpineLHS +type RewriteEqn = RewriteEqn' QName Pattern Expr data RHS = RHS @@ -371,10 +373,10 @@ -- 'Nothing' for internally generated rhss. } | AbsurdRHS - | WithRHS QName [Expr] [Clause] + | WithRHS QName [WithHiding Expr] [Clause] -- ^ The 'QName' is the name of the with function. | RewriteRHS - { rewriteExprs :: [(QName, Expr)] + { rewriteExprs :: [RewriteEqn] -- ^ The 'QName's are the names of the generated with functions, -- one for each 'Expr'. , rewriteStrippedPats :: [ProblemEq] @@ -496,7 +498,7 @@ Things we parse but are not part of the Agda file syntax --------------------------------------------------------------------------} -type HoleContent = C.HoleContent' Expr +type HoleContent = C.HoleContent' () Pattern Expr {-------------------------------------------------------------------------- Instances @@ -532,12 +534,10 @@ ETel a1 == ETel a2 = a1 == a2 Rec a1 b1 == Rec a2 b2 = (a1, b1) == (a2, b2) RecUpdate a1 b1 c1 == RecUpdate a2 b2 c2 = (a1, b1, c1) == (a2, b2, c2) - QuoteGoal a1 b1 c1 == QuoteGoal a2 b2 c2 = (a1, b1, c1) == (a2, b2, c2) - QuoteContext a1 == QuoteContext a2 = a1 == a2 Quote a1 == Quote a2 = a1 == a2 QuoteTerm a1 == QuoteTerm a2 = a1 == a2 Unquote a1 == Unquote a2 = a1 == a2 - Tactic a1 b1 c1 d1 == Tactic a2 b2 c2 d2 = (a1, b1, c1, d1) == (a2, b2, c2, d2) + Tactic a1 b1 c1 == Tactic a2 b2 c2 = (a1, b1, c1) == (a2, b2, c2) DontCare a1 == DontCare a2 = a1 == a2 _ == _ = False @@ -573,24 +573,27 @@ isUnderscore = __IMPOSSIBLE__ instance LensHiding LamBinding where - getHiding (DomainFree x) = getHiding x - getHiding (DomainFull tb) = getHiding tb - mapHiding f (DomainFree x) = DomainFree $ mapHiding f x - mapHiding f (DomainFull tb) = DomainFull $ mapHiding f tb + getHiding (DomainFree _ x) = getHiding x + getHiding (DomainFull tb) = getHiding tb + mapHiding f (DomainFree t x) = DomainFree t $ mapHiding f x + mapHiding f (DomainFull tb) = DomainFull $ mapHiding f tb instance LensHiding TypedBinding where - getHiding (TBind _ (x : _) _) = getHiding x -- Slightly dubious - getHiding (TBind _ [] _) = __IMPOSSIBLE__ - getHiding TLet{} = mempty - mapHiding f (TBind r xs e) = TBind r ((map . mapHiding) f xs) e - mapHiding f b@TLet{} = b + getHiding (TBind _ _ (x : _) _) = getHiding x -- Slightly dubious + getHiding (TBind _ _ [] _) = __IMPOSSIBLE__ + getHiding TLet{} = mempty + mapHiding f (TBind r t xs e) = TBind r t ((map . mapHiding) f xs) e + mapHiding f b@TLet{} = b +instance HasRange a => HasRange (Binder' a) where + getRange (Binder p n) = fuseRange p n + instance HasRange LamBinding where - getRange (DomainFree x) = getRange x - getRange (DomainFull b) = getRange b + getRange (DomainFree _ x) = getRange x + getRange (DomainFull b) = getRange b instance HasRange TypedBinding where - getRange (TBind r _ _) = r + getRange (TBind r _ _ _) = r getRange (TLet r _) = r instance HasRange Expr where @@ -617,12 +620,10 @@ getRange (RecUpdate i _ _) = getRange i getRange (ETel tel) = getRange tel getRange (ScopedExpr _ e) = getRange e - getRange (QuoteGoal _ _ e) = getRange e - getRange (QuoteContext i) = getRange i getRange (Quote i) = getRange i getRange (QuoteTerm i) = getRange i getRange (Unquote i) = getRange i - getRange (Tactic i _ _ _) = getRange i + getRange (Tactic i _ _) = getRange i getRange (DontCare{}) = noRange getRange (PatternSyn x) = getRange x getRange (Macro x) = getRange x @@ -678,10 +679,10 @@ getRange (Clause lhs _ rhs ds catchall) = getRange (lhs, rhs, ds) instance HasRange RHS where - getRange AbsurdRHS = noRange - getRange (RHS e _) = getRange e - getRange (WithRHS _ e cs) = fuseRange e cs - getRange (RewriteRHS xes _ rhs wh) = getRange (map snd xes, rhs, wh) + getRange AbsurdRHS = noRange + getRange (RHS e _) = getRange e + getRange (WithRHS _ e cs) = fuseRange e cs + getRange (RewriteRHS xes _ rhs wh) = getRange (xes, rhs, wh) instance HasRange WhereDeclarations where getRange (WhereDecls _ ds) = getRange ds @@ -709,9 +710,12 @@ setRange r (EqualP _ es) = EqualP (PatRange r) es setRange r (WithP i p) = WithP (setRange r i) p +instance KillRange a => KillRange (Binder' a) where + killRange (Binder a b) = killRange2 Binder a b + instance KillRange LamBinding where - killRange (DomainFree x) = killRange1 DomainFree x - killRange (DomainFull b) = killRange1 DomainFull b + killRange (DomainFree t x) = killRange2 DomainFree t x + killRange (DomainFull b) = killRange1 DomainFull b instance KillRange GeneralizeTelescope where killRange (GeneralizeTel s tel) = GeneralizeTel s (killRange tel) @@ -720,8 +724,8 @@ killRange (DataDefParams s tel) = DataDefParams s (killRange tel) instance KillRange TypedBinding where - killRange (TBind r xs e) = killRange3 TBind r xs e - killRange (TLet r lbs) = killRange2 TLet r lbs + killRange (TBind r t xs e) = killRange4 TBind r t xs e + killRange (TLet r lbs) = killRange2 TLet r lbs instance KillRange Expr where killRange (Var x) = killRange1 Var x @@ -747,12 +751,10 @@ killRange (RecUpdate i e fs) = killRange3 RecUpdate i e fs killRange (ETel tel) = killRange1 ETel tel killRange (ScopedExpr s e) = killRange1 (ScopedExpr s) e - killRange (QuoteGoal i x e) = killRange3 QuoteGoal i x e - killRange (QuoteContext i) = killRange1 QuoteContext i killRange (Quote i) = killRange1 Quote i killRange (QuoteTerm i) = killRange1 QuoteTerm i killRange (Unquote i) = killRange1 Unquote i - killRange (Tactic i e xs ys) = killRange4 Tactic i e xs ys + killRange (Tactic i e xs) = killRange3 Tactic i e xs killRange (DontCare e) = killRange1 DontCare e killRange (PatternSyn x) = killRange1 PatternSyn x killRange (Macro x) = killRange1 Macro x @@ -851,6 +853,7 @@ instanceUniverseBiT' [] [t| (Declaration, NamedArg BindName) |] instanceUniverseBiT' [] [t| (Declaration, NamedArg Expr) |] instanceUniverseBiT' [] [t| (Declaration, NamedArg Pattern) |] +instanceUniverseBiT' [] [t| (Declaration, Quantity) |] ------------------------------------------------------------------------ -- Queries @@ -879,6 +882,9 @@ instance (AllNames a, AllNames b) => AllNames (a,b) where allNames (a,b) = allNames a >< allNames b +instance (AllNames a, AllNames b, AllNames c) => AllNames (a,b,c) where + allNames (a,b,c) = allNames a >< allNames b >< allNames c + instance AllNames QName where allNames q = Seq.singleton q @@ -906,11 +912,16 @@ instance AllNames Clause where allNames cl = allNames (clauseRHS cl, clauseWhereDecls cl) +instance (AllNames qn, AllNames e) => AllNames (RewriteEqn' qn p e) where + allNames = \case + Rewrite es -> Fold.foldMap allNames es + Invert qn pes -> allNames qn >< foldMap (Fold.foldMap allNames) pes + instance AllNames RHS where allNames (RHS e _) = allNames e allNames AbsurdRHS{} = Seq.empty allNames (WithRHS q _ cls) = q <| allNames cls - allNames (RewriteRHS qes _ rhs cls) = Seq.fromList (map fst qes) >< allNames rhs >< allNames cls + allNames (RewriteRHS qes _ rhs cls) = allNames (qes, rhs, cls) instance AllNames WhereDeclarations where allNames (WhereDecls _ ds) = allNames ds @@ -939,12 +950,10 @@ allNames (Rec _ fields) = allNames [ a ^. exprFieldA | Left a <- fields ] allNames (RecUpdate _ e fs) = allNames e >< allNames (map (view exprFieldA) fs) allNames (ScopedExpr _ e) = allNames e - allNames (QuoteGoal _ _ e) = allNames e - allNames (QuoteContext _) = Seq.empty allNames Quote{} = Seq.empty allNames QuoteTerm{} = Seq.empty allNames Unquote{} = Seq.empty - allNames (Tactic _ e xs ys) = allNames e >< allNames xs >< allNames ys + allNames (Tactic _ e xs) = allNames e >< allNames xs allNames DontCare{} = Seq.empty allNames PatternSyn{} = Seq.empty allNames Macro{} = Seq.empty @@ -954,7 +963,7 @@ allNames (DomainFull binds) = allNames binds instance AllNames TypedBinding where - allNames (TBind _ _ e) = allNames e + allNames (TBind _ t _ e) = allNames (t, e) allNames (TLet _ lbs) = allNames lbs instance AllNames LetBinding where @@ -999,29 +1008,43 @@ anyAbstract (RecSig i _ _ _) = defAbstract i == AbstractDef anyAbstract _ = __IMPOSSIBLE__ +-- | Turn a name into an expression. + class NameToExpr a where - nameExpr :: a -> Expr + nameToExpr :: a -> Expr --- | Turn an 'AbstractName' to an expression. +-- | Turn an 'AbstractName' into an expression. + instance NameToExpr AbstractName where - nameExpr d = mk (anameKind d) $ anameName d + nameToExpr d = + case anameKind d of + DataName -> Def x + RecName -> Def x + AxiomName -> Def x + PrimName -> Def x + FunName -> Def x + OtherDefName -> Def x + GeneralizeName -> Def x + DisallowedGeneralizeName -> Def x + FldName -> Proj ProjSystem ux + ConName -> Con ux + PatternSynName -> PatternSyn ux + MacroName -> Macro x + QuotableName -> App (defaultAppInfo r) (Quote i) (defaultNamedArg $ Def x) where - mk DefName x = Def x - mk GeneralizeName x = Def x - mk DisallowedGeneralizeName x = Def x - mk FldName x = Proj ProjSystem $ unambiguous x - mk ConName x = Con $ unambiguous x - mk PatternSynName x = PatternSyn $ unambiguous x - mk MacroName x = Macro x - mk QuotableName x = App (defaultAppInfo r) (Quote i) (defaultNamedArg $ Def x) - where i = ExprRange r - r = getRange x + x = anameName d + ux = unambiguous x + r = getRange x + i = ExprRange r --- | Assumes name is not 'UnknownName'. +-- | Turn a 'ResolvedName' into an expression. +-- +-- Assumes name is not 'UnknownName'. + instance NameToExpr ResolvedName where - nameExpr = \case + nameToExpr = \case VarName x _ -> Var x - DefinedName _ x -> nameExpr x -- Can be 'DefName', 'MacroName', 'QuotableName'. + DefinedName _ x -> nameToExpr x -- Can be 'isDefName', 'MacroName', 'QuotableName'. FieldName xs -> Proj ProjSystem . AmbQ . fmap anameName $ xs ConstructorName xs -> Con . AmbQ . fmap anameName $ xs PatternSynResName xs -> PatternSyn . AmbQ . fmap anameName $ xs @@ -1035,34 +1058,36 @@ mkLet i ds e = Let i ds e patternToExpr :: Pattern -> Expr -patternToExpr (VarP x) = Var (unBind x) -patternToExpr (ConP _ c ps) = - Con c `app` map (fmap (fmap patternToExpr)) ps -patternToExpr (ProjP _ o ds) = Proj o ds -patternToExpr (DefP _ fs ps) = - Def (headAmbQ fs) `app` map (fmap (fmap patternToExpr)) ps -patternToExpr (WildP _) = Underscore emptyMetaInfo -patternToExpr (AsP _ _ p) = patternToExpr p -patternToExpr (DotP _ e) = e -patternToExpr (AbsurdP _) = Underscore emptyMetaInfo -- TODO: could this happen? -patternToExpr (LitP l) = Lit l -patternToExpr (PatternSynP _ c ps) = PatternSyn c `app` (map . fmap . fmap) patternToExpr ps -patternToExpr (RecP _ as) = Rec exprNoRange $ map (Left . fmap patternToExpr) as -patternToExpr EqualP{} = __IMPOSSIBLE__ -- Andrea TODO: where is this used? -patternToExpr (WithP r p) = __IMPOSSIBLE__ +patternToExpr = \case + VarP x -> Var (unBind x) + ConP _ c ps -> Con c `app` map (fmap (fmap patternToExpr)) ps + ProjP _ o ds -> Proj o ds + DefP _ fs ps -> Def (headAmbQ fs) `app` map (fmap (fmap patternToExpr)) ps + WildP _ -> Underscore emptyMetaInfo + AsP _ _ p -> patternToExpr p + DotP _ e -> e + AbsurdP _ -> Underscore emptyMetaInfo -- TODO: could this happen? + LitP l -> Lit l + PatternSynP _ c ps -> PatternSyn c `app` (map . fmap . fmap) patternToExpr ps + RecP _ as -> Rec exprNoRange $ map (Left . fmap patternToExpr) as + EqualP{} -> __IMPOSSIBLE__ -- Andrea TODO: where is this used? + WithP r p -> __IMPOSSIBLE__ type PatternSynDefn = ([Arg Name], Pattern' Void) type PatternSynDefns = Map QName PatternSynDefn lambdaLiftExpr :: [Name] -> Expr -> Expr lambdaLiftExpr [] e = e -lambdaLiftExpr (n:ns) e = Lam exprNoRange (DomainFree $ defaultNamedArg $ BindName n) $ - lambdaLiftExpr ns e - +lambdaLiftExpr (n:ns) e = + Lam exprNoRange (mkDomainFree $ defaultNamedArg $ mkBinder_ n) $ + lambdaLiftExpr ns e class SubstExpr a where substExpr :: [(Name, Expr)] -> a -> a +instance SubstExpr a => SubstExpr (Maybe a) where + substExpr = fmap . substExpr + instance SubstExpr a => SubstExpr [a] where substExpr = fmap . substExpr @@ -1114,12 +1139,10 @@ RecUpdate i e nes -> RecUpdate i (substExpr s e) (substExpr s nes) -- XXX: Do we need to do more with ScopedExprs? ScopedExpr si e -> ScopedExpr si (substExpr s e) - QuoteGoal i n e -> QuoteGoal i n (substExpr s e) - QuoteContext i -> e Quote i -> e QuoteTerm i -> e Unquote i -> e - Tactic i e xs ys -> Tactic i (substExpr s e) (substExpr s xs) (substExpr s ys) + Tactic i e xs -> Tactic i (substExpr s e) (substExpr s xs) DontCare e -> DontCare (substExpr s e) PatternSyn{} -> e Macro{} -> e @@ -1132,12 +1155,17 @@ instance SubstExpr TypedBinding where substExpr s tb = case tb of - TBind r ns e -> TBind r ns $ substExpr s e - TLet r lbs -> TLet r $ substExpr s lbs + TBind r t ns e -> TBind r (substExpr s t) ns $ substExpr s e + TLet r lbs -> TLet r $ substExpr s lbs -- TODO: more informative failure -insertImplicitPatSynArgs :: HasRange a => (Range -> a) -> Range -> [Arg Name] -> [NamedArg a] -> - Maybe ([(Name, a)], [Arg Name]) +insertImplicitPatSynArgs + :: HasRange a + => (Range -> a) + -> Range + -> [Arg Name] + -> [NamedArg a] + -> Maybe ([(Name, a)], [Arg Name]) insertImplicitPatSynArgs wild r ns as = matchArgs r ns as where matchNextArg r n as@(~(a : as')) @@ -1146,10 +1174,9 @@ | otherwise = return (wild r, as) matchNext _ [] = False - matchNext n (a:as) = sameHiding n a && matchName + matchNext n (a:as) = sameHiding n a && maybe True (x ==) (bareNameOf a) where - x = unranged $ C.nameToRawName $ nameConcrete $ unArg n - matchName = maybe True (== x) (nameOf $ unArg a) + x = C.nameToRawName $ nameConcrete $ unArg n matchArgs r [] [] = return ([], []) matchArgs r [] as = Nothing diff --git a/src/full/Agda/Syntax/Abstract/Copatterns.hs b/src/full/Agda/Syntax/Abstract/Copatterns.hs deleted file mode 100644 --- a/src/full/Agda/Syntax/Abstract/Copatterns.hs +++ /dev/null @@ -1,414 +0,0 @@ -{-# LANGUAGE CPP #-} - -module Agda.Syntax.Abstract.Copatterns (translateCopatternClauses) where - -import Prelude hiding (mapM) - -import Control.Monad hiding (mapM) -import Control.Monad.Writer hiding (mapM) - -import Data.Function -import Data.List - -import Data.Traversable as T - -import Agda.Syntax.Abstract -import Agda.Syntax.Common -import qualified Agda.Syntax.Concrete.Name as C -import Agda.Syntax.Concrete (FieldAssignment'(..)) -import Agda.Syntax.Info -import Agda.Syntax.Position -import Agda.Syntax.Scope.Monad - -import Agda.TypeChecking.Monad.Base (TypeError(..), typeError) -import Agda.Utils.Either -import Agda.Utils.Maybe -import Agda.Utils.Tuple - -#include "undefined.h" -import Agda.Utils.Impossible - -{- Andreas 2012-04-07, 2012-05-08 - - Translating copatterns into record expressions - -This is a preliminary solution until we have proper copattern type -checking and evaluation. - -Example 1: - - record Stream (A : Set) : Set where - field - head : A - tail : Stream A - open Stream - - alternate : Stream Nat - ( head alternate ) = zero - (head (tail alternate)) = suc zero - (tail (tail alternate)) = alternate - -with pathes - - Path [head] zero - Path [tail,head] (suc zero) - Path [tail,tail] alternate - -is translated into - - alternate = record - { head = zero - ; tail = record - { head = suc zero - ; tail = alternate - } - } - -Example 2: - - record State (S A : Set) : Set where - constructor state - field - runState : S → A × S - open State - - record Monad (M : Set → Set) : Set1 where - constructor monad - field - return : {A : Set} → A → M A - _>>=_ : {A B : Set} → M A → (A → M B) → M B - open Monad - - stateMonad : {S : Set} → Monad (State S) - runState (return stateMonad a ) s = a , s - runState (_>>=_ stateMonad m k) s₀ = - let as₁ = runState m s₀ - in runState (k (proj₁ as₁)) (proj₂ as₁) - -with pathes - - Path [(return,[a] ), (runstate,[s ])] (a,s) - Path [(_>>=_, [m,k]), (runstate,[s₀])] (let...) - -is translated to - - stateMonad = record - { return = λ a → record { runState = λ s → a , s } - ; _>>=_ = λ m k → record { runState = λ s₀ → - let as₁ = runState m s₀ - in runState (k (proj₁ as₁)) (proj₂ as₁) - } - -Example 3: - - swap3 : {A B C X : Set} → (X → A) × ((X → B) × C) → (X → C) × (X → (B × A)) - fst (swap3 t) x = snd (snd t) - fst (snd (swap3 t) y) = fst (snd t) y - snd (snd (swap3 t) z) = fst t z - -with pathes - - Path [(fst,[x])] (snd (snd t)) - Path [(snd,[y]), (fst,[])] (fst (snd t) y) - Path [(snd,[z]), (snd,[])] (fst t z) - -ist translated to - - swap3 t = record - { fst = λ x → snd (snd t) - ; snd = λ y → record - { fst = fst (snd t) y - ; snd = (fst t z){z := y} - } - } - -How to translate: -- group clauses into those with same LHSCore and same withpatterns - --} - -translateCopatternClauses :: [Clause] -> ScopeM (Delayed, [Clause]) -translateCopatternClauses cs = if all noCopats cs then return (NotDelayed, cs) else (Delayed,) <$> do - pcs :: [ProjPath Clause] <- mapM clauseToPath cs - let cps :: [(Clause, [ProjPath Expr])] - cps = groupClauses pcs - ces <- mapM (mapSndM pathToRecord) $ - map (mapSnd $ sortBy (compare `on` thePath)) cps - return $ map (\ (c, e) -> c { clauseRHS = RHS e Nothing }) ces -- TODO: preserve C.Expr - where - noCopats Clause{ clauseLHS = LHS _ LHSHead{} } = True - noCopats _ = False - --- | A sequence of decisions @b@ leading to a head @a@. -data Path a b = Path - { thePath :: [a] -- ^ the list of choices - , theContent :: b - } deriving (Functor) -- NB: this means @Path a@ is a functor for any @a@ - -mapContent :: (b -> c) -> Path a b -> Path a c -mapContent f (Path p c) = Path p (f c) - -data ProjEntry = ProjEntry - { projPE :: AmbiguousQName - , patsPE :: [NamedArg Name] -- ^ currently we only support variable patterns - } deriving (Eq, Ord) - -type ProjPath = Path ProjEntry - -instance HasRange ProjEntry where - getRange (ProjEntry p ps) = getRange (p,ps) - --- | This is a n^2 grouping algorithm which uses only alpha-equality -groupClauses :: [ProjPath Clause] -> [(Clause, [ProjPath Expr])] -groupClauses [] = [] -groupClauses (pc@(Path p c) : pcs) = (c, Path p (rhs c) : grp) : groupClauses rest - where - (grp, rest) = collect pcs - -- Collect l splits l into pc's group and the remainder - -- If the lhs of the next clause is alpha-equivalent to the current lhs - -- then add the next clause to this group, performing the alpha-conversion - collect (Path p' c' : pcs) | Just rho <- alpha (clauseLHS c') (clauseLHS c) = - mapFst (Path p' (rename' rho (rhs c')) :) $ collect pcs - -- we go through all the clauses, since they could be in random order... - collect (pc : pcs) = mapSnd (pc :) $ collect pcs - collect [] = ([], []) - - rhs = rhsExpr . clauseRHS - rhsExpr (RHS e _ ) = e -- TODO: preserve C.Expr - rhsExpr _ = __IMPOSSIBLE__ - -clauseToPath :: Clause -> ScopeM (ProjPath Clause) -clauseToPath (Clause (LHS i lhs) spats (RHS e c) wh@(WhereDecls _ []) catchall) = - fmap (\ lhs -> Clause (LHS i lhs) spats (RHS e c) wh catchall) <$> lhsToPath [] lhs -clauseToPath (Clause lhs _ (RHS e _) (WhereDecls _ (_:_)) _) = typeError $ NotImplemented $ "copattern clauses with where declarations" -clauseToPath (Clause lhs _ _ wheredecls _) = typeError $ NotImplemented $ "copattern clauses with absurd, with or rewrite right hand side" - -lhsToPath :: [ProjEntry] -> LHSCore -> ScopeM (ProjPath LHSCore) -lhsToPath acc lhs@LHSHead{} = return $ Path acc lhs -lhsToPath acc (LHSWith h wps ps) = __IMPOSSIBLE__ -- TODO! -lhsToPath acc (LHSProj f lhs ps) = do - let xs = fromMaybe __IMPOSSIBLE__ $ mapM (T.mapM (T.mapM fromVarP)) ps - lhsToPath (ProjEntry f xs : acc) $ namedArg lhs - where fromVarP :: Pattern -> Maybe Name - fromVarP (VarP n) = Just $ unBind n - fromVarP _ = Nothing - --- | Expects a sorted list. -pathToRecord :: [ProjPath Expr] -> ScopeM Expr -pathToRecord [] = __IMPOSSIBLE__ -pathToRecord [Path [] e] = return e -pathToRecord pps = - case pathHeads pps of - Nothing -> typeError $ GenericError $ "overlapping copattern clauses" - Just pps -> do - pes <- mapM (mapSndM pathToRecord) $ groupPathes pps - let ei = ExprRange $ getRange $ map fst pes - Rec ei <$> mapM abstractions pes - - where - abstractions :: (ProjEntry, Expr) -> ScopeM RecordAssign - abstractions (ProjEntry p xs, e) = Left . FieldAssignment (C.unqualify $ qnameToConcrete $ headAmbQ p) <$> - foldr abstract (return e) xs - - abstract :: NamedArg Name -> ScopeM Expr -> ScopeM Expr - abstract (Arg info (Named Nothing x)) me = - Lam exprNoRange (DomainFree $ unnamedArg info $ BindName x) <$> me - abstract (Arg _ (Named Just{} _)) me = typeError $ NotImplemented $ - "named arguments in projection patterns" - --- | Similar to 'groupClauses'. -groupPathes :: [(ProjEntry, ProjPath Expr)] -> [(ProjEntry, [ProjPath Expr])] -groupPathes [] = [] -groupPathes ((pe@(ProjEntry p xs), path) : pps) = (pe, path : grp) : groupPathes rest - -- Now group all following pps that have the same projection p - -- We expect that they have alpha-equivalent xs - where - (grp, rest) = collect pps - collect l@((ProjEntry p' xs', path) : pps) | p == p', Just rho <- alpha xs' xs = - -- add the alpha-converted path to the group - -- NOTE: because the path contains only projections and pattern vars - -- we only alpha-convert the content (rhs Expr) - -- When the path will contain dot patterns, we have to rename in them - mapFst (mapContent (rename' rho) path :) $ collect pps - collect l = ([], l) -- null or different projection: close group - -pathHeads :: [Path a b] -> Maybe [(a, Path a b)] -pathHeads = mapM pathSplit - -pathSplit :: Path a b -> Maybe (a, Path a b) -pathSplit (Path [] b) = Nothing -pathSplit (Path (a:as) b) = Just (a, Path as b) - - --- * Alpha conversion - -type NameMap = [(Name,Name)] - -class Rename e where - rename :: (Name -> Maybe Name) -> e -> e - rename' :: NameMap -> e -> e - rename' rho = rename (flip lookup rho) - --- | 'QName's are not renamed. -instance Rename QName where - rename _ q = q - -instance Rename Name where - rename rho x = fromMaybe x (rho x) - -instance Rename BindName where - rename rho (BindName x) = BindName $ rename rho x - -instance Rename Expr where - rename rho e = - case e of - Var x -> Var (rename rho x) - Def f -> e - Proj{} -> e - Con c -> e - Lit l -> e - QuestionMark{} -> e - Underscore i -> e - Dot i e -> Dot i (rename rho e) - App i e es -> App i (rename rho e) (rename rho es) - WithApp i e es -> WithApp i (rename rho e) (rename rho es) - Lam i lb e -> Lam i (rename rho lb) (rename rho e) - AbsurdLam{} -> e - ExtendedLam i i' n cs -> ExtendedLam i i' n (rename rho cs) - Pi i tel e -> Pi i (rename rho tel) (rename rho e) - Generalized s e -> Generalized s (rename rho e) - Fun i a e -> Fun i (rename rho a) (rename rho e) - Set{} -> e - Prop{} -> e - Let i bs e -> Let i (rename rho bs) (rename rho e) - ETel tel -> ETel (rename rho tel) - Rec i fes -> Rec i $ rename rho fes - RecUpdate i e fes -> RecUpdate i (rename rho e) (rename rho fes) - ScopedExpr i e -> ScopedExpr i (rename rho e) - QuoteGoal i n e -> QuoteGoal i n (rename rho e) - QuoteContext i -> e - Quote i -> e - QuoteTerm i -> e - Unquote i -> e - Tactic i e xs ys -> Tactic i (rename rho e) (rename rho xs) (rename rho ys) - DontCare e -> DontCare (rename rho e) - PatternSyn{} -> e - Macro{} -> e - -instance Rename ModuleName where - rename rho x = x - -instance Rename a => Rename (FieldAssignment' a) where - rename rho = fmap (rename rho) - -instance Rename LetBinding where - rename rho e = - case e of - LetBind i r n e e' -> LetBind i r n (rename rho e) (rename rho e') - LetPatBind i p e -> LetPatBind i (rename rho p) (rename rho e) - LetApply{} -> e - LetOpen{} -> e - LetDeclaredVariable x -> LetDeclaredVariable (rename rho x) - -instance Rename LamBinding where - rename rho e = - case e of - DomainFree{} -> e - DomainFull tb -> DomainFull (rename rho tb) - -instance Rename TypedBinding where - rename rho (TBind r ns e) = TBind r ns (rename rho e) - rename rho (TLet r lbs) = TLet r (rename rho lbs) - -instance Rename ProblemEq where - rename rho (ProblemEq p v a) = ProblemEq (rename rho p) v a - -instance Rename Clause where - rename rho (Clause lhs spats rhs wheredecls catchall) = - Clause (rename rho lhs) (rename rho spats) (rename rho rhs) (rename rho wheredecls) catchall - -instance Rename RHS where - rename rho e = case e of - RHS e c -> RHS (rename rho e) c - AbsurdRHS -> e - WithRHS n es cs -> WithRHS n (rename rho es) (rename rho cs) - RewriteRHS nes spats r ds -> RewriteRHS (rename rho nes) (rename rho spats) (rename rho r) (rename rho ds) - -instance Rename WhereDeclarations where - rename rho (WhereDecls m ds) = WhereDecls m (rename rho ds) - -instance Rename LHS where - rename rho (LHS i core) = LHS i (rename rho core) - -instance Rename LHSCore where - rename rho = fmap (rename rho) -- only rename in dot patterns - -instance Rename Pattern where - rename rho = fmap (rename rho) -- only rename in dot patterns - -instance Rename Declaration where - rename rho d = __IMPOSSIBLE__ - -instance Rename a => Rename (Arg a) where - rename rho = fmap (rename rho) - -instance Rename a => Rename (Named n a) where - rename rho = fmap (rename rho) - -instance Rename a => Rename [a] where - rename rho = map (rename rho) - -instance (Rename a, Rename b) => Rename (Either a b) where - rename rho = mapEither (rename rho) (rename rho) - -instance (Rename a, Rename b) => Rename (a, b) where - rename rho (a,b) = (rename rho a, rename rho b) - - --- | Alpha-Equivalence of patterns, ignoring dot patterns -class Alpha t where - alpha :: t -> t -> Maybe NameMap - alpha t t' = fmap snd $ runWriterT $ alpha' t t' - - alpha' :: t -> t -> WriterT NameMap Maybe () - alpha' t t' = WriterT $ fmap ((),) $ alpha t t' - -instance Alpha Name where - alpha' x x' = tell1 (x, x') - -instance Alpha (Pattern' e) where - alpha' p p' = - case (p,p') of - ((VarP x) , (VarP x') ) -> tell1 (unBind x, unBind x') - ((ConP _ x ps) , (ConP _ x' ps') ) -> guard (x == x') >> alpha' ps ps' - ((DefP _ x ps) , (DefP _ x' ps') ) -> guard (x == x') >> alpha' ps ps' - ((WildP _) , (WildP _) ) -> return () - ((AsP _ x p) , (AsP _ x' p') ) -> tell1 (unBind x, unBind x') >> alpha' p p' - ((DotP _ _) , (DotP _ _) ) -> return () - (AbsurdP{} , AbsurdP{} ) -> return () - ((LitP l) , (LitP l') ) -> guard (l == l') - ((PatternSynP _ x ps) , (PatternSynP _ x' ps')) -> guard (x == x') >> alpha' ps ps' - (_ , _ ) -> fail "not alpha equivalent" - -tell1 :: (MonadWriter [a] m) => a -> m () -tell1 a = tell [a] - -instance Alpha (LHSCore' e) where - alpha' (LHSHead f ps) (LHSHead f' ps') = guard (f == f') >> alpha' ps ps' - alpha' (LHSProj d lhs ps) (LHSProj d' lhs' ps') = - guard (d == d') >> alpha' lhs lhs' >> alpha' ps ps' - alpha' (LHSWith h wps ps) (LHSWith h' wps' ps') = - alpha' h h' >> alpha' wps wps' >> alpha' ps ps' - alpha' _ _ = fail "not alpha equivalent" - -instance Alpha LHS where - alpha' (LHS _ core) (LHS _ core') = alpha' core core' - -instance Alpha a => Alpha (Arg a) where - alpha' a a' = alpha' (unArg a) (unArg a') - -instance (Eq n, Alpha a) => Alpha (Named n a) where - alpha' a a' = guard (nameOf a == nameOf a') >> alpha' (namedThing a) (namedThing a') - -instance Alpha a => Alpha [a] where - alpha' l l' = guard (length l == length l') >> zipWithM_ alpha' l l' diff --git a/src/full/Agda/Syntax/Abstract/Name.hs b/src/full/Agda/Syntax/Abstract/Name.hs --- a/src/full/Agda/Syntax/Abstract/Name.hs +++ b/src/full/Agda/Syntax/Abstract/Name.hs @@ -1,6 +1,4 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE DeriveDataTypeable #-} -{-# LANGUAGE GeneralizedNewtypeDeriving #-} {-| Abstract names carry unique identifiers and stuff. -} @@ -9,48 +7,44 @@ , IsNoName(..) ) where -#if MIN_VERSION_base(4,11,0) -import Prelude hiding ((<>)) -#endif - import Control.DeepSeq -import Data.Foldable (Foldable) -import Data.Traversable (Traversable) import Data.Data (Data) -import Data.List +import Data.Foldable (Foldable) import Data.Function import Data.Hashable (Hashable(..)) -import Data.Set (Set) -import qualified Data.Set as Set +import Data.List +import Data.List.NonEmpty (NonEmpty(..)) +import qualified Data.List.NonEmpty as NonEmpty +import Data.Maybe +import Data.Traversable (Traversable) import Data.Void import Agda.Syntax.Position import Agda.Syntax.Common -import {-# SOURCE #-} Agda.Syntax.Fixity import Agda.Syntax.Concrete.Name (IsNoName(..), NumHoles(..), NameInScope(..), LensInScope(..)) import qualified Agda.Syntax.Concrete.Name as C +import Agda.Utils.Functor +import Agda.Utils.Lens import Agda.Utils.List -import Agda.Utils.Maybe -import Agda.Utils.Monad -import Agda.Utils.NonemptyList import Agda.Utils.Pretty import Agda.Utils.Size -#include "undefined.h" import Agda.Utils.Impossible -- | A name is a unique identifier and a suggestion for a concrete name. The -- concrete name contains the source location (if any) of the name. The -- source location of the binding site is also recorded. -data Name = Name { nameId :: !NameId - , nameConcrete :: C.Name - , nameBindingSite :: Range - , nameFixity :: Fixity' - , nameIsRecordName :: Bool - } - deriving Data +data Name = Name + { nameId :: !NameId + , nameConcrete :: C.Name + , nameBindingSite :: Range + , nameFixity :: Fixity' + , nameIsRecordName :: Bool + -- ^ Is this the name of the invisible record variable `self`? + -- Should not be printed or displayed in the context, see issue #3584. + } deriving Data -- | Useful for debugging scoping problems uglyShowName :: Name -> String @@ -85,24 +79,24 @@ -- -- Invariant: All the names in the list must have the same concrete, -- unqualified name. (This implies that they all have the same 'Range'). -newtype AmbiguousQName = AmbQ { unAmbQ :: NonemptyList QName } +newtype AmbiguousQName = AmbQ { unAmbQ :: NonEmpty QName } deriving (Eq, Ord, Data) -- | A singleton "ambiguous" name. unambiguous :: QName -> AmbiguousQName -unambiguous x = AmbQ (x :! []) +unambiguous x = AmbQ (x :| []) -- | Get the first of the ambiguous names. headAmbQ :: AmbiguousQName -> QName -headAmbQ (AmbQ xs) = headNe xs +headAmbQ (AmbQ xs) = NonEmpty.head xs -- | Is a name ambiguous. isAmbiguous :: AmbiguousQName -> Bool -isAmbiguous (AmbQ (_ :! xs)) = not (null xs) +isAmbiguous (AmbQ (_ :| xs)) = not (null xs) -- | Get the name if unambiguous. getUnambiguous :: AmbiguousQName -> Maybe QName -getUnambiguous (AmbQ (x :! [])) = Just x +getUnambiguous (AmbQ (x :| [])) = Just x getUnambiguous _ = Nothing -- | Check whether we are a projection pattern. @@ -235,14 +229,24 @@ -- | Is the name an operator? isOperator :: QName -> Bool -isOperator q = C.isOperator (nameConcrete (qnameName q)) +isOperator = C.isOperator . nameConcrete . qnameName -isSubModuleOf :: ModuleName -> ModuleName -> Bool -isSubModuleOf x y = xs /= ys && isPrefixOf ys xs - where - xs = mnameToList x - ys = mnameToList y +-- | Is the first module a weak parent of the second? +isLeParentModuleOf :: ModuleName -> ModuleName -> Bool +isLeParentModuleOf = isPrefixOf `on` mnameToList +-- | Is the first module a proper parent of the second? +isLtParentModuleOf :: ModuleName -> ModuleName -> Bool +isLtParentModuleOf x y = isJust $ (stripPrefixBy (==) `on` mnameToList) x y + +-- | Is the first module a weak child of the second? +isLeChildModuleOf :: ModuleName -> ModuleName -> Bool +isLeChildModuleOf = flip isLeParentModuleOf + +-- | Is the first module a proper child of the second? +isLtChildModuleOf :: ModuleName -> ModuleName -> Bool +isLtChildModuleOf = flip isLtParentModuleOf + isInModule :: QName -> ModuleName -> Bool isInModule q m = mnameToList m `isPrefixOf` qnameToList q @@ -299,6 +303,33 @@ numHoles = numHoles . headAmbQ ------------------------------------------------------------------------ +-- * name lenses +------------------------------------------------------------------------ + +lensQNameName :: Lens' Name QName +lensQNameName f (QName m n) = QName m <$> f n + +------------------------------------------------------------------------ +-- * LensFixity' instances +------------------------------------------------------------------------ + +instance LensFixity' Name where + lensFixity' f n = f (nameFixity n) <&> \ fix' -> n { nameFixity = fix' } + +instance LensFixity' QName where + lensFixity' = lensQNameName . lensFixity' + +------------------------------------------------------------------------ +-- * LensFixity instances +------------------------------------------------------------------------ + +instance LensFixity Name where + lensFixity = lensFixity' . lensFixity + +instance LensFixity QName where + lensFixity = lensFixity' . lensFixity + +------------------------------------------------------------------------ -- * LensInScope instances ------------------------------------------------------------------------ @@ -341,6 +372,12 @@ instance Show QName where show = prettyShow +nameToArgName :: Name -> ArgName +nameToArgName = stringToArgName . prettyShow + +namedArgName :: NamedArg Name -> ArgName +namedArgName x = fromMaybe (nameToArgName $ namedArg x) $ bareNameOf x + ------------------------------------------------------------------------ -- * Pretty instances ------------------------------------------------------------------------ @@ -355,7 +392,7 @@ pretty = hcat . punctuate "." . map pretty . qnameToList instance Pretty AmbiguousQName where - pretty (AmbQ qs) = hcat $ punctuate " | " $ map pretty (toList qs) + pretty (AmbQ qs) = hcat $ punctuate " | " $ map pretty (NonEmpty.toList qs) instance Pretty a => Pretty (QNamed a) where pretty (QNamed a b) = pretty a <> "." <> pretty b @@ -379,7 +416,7 @@ -- | The range of an @AmbiguousQName@ is the range of any of its -- disambiguations (they are the same concrete name). instance HasRange AmbiguousQName where - getRange (AmbQ (c :! _)) = getRange c + getRange (AmbQ (c :| _)) = getRange c -- ** SetRange diff --git a/src/full/Agda/Syntax/Abstract/Pattern.hs b/src/full/Agda/Syntax/Abstract/Pattern.hs --- a/src/full/Agda/Syntax/Abstract/Pattern.hs +++ b/src/full/Agda/Syntax/Abstract/Pattern.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE UndecidableInstances #-} @@ -13,11 +12,9 @@ import Control.Arrow ((***), second) import Control.Monad ((>=>)) import Control.Monad.Identity -import Control.Applicative (Applicative, liftA2) +import Control.Applicative (liftA2) import Data.Foldable (Foldable, foldMap) -import Data.Functor - import Data.Traversable (Traversable, traverse) import Data.Maybe @@ -25,7 +22,7 @@ import Agda.Syntax.Abstract as A import Agda.Syntax.Common -import Agda.Syntax.Concrete (FieldAssignment', exprFieldA) +import Agda.Syntax.Concrete (FieldAssignment') import qualified Agda.Syntax.Concrete as C import Agda.Syntax.Concrete.Pattern (IsWithP(..)) import Agda.Syntax.Info @@ -35,7 +32,6 @@ import Agda.Utils.List import Agda.Utils.Null -#include "undefined.h" import Agda.Utils.Impossible -- * Generic traversals diff --git a/src/full/Agda/Syntax/Abstract/PatternSynonyms.hs b/src/full/Agda/Syntax/Abstract/PatternSynonyms.hs --- a/src/full/Agda/Syntax/Abstract/PatternSynonyms.hs +++ b/src/full/Agda/Syntax/Abstract/PatternSynonyms.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} -- | Pattern synonym utilities: folding pattern synonym definitions for -- printing and merging pattern synonym definitions to handle overloaded @@ -11,28 +10,25 @@ import Control.Applicative ( Alternative(empty) ) import Control.Monad.Writer hiding (forM) + import Data.Map (Map) import qualified Data.Map as Map import Data.Traversable (forM) import Data.List +import Data.List.NonEmpty (NonEmpty(..)) +import qualified Data.List.NonEmpty as NonEmpty import Data.Void import Agda.Syntax.Common -import Agda.Syntax.Position -import Agda.Syntax.Literal import Agda.Syntax.Abstract import Agda.Syntax.Abstract.Views -import Agda.Utils.Monad -import Agda.Utils.NonemptyList -import Agda.Utils.Impossible -#include "undefined.h" -- | Merge a list of pattern synonym definitions. Fails unless all definitions -- have the same shape (i.e. equal up to renaming of variables and constructor -- names). -mergePatternSynDefs :: NonemptyList PatternSynDefn -> Maybe PatternSynDefn -mergePatternSynDefs (def :! defs) = foldM mergeDef def defs +mergePatternSynDefs :: NonEmpty PatternSynDefn -> Maybe PatternSynDefn +mergePatternSynDefs (def :| defs) = foldM mergeDef def defs mergeDef :: PatternSynDefn -> PatternSynDefn -> Maybe PatternSynDefn mergeDef (xs, p) (ys, q) = do @@ -50,6 +46,8 @@ mergeArg ren p q = setNamedArg p <$> merge ren (namedArg p) (namedArg q) + unionNe xs ys = NonEmpty.fromList $ NonEmpty.toList xs `union` NonEmpty.toList ys + -- | Match an expression against a pattern synonym. matchPatternSyn :: PatternSynDefn -> Expr -> Maybe [Arg Expr] matchPatternSyn = runMatch match @@ -58,7 +56,7 @@ match (LitP l) (Lit l') = guard (l == l') match (ConP _ (AmbQ cs) ps) e = do Application (Con (AmbQ cs')) args <- return (appView e) - guard $ null (toList cs' \\ toList cs) -- check all possible constructors appear in the synonym + guard $ null (NonEmpty.toList cs' \\ NonEmpty.toList cs) -- check all possible constructors appear in the synonym guard $ map getArgInfo ps == map getArgInfo args -- check that we agree on the hiding (TODO: too strict?) zipWithM_ match (map namedArg ps) (map namedArg args) match _ _ = empty @@ -71,7 +69,7 @@ match (LitP l) (LitP l') = guard (l == l') match (WildP _) (WildP _) = return () match (ConP _ (AmbQ cs) ps) (ConP _ (AmbQ cs') qs) = do - guard $ null (toList cs' \\ toList cs) + guard $ null (NonEmpty.toList cs' \\ NonEmpty.toList cs) guard $ map getArgInfo ps == map getArgInfo qs zipWithM_ match (map namedArg ps) (map namedArg qs) match _ _ = empty diff --git a/src/full/Agda/Syntax/Abstract/Pretty.hs b/src/full/Agda/Syntax/Abstract/Pretty.hs --- a/src/full/Agda/Syntax/Abstract/Pretty.hs +++ b/src/full/Agda/Syntax/Abstract/Pretty.hs @@ -1,27 +1,25 @@ module Agda.Syntax.Abstract.Pretty where -import Agda.Syntax.Concrete.Pretty () import Agda.Syntax.Fixity import Agda.Syntax.Translation.AbstractToConcrete -import Agda.TypeChecking.Monad import Agda.Utils.Pretty -showA :: (Show c, ToConcrete a c) => a -> TCM String +showA :: (Show c, ToConcrete a c, MonadAbsToCon m) => a -> m String showA x = show <$> abstractToConcrete_ x -prettyA :: (Pretty c, ToConcrete a c) => a -> TCM Doc +prettyA :: (Pretty c, ToConcrete a c, MonadAbsToCon m) => a -> m Doc prettyA x = pretty <$> abstractToConcrete_ x -prettyAs :: (Pretty c, ToConcrete a [c]) => a -> TCM Doc +prettyAs :: (Pretty c, ToConcrete a [c], MonadAbsToCon m) => a -> m Doc prettyAs x = fsep . map pretty <$> abstractToConcrete_ x -- | Variant of 'showA' which does not insert outermost parentheses. -showATop :: (Show c, ToConcrete a c) => a -> TCM String +showATop :: (Show c, ToConcrete a c, MonadAbsToCon m) => a -> m String showATop x = show <$> abstractToConcreteCtx TopCtx x -- | Variant of 'prettyA' which does not insert outermost parentheses. -prettyATop :: (Pretty c, ToConcrete a c) => a -> TCM Doc +prettyATop :: (Pretty c, ToConcrete a c, MonadAbsToCon m) => a -> m Doc prettyATop x = pretty <$> abstractToConcreteCtx TopCtx x diff --git a/src/full/Agda/Syntax/Abstract/Views.hs b/src/full/Agda/Syntax/Abstract/Views.hs --- a/src/full/Agda/Syntax/Abstract/Views.hs +++ b/src/full/Agda/Syntax/Abstract/Views.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE NoMonoLocalBinds #-} {-# LANGUAGE NoMonomorphismRestriction #-} @@ -9,12 +8,8 @@ import Control.Arrow (first) import Control.Monad.Identity -import Data.Foldable (foldMap) -import Data.Monoid -import Data.Traversable import Data.Void -import Agda.Syntax.Position import Agda.Syntax.Common import Agda.Syntax.Abstract as A import Agda.Syntax.Concrete (FieldAssignment', exprFieldA) @@ -22,7 +17,6 @@ import Agda.Syntax.Scope.Base (emptyScopeInfo) import Agda.Utils.Either -import Agda.Utils.Lens data AppView' arg = Application Expr [NamedArg arg] deriving (Functor) @@ -153,14 +147,12 @@ Rec ei bs -> Rec ei <$> recurse bs RecUpdate ei e bs -> RecUpdate ei <$> recurse e <*> recurse bs ScopedExpr sc e -> ScopedExpr sc <$> recurse e - QuoteGoal ei n e -> QuoteGoal ei n <$> recurse e - QuoteContext ei -> pure e0 Quote{} -> pure e0 QuoteTerm{} -> pure e0 Unquote{} -> pure e0 DontCare e -> DontCare <$> recurse e PatternSyn{} -> pure e0 - Tactic ei e xs ys -> Tactic ei <$> recurse e <*> recurse xs <*> recurse ys + Tactic ei e xs -> Tactic ei <$> recurse e <*> recurse xs Macro{} -> pure e0 foldExpr f e = @@ -190,12 +182,10 @@ Rec _ as -> m `mappend` fold as RecUpdate _ e as -> m `mappend` fold e `mappend` fold as ScopedExpr _ e -> m `mappend` fold e - QuoteGoal _ _ e -> m `mappend` fold e - QuoteContext _ -> m Quote{} -> m QuoteTerm{} -> m Unquote{} -> m - Tactic _ e xs ys -> m `mappend` fold e `mappend` fold xs `mappend` fold ys + Tactic _ e xs -> m `mappend` fold e `mappend` fold xs DontCare e -> m `mappend` fold e where m = f e @@ -227,17 +217,16 @@ Rec ei bs -> f =<< Rec ei <$> trav bs RecUpdate ei e bs -> f =<< RecUpdate ei <$> trav e <*> trav bs ScopedExpr sc e -> f =<< ScopedExpr sc <$> trav e - QuoteGoal ei n e -> f =<< QuoteGoal ei n <$> trav e - QuoteContext{} -> f e Quote{} -> f e QuoteTerm{} -> f e Unquote{} -> f e - Tactic ei e xs ys -> f =<< Tactic ei <$> trav e <*> trav xs <*> trav ys + Tactic ei e xs -> f =<< Tactic ei <$> trav e <*> trav xs DontCare e -> f =<< DontCare <$> trav e PatternSyn{} -> f e Macro{} -> f e instance ExprLike a => ExprLike (Arg a) where +instance ExprLike a => ExprLike (Maybe a) where instance ExprLike a => ExprLike (Named x a) where instance ExprLike a => ExprLike [a] where @@ -263,16 +252,16 @@ instance ExprLike LamBinding where recurseExpr f e = case e of - DomainFree{} -> pure e - DomainFull bs -> DomainFull <$> recurseExpr f bs + DomainFree t x -> DomainFree <$> recurseExpr f t <*> pure x + DomainFull bs -> DomainFull <$> recurseExpr f bs foldExpr f e = case e of - DomainFree{} -> mempty + DomainFree t _ -> foldExpr f t DomainFull bs -> foldExpr f bs traverseExpr f e = case e of - DomainFree{} -> pure e - DomainFull bs -> DomainFull <$> traverseExpr f bs + DomainFree t x -> DomainFree <$> traverseExpr f t <*> pure x + DomainFull bs -> DomainFull <$> traverseExpr f bs instance ExprLike GeneralizeTelescope where recurseExpr f (GeneralizeTel s tel) = GeneralizeTel s <$> recurseExpr f tel @@ -287,16 +276,16 @@ instance ExprLike TypedBinding where recurseExpr f e = case e of - TBind r xs e -> TBind r xs <$> recurseExpr f e - TLet r ds -> TLet r <$> recurseExpr f ds + TBind r t xs e -> TBind r <$> recurseExpr f t <*> pure xs <*> recurseExpr f e + TLet r ds -> TLet r <$> recurseExpr f ds foldExpr f e = case e of - TBind _ _ e -> foldExpr f e - TLet _ ds -> foldExpr f ds + TBind _ t _ e -> foldExpr f t `mappend` foldExpr f e + TLet _ ds -> foldExpr f ds traverseExpr f e = case e of - TBind r xs e -> TBind r xs <$> traverseExpr f e - TLet r ds -> TLet r <$> traverseExpr f ds + TBind r t xs e -> TBind r <$> traverseExpr f t <*> pure xs <*> traverseExpr f e + TLet r ds -> TLet r <$> traverseExpr f ds instance ExprLike LetBinding where recurseExpr f e = do @@ -341,6 +330,11 @@ RewriteRHS xes spats rhs ds -> RewriteRHS <$> rec xes <*> pure spats <*> rec rhs <*> rec ds where rec e = recurseExpr f e +instance (ExprLike qn, ExprLike p, ExprLike e) => ExprLike (RewriteEqn' qn p e) where + recurseExpr f = \case + Rewrite es -> Rewrite <$> recurseExpr f es + Invert qn pes -> Invert <$> recurseExpr f qn <*> recurseExpr f pes + instance ExprLike WhereDeclarations where recurseExpr f (WhereDecls a b) = WhereDecls a <$> recurseExpr f b @@ -369,7 +363,8 @@ instance ExprLike LHS where recurseExpr f (LHS i p) = LHS i <$> recurseExpr f p -instance ExprLike a => ExprLike (LHSCore' a) where +instance ExprLike a => ExprLike (LHSCore' a) where +instance ExprLike a => ExprLike (WithHiding a) where instance ExprLike SpineLHS where recurseExpr f (SpineLHS i x ps) = SpineLHS i x <$> recurseExpr f ps diff --git a/src/full/Agda/Syntax/Builtin.hs b/src/full/Agda/Syntax/Builtin.hs --- a/src/full/Agda/Syntax/Builtin.hs +++ b/src/full/Agda/Syntax/Builtin.hs @@ -15,8 +15,10 @@ builtinComp, builtinPOr, builtinTrans, builtinHComp, builtinSub, builtinSubIn, builtinSubOut, - builtinEquiv, builtinEquivFun, builtinEquivProof, builtinPathToEquiv, + builtinEquiv, builtinEquivFun, builtinEquivProof, + builtinTranspProof, builtinGlue, builtin_glue, builtin_unglue, + builtin_glueU, builtin_unglueU, builtinFaceForall, builtinId, builtinConId, builtinIdElim, builtinSizeUniv, builtinSize, builtinSizeLt, @@ -63,182 +65,184 @@ builtinAgdaTCMRunSpeculative :: String -builtinNat = "NATURAL" -builtinSuc = "SUC" -builtinZero = "ZERO" -builtinNatPlus = "NATPLUS" -builtinNatMinus = "NATMINUS" -builtinNatTimes = "NATTIMES" -builtinNatDivSucAux = "NATDIVSUCAUX" -builtinNatModSucAux = "NATMODSUCAUX" -builtinNatEquals = "NATEQUALS" -builtinNatLess = "NATLESS" -builtinWord64 = "WORD64" -builtinInteger = "INTEGER" -builtinIntegerPos = "INTEGERPOS" -builtinIntegerNegSuc = "INTEGERNEGSUC" -builtinFloat = "FLOAT" -builtinChar = "CHAR" -builtinString = "STRING" -builtinUnit = "UNIT" -builtinUnitUnit = "UNITUNIT" -builtinSigma = "SIGMA" -builtinBool = "BOOL" -builtinTrue = "TRUE" -builtinFalse = "FALSE" -builtinList = "LIST" -builtinNil = "NIL" -builtinCons = "CONS" -builtinIO = "IO" -builtinId = "ID" -builtinConId = "CONID" -builtinIdElim = "primIdElim" -builtinPath = "PATH" -builtinPathP = "PATHP" -builtinInterval = "INTERVAL" -builtinIMin = "primIMin" -builtinIMax = "primIMax" -builtinINeg = "primINeg" -builtinIZero = "IZERO" -builtinIOne = "IONE" -builtinPartial = "PARTIAL" -builtinPartialP = "PARTIALP" -builtinIsOne = "ISONE" -builtinItIsOne = "ITISONE" -builtinEquiv = "EQUIV" -builtinEquivFun = "EQUIVFUN" -builtinEquivProof = "EQUIVPROOF" -builtinPathToEquiv = "PATHTOEQUIV" -builtinGlue = "primGlue" -builtin_glue = "prim^glue" -builtin_unglue = "prim^unglue" -builtinFaceForall = "primFaceForall" -builtinIsOne1 = "ISONE1" -builtinIsOne2 = "ISONE2" -builtinIsOneEmpty = "ISONEEMPTY" -builtinComp = "primComp" -builtinPOr = "primPOr" -builtinTrans = "primTransp" -builtinHComp = "primHComp" -builtinSub = "SUB" -builtinSubIn = "SUBIN" -builtinSubOut = "primSubOut" -builtinSizeUniv = "SIZEUNIV" -builtinSize = "SIZE" -builtinSizeLt = "SIZELT" -builtinSizeSuc = "SIZESUC" -builtinSizeInf = "SIZEINF" -builtinSizeMax = "SIZEMAX" -builtinInf = "INFINITY" -builtinSharp = "SHARP" -builtinFlat = "FLAT" -builtinEquality = "EQUALITY" -builtinRefl = "REFL" -builtinRewrite = "REWRITE" -builtinLevelMax = "LEVELMAX" -builtinLevel = "LEVEL" -builtinLevelZero = "LEVELZERO" -builtinLevelSuc = "LEVELSUC" -builtinSetOmega = "SETOMEGA" -builtinFromNat = "FROMNAT" -builtinFromNeg = "FROMNEG" -builtinFromString = "FROMSTRING" -builtinQName = "QNAME" -builtinAgdaSort = "AGDASORT" -builtinAgdaSortSet = "AGDASORTSET" -builtinAgdaSortLit = "AGDASORTLIT" -builtinAgdaSortUnsupported = "AGDASORTUNSUPPORTED" -builtinHiding = "HIDING" -builtinHidden = "HIDDEN" -builtinInstance = "INSTANCE" -builtinVisible = "VISIBLE" -builtinRelevance = "RELEVANCE" -builtinRelevant = "RELEVANT" -builtinIrrelevant = "IRRELEVANT" -builtinAssoc = "ASSOC" -builtinAssocLeft = "ASSOCLEFT" -builtinAssocRight = "ASSOCRIGHT" -builtinAssocNon = "ASSOCNON" -builtinPrecedence = "PRECEDENCE" -builtinPrecRelated = "PRECRELATED" -builtinPrecUnrelated = "PRECUNRELATED" -builtinFixity = "FIXITY" -builtinFixityFixity = "FIXITYFIXITY" -builtinArg = "ARG" -builtinArgInfo = "ARGINFO" -builtinArgArgInfo = "ARGARGINFO" -builtinArgArg = "ARGARG" -builtinAbs = "ABS" -builtinAbsAbs = "ABSABS" -builtinAgdaTerm = "AGDATERM" -builtinAgdaTermVar = "AGDATERMVAR" -builtinAgdaTermLam = "AGDATERMLAM" -builtinAgdaTermExtLam = "AGDATERMEXTLAM" -builtinAgdaTermDef = "AGDATERMDEF" -builtinAgdaTermCon = "AGDATERMCON" -builtinAgdaTermPi = "AGDATERMPI" -builtinAgdaTermSort = "AGDATERMSORT" -builtinAgdaTermLit = "AGDATERMLIT" -builtinAgdaTermUnsupported = "AGDATERMUNSUPPORTED" -builtinAgdaTermMeta = "AGDATERMMETA" -builtinAgdaErrorPart = "AGDAERRORPART" -builtinAgdaErrorPartString = "AGDAERRORPARTSTRING" -builtinAgdaErrorPartTerm = "AGDAERRORPARTTERM" -builtinAgdaErrorPartName = "AGDAERRORPARTNAME" -builtinAgdaLiteral = "AGDALITERAL" -builtinAgdaLitNat = "AGDALITNAT" -builtinAgdaLitWord64 = "AGDALITWORD64" -builtinAgdaLitFloat = "AGDALITFLOAT" -builtinAgdaLitChar = "AGDALITCHAR" -builtinAgdaLitString = "AGDALITSTRING" -builtinAgdaLitQName = "AGDALITQNAME" -builtinAgdaLitMeta = "AGDALITMETA" -builtinAgdaClause = "AGDACLAUSE" -builtinAgdaClauseClause = "AGDACLAUSECLAUSE" -builtinAgdaClauseAbsurd = "AGDACLAUSEABSURD" -builtinAgdaPattern = "AGDAPATTERN" -builtinAgdaPatVar = "AGDAPATVAR" -builtinAgdaPatCon = "AGDAPATCON" -builtinAgdaPatDot = "AGDAPATDOT" -builtinAgdaPatLit = "AGDAPATLIT" -builtinAgdaPatProj = "AGDAPATPROJ" -builtinAgdaPatAbsurd = "AGDAPATABSURD" -builtinAgdaDefinitionFunDef = "AGDADEFINITIONFUNDEF" -builtinAgdaDefinitionDataDef = "AGDADEFINITIONDATADEF" -builtinAgdaDefinitionRecordDef = "AGDADEFINITIONRECORDDEF" -builtinAgdaDefinitionDataConstructor = "AGDADEFINITIONDATACONSTRUCTOR" -builtinAgdaDefinitionPostulate = "AGDADEFINITIONPOSTULATE" -builtinAgdaDefinitionPrimitive = "AGDADEFINITIONPRIMITIVE" -builtinAgdaDefinition = "AGDADEFINITION" -builtinAgdaMeta = "AGDAMETA" -builtinAgdaTCM = "AGDATCM" -builtinAgdaTCMReturn = "AGDATCMRETURN" -builtinAgdaTCMBind = "AGDATCMBIND" -builtinAgdaTCMUnify = "AGDATCMUNIFY" -builtinAgdaTCMTypeError = "AGDATCMTYPEERROR" -builtinAgdaTCMInferType = "AGDATCMINFERTYPE" -builtinAgdaTCMCheckType = "AGDATCMCHECKTYPE" -builtinAgdaTCMNormalise = "AGDATCMNORMALISE" -builtinAgdaTCMReduce = "AGDATCMREDUCE" -builtinAgdaTCMCatchError = "AGDATCMCATCHERROR" -builtinAgdaTCMGetContext = "AGDATCMGETCONTEXT" -builtinAgdaTCMExtendContext = "AGDATCMEXTENDCONTEXT" -builtinAgdaTCMInContext = "AGDATCMINCONTEXT" -builtinAgdaTCMFreshName = "AGDATCMFRESHNAME" -builtinAgdaTCMDeclareDef = "AGDATCMDECLAREDEF" -builtinAgdaTCMDeclarePostulate = "AGDATCMDECLAREPOSTULATE" -builtinAgdaTCMDefineFun = "AGDATCMDEFINEFUN" -builtinAgdaTCMGetType = "AGDATCMGETTYPE" -builtinAgdaTCMGetDefinition = "AGDATCMGETDEFINITION" -builtinAgdaTCMBlockOnMeta = "AGDATCMBLOCKONMETA" -builtinAgdaTCMCommit = "AGDATCMCOMMIT" -builtinAgdaTCMQuoteTerm = "AGDATCMQUOTETERM" -builtinAgdaTCMUnquoteTerm = "AGDATCMUNQUOTETERM" -builtinAgdaTCMIsMacro = "AGDATCMISMACRO" -builtinAgdaTCMWithNormalisation = "AGDATCMWITHNORMALISATION" -builtinAgdaTCMDebugPrint = "AGDATCMDEBUGPRINT" -builtinAgdaTCMNoConstraints = "AGDATCMNOCONSTRAINTS" -builtinAgdaTCMRunSpeculative = "AGDATCMRUNSPECULATIVE" +builtinNat = "NATURAL" +builtinSuc = "SUC" +builtinZero = "ZERO" +builtinNatPlus = "NATPLUS" +builtinNatMinus = "NATMINUS" +builtinNatTimes = "NATTIMES" +builtinNatDivSucAux = "NATDIVSUCAUX" +builtinNatModSucAux = "NATMODSUCAUX" +builtinNatEquals = "NATEQUALS" +builtinNatLess = "NATLESS" +builtinWord64 = "WORD64" +builtinInteger = "INTEGER" +builtinIntegerPos = "INTEGERPOS" +builtinIntegerNegSuc = "INTEGERNEGSUC" +builtinFloat = "FLOAT" +builtinChar = "CHAR" +builtinString = "STRING" +builtinUnit = "UNIT" +builtinUnitUnit = "UNITUNIT" +builtinSigma = "SIGMA" +builtinBool = "BOOL" +builtinTrue = "TRUE" +builtinFalse = "FALSE" +builtinList = "LIST" +builtinNil = "NIL" +builtinCons = "CONS" +builtinIO = "IO" +builtinId = "ID" +builtinConId = "CONID" +builtinIdElim = "primIdElim" +builtinPath = "PATH" +builtinPathP = "PATHP" +builtinInterval = "INTERVAL" +builtinIMin = "primIMin" +builtinIMax = "primIMax" +builtinINeg = "primINeg" +builtinIZero = "IZERO" +builtinIOne = "IONE" +builtinPartial = "PARTIAL" +builtinPartialP = "PARTIALP" +builtinIsOne = "ISONE" +builtinItIsOne = "ITISONE" +builtinEquiv = "EQUIV" +builtinEquivFun = "EQUIVFUN" +builtinEquivProof = "EQUIVPROOF" +builtinTranspProof = "TRANSPPROOF" +builtinGlue = "primGlue" +builtin_glue = "prim^glue" +builtin_unglue = "prim^unglue" +builtin_glueU = "prim^glueU" +builtin_unglueU = "prim^unglueU" +builtinFaceForall = "primFaceForall" +builtinIsOne1 = "ISONE1" +builtinIsOne2 = "ISONE2" +builtinIsOneEmpty = "ISONEEMPTY" +builtinComp = "primComp" +builtinPOr = "primPOr" +builtinTrans = "primTransp" +builtinHComp = "primHComp" +builtinSub = "SUB" +builtinSubIn = "SUBIN" +builtinSubOut = "primSubOut" +builtinSizeUniv = "SIZEUNIV" +builtinSize = "SIZE" +builtinSizeLt = "SIZELT" +builtinSizeSuc = "SIZESUC" +builtinSizeInf = "SIZEINF" +builtinSizeMax = "SIZEMAX" +builtinInf = "INFINITY" +builtinSharp = "SHARP" +builtinFlat = "FLAT" +builtinEquality = "EQUALITY" +builtinRefl = "REFL" +builtinRewrite = "REWRITE" +builtinLevelMax = "LEVELMAX" +builtinLevel = "LEVEL" +builtinLevelZero = "LEVELZERO" +builtinLevelSuc = "LEVELSUC" +builtinSetOmega = "SETOMEGA" +builtinFromNat = "FROMNAT" +builtinFromNeg = "FROMNEG" +builtinFromString = "FROMSTRING" +builtinQName = "QNAME" +builtinAgdaSort = "AGDASORT" +builtinAgdaSortSet = "AGDASORTSET" +builtinAgdaSortLit = "AGDASORTLIT" +builtinAgdaSortUnsupported = "AGDASORTUNSUPPORTED" +builtinHiding = "HIDING" +builtinHidden = "HIDDEN" +builtinInstance = "INSTANCE" +builtinVisible = "VISIBLE" +builtinRelevance = "RELEVANCE" +builtinRelevant = "RELEVANT" +builtinIrrelevant = "IRRELEVANT" +builtinAssoc = "ASSOC" +builtinAssocLeft = "ASSOCLEFT" +builtinAssocRight = "ASSOCRIGHT" +builtinAssocNon = "ASSOCNON" +builtinPrecedence = "PRECEDENCE" +builtinPrecRelated = "PRECRELATED" +builtinPrecUnrelated = "PRECUNRELATED" +builtinFixity = "FIXITY" +builtinFixityFixity = "FIXITYFIXITY" +builtinArg = "ARG" +builtinArgInfo = "ARGINFO" +builtinArgArgInfo = "ARGARGINFO" +builtinArgArg = "ARGARG" +builtinAbs = "ABS" +builtinAbsAbs = "ABSABS" +builtinAgdaTerm = "AGDATERM" +builtinAgdaTermVar = "AGDATERMVAR" +builtinAgdaTermLam = "AGDATERMLAM" +builtinAgdaTermExtLam = "AGDATERMEXTLAM" +builtinAgdaTermDef = "AGDATERMDEF" +builtinAgdaTermCon = "AGDATERMCON" +builtinAgdaTermPi = "AGDATERMPI" +builtinAgdaTermSort = "AGDATERMSORT" +builtinAgdaTermLit = "AGDATERMLIT" +builtinAgdaTermUnsupported = "AGDATERMUNSUPPORTED" +builtinAgdaTermMeta = "AGDATERMMETA" +builtinAgdaErrorPart = "AGDAERRORPART" +builtinAgdaErrorPartString = "AGDAERRORPARTSTRING" +builtinAgdaErrorPartTerm = "AGDAERRORPARTTERM" +builtinAgdaErrorPartName = "AGDAERRORPARTNAME" +builtinAgdaLiteral = "AGDALITERAL" +builtinAgdaLitNat = "AGDALITNAT" +builtinAgdaLitWord64 = "AGDALITWORD64" +builtinAgdaLitFloat = "AGDALITFLOAT" +builtinAgdaLitChar = "AGDALITCHAR" +builtinAgdaLitString = "AGDALITSTRING" +builtinAgdaLitQName = "AGDALITQNAME" +builtinAgdaLitMeta = "AGDALITMETA" +builtinAgdaClause = "AGDACLAUSE" +builtinAgdaClauseClause = "AGDACLAUSECLAUSE" +builtinAgdaClauseAbsurd = "AGDACLAUSEABSURD" +builtinAgdaPattern = "AGDAPATTERN" +builtinAgdaPatVar = "AGDAPATVAR" +builtinAgdaPatCon = "AGDAPATCON" +builtinAgdaPatDot = "AGDAPATDOT" +builtinAgdaPatLit = "AGDAPATLIT" +builtinAgdaPatProj = "AGDAPATPROJ" +builtinAgdaPatAbsurd = "AGDAPATABSURD" +builtinAgdaDefinitionFunDef = "AGDADEFINITIONFUNDEF" +builtinAgdaDefinitionDataDef = "AGDADEFINITIONDATADEF" +builtinAgdaDefinitionRecordDef = "AGDADEFINITIONRECORDDEF" +builtinAgdaDefinitionDataConstructor = "AGDADEFINITIONDATACONSTRUCTOR" +builtinAgdaDefinitionPostulate = "AGDADEFINITIONPOSTULATE" +builtinAgdaDefinitionPrimitive = "AGDADEFINITIONPRIMITIVE" +builtinAgdaDefinition = "AGDADEFINITION" +builtinAgdaMeta = "AGDAMETA" +builtinAgdaTCM = "AGDATCM" +builtinAgdaTCMReturn = "AGDATCMRETURN" +builtinAgdaTCMBind = "AGDATCMBIND" +builtinAgdaTCMUnify = "AGDATCMUNIFY" +builtinAgdaTCMTypeError = "AGDATCMTYPEERROR" +builtinAgdaTCMInferType = "AGDATCMINFERTYPE" +builtinAgdaTCMCheckType = "AGDATCMCHECKTYPE" +builtinAgdaTCMNormalise = "AGDATCMNORMALISE" +builtinAgdaTCMReduce = "AGDATCMREDUCE" +builtinAgdaTCMCatchError = "AGDATCMCATCHERROR" +builtinAgdaTCMGetContext = "AGDATCMGETCONTEXT" +builtinAgdaTCMExtendContext = "AGDATCMEXTENDCONTEXT" +builtinAgdaTCMInContext = "AGDATCMINCONTEXT" +builtinAgdaTCMFreshName = "AGDATCMFRESHNAME" +builtinAgdaTCMDeclareDef = "AGDATCMDECLAREDEF" +builtinAgdaTCMDeclarePostulate = "AGDATCMDECLAREPOSTULATE" +builtinAgdaTCMDefineFun = "AGDATCMDEFINEFUN" +builtinAgdaTCMGetType = "AGDATCMGETTYPE" +builtinAgdaTCMGetDefinition = "AGDATCMGETDEFINITION" +builtinAgdaTCMBlockOnMeta = "AGDATCMBLOCKONMETA" +builtinAgdaTCMCommit = "AGDATCMCOMMIT" +builtinAgdaTCMQuoteTerm = "AGDATCMQUOTETERM" +builtinAgdaTCMUnquoteTerm = "AGDATCMUNQUOTETERM" +builtinAgdaTCMIsMacro = "AGDATCMISMACRO" +builtinAgdaTCMWithNormalisation = "AGDATCMWITHNORMALISATION" +builtinAgdaTCMDebugPrint = "AGDATCMDEBUGPRINT" +builtinAgdaTCMNoConstraints = "AGDATCMNOCONSTRAINTS" +builtinAgdaTCMRunSpeculative = "AGDATCMRUNSPECULATIVE" -- | Builtins that come without a definition in Agda syntax. -- These are giving names to Agda internal concepts which diff --git a/src/full/Agda/Syntax/Common.hs b/src/full/Agda/Syntax/Common.hs --- a/src/full/Agda/Syntax/Common.hs +++ b/src/full/Agda/Syntax/Common.hs @@ -2,1679 +2,2493 @@ {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} -{-# LANGUAGE UndecidableInstances #-} -- for: LensNamed name (Arg a) - -{-| Some common syntactic entities are defined in this module. --} -module Agda.Syntax.Common where - -import Control.DeepSeq - -import Data.ByteString.Char8 (ByteString) -import qualified Data.ByteString.Char8 as ByteString -import Data.Foldable -import Data.Hashable (Hashable(..)) -import qualified Data.Strict.Maybe as Strict -import Data.Semigroup hiding (Arg) -import Data.Traversable -import Data.Data (Data) -import Data.Word -import Data.IntSet (IntSet) -import qualified Data.IntSet as IntSet - -import GHC.Generics (Generic) - -import Agda.Syntax.Position - -import Agda.Utils.Functor -import Agda.Utils.Lens -import Agda.Utils.PartialOrd -import Agda.Utils.POMonoid -import Agda.Utils.Pretty hiding ((<>)) - -#include "undefined.h" -import Agda.Utils.Impossible - ---------------------------------------------------------------------------- --- * Delayed ---------------------------------------------------------------------------- - --- | Used to specify whether something should be delayed. -data Delayed = Delayed | NotDelayed - deriving (Data, Show, Eq, Ord) - -instance KillRange Delayed where - killRange = id - ---------------------------------------------------------------------------- --- * File ---------------------------------------------------------------------------- - -data FileType = AgdaFileType | MdFileType | RstFileType | TexFileType | OrgFileType - deriving (Data, Eq, Ord, Show) - -instance Pretty FileType where - pretty = \case - AgdaFileType -> "Agda" - MdFileType -> "Markdown" - RstFileType -> "ReStructedText" - TexFileType -> "LaTeX" - OrgFileType -> "org-mode" - ---------------------------------------------------------------------------- --- * Eta-equality ---------------------------------------------------------------------------- - -data HasEta = NoEta | YesEta - deriving (Data, Show, Eq, Ord) - -instance HasRange HasEta where - getRange _ = noRange - -instance KillRange HasEta where - killRange = id - -instance NFData HasEta where - rnf NoEta = () - rnf YesEta = () - ---------------------------------------------------------------------------- --- * Induction ---------------------------------------------------------------------------- - -data Induction = Inductive | CoInductive - deriving (Data, Eq, Ord, Show) - -instance Pretty Induction where - pretty Inductive = "inductive" - pretty CoInductive = "coinductive" - -instance HasRange Induction where - getRange _ = noRange - -instance KillRange Induction where - killRange = id - -instance NFData Induction where - rnf Inductive = () - rnf CoInductive = () - ---------------------------------------------------------------------------- --- * Hiding ---------------------------------------------------------------------------- - -data Overlappable = YesOverlap | NoOverlap - deriving (Data, Show, Eq, Ord) - -data Hiding = Hidden | Instance Overlappable | NotHidden - deriving (Data, Show, Eq, Ord) - -instance Pretty Hiding where - pretty = \case - Hidden -> "hidden" - NotHidden -> "visible" - Instance{} -> "instance" - --- | Just for the 'Hiding' instance. Should never combine different --- overlapping. -instance Semigroup Overlappable where - NoOverlap <> NoOverlap = NoOverlap - YesOverlap <> YesOverlap = YesOverlap - _ <> _ = __IMPOSSIBLE__ - --- | 'Hiding' is an idempotent partial monoid, with unit 'NotHidden'. --- 'Instance' and 'NotHidden' are incompatible. -instance Semigroup Hiding where - NotHidden <> h = h - h <> NotHidden = h - Hidden <> Hidden = Hidden - Instance o <> Instance o' = Instance (o <> o') - _ <> _ = __IMPOSSIBLE__ - -instance Monoid Overlappable where - mempty = NoOverlap - mappend = (<>) - -instance Monoid Hiding where - mempty = NotHidden - mappend = (<>) - -instance KillRange Hiding where - killRange = id - -instance NFData Overlappable where - rnf NoOverlap = () - rnf YesOverlap = () - -instance NFData Hiding where - rnf Hidden = () - rnf (Instance o) = rnf o - rnf NotHidden = () - --- | Decorating something with 'Hiding' information. -data WithHiding a = WithHiding - { whHiding :: !Hiding - , whThing :: a - } - deriving (Data, Eq, Ord, Show, Functor, Foldable, Traversable) - -instance Decoration WithHiding where - traverseF f (WithHiding h a) = WithHiding h <$> f a - -instance Applicative WithHiding where - pure = WithHiding mempty - WithHiding h f <*> WithHiding h' a = WithHiding (mappend h h') (f a) - -instance HasRange a => HasRange (WithHiding a) where - getRange = getRange . dget - -instance SetRange a => SetRange (WithHiding a) where - setRange = fmap . setRange - -instance KillRange a => KillRange (WithHiding a) where - killRange = fmap killRange - -instance NFData a => NFData (WithHiding a) where - rnf (WithHiding _ a) = rnf a - --- | A lens to access the 'Hiding' attribute in data structures. --- Minimal implementation: @getHiding@ and one of @setHiding@ or @mapHiding@. -class LensHiding a where - - getHiding :: a -> Hiding - - setHiding :: Hiding -> a -> a - setHiding h = mapHiding (const h) - - mapHiding :: (Hiding -> Hiding) -> a -> a - mapHiding f a = setHiding (f $ getHiding a) a - -instance LensHiding Hiding where - getHiding = id - setHiding = const - mapHiding = id - -instance LensHiding (WithHiding a) where - getHiding (WithHiding h _) = h - setHiding h (WithHiding _ a) = WithHiding h a - mapHiding f (WithHiding h a) = WithHiding (f h) a - --- | Monoidal composition of 'Hiding' information in some data. -mergeHiding :: LensHiding a => WithHiding a -> a -mergeHiding (WithHiding h a) = mapHiding (mappend h) a - --- | 'NotHidden' arguments are @visible@. -visible :: LensHiding a => a -> Bool -visible a = getHiding a == NotHidden - --- | 'Instance' and 'Hidden' arguments are @notVisible@. -notVisible :: LensHiding a => a -> Bool -notVisible a = getHiding a /= NotHidden - --- | 'Hidden' arguments are @hidden@. -hidden :: LensHiding a => a -> Bool -hidden a = getHiding a == Hidden - -hide :: LensHiding a => a -> a -hide = setHiding Hidden - -hideOrKeepInstance :: LensHiding a => a -> a -hideOrKeepInstance x = - case getHiding x of - Hidden -> x - Instance{} -> x - NotHidden -> setHiding Hidden x - -makeInstance :: LensHiding a => a -> a -makeInstance = makeInstance' NoOverlap - -makeInstance' :: LensHiding a => Overlappable -> a -> a -makeInstance' o = setHiding (Instance o) - -isOverlappable :: LensHiding a => a -> Bool -isOverlappable x = - case getHiding x of - Instance YesOverlap -> True - _ -> False - -isInstance :: LensHiding a => a -> Bool -isInstance x = - case getHiding x of - Instance{} -> True - _ -> False - --- | Ignores 'Overlappable'. -sameHiding :: (LensHiding a, LensHiding b) => a -> b -> Bool -sameHiding x y = - case (getHiding x, getHiding y) of - (Instance{}, Instance{}) -> True - (hx, hy) -> hx == hy - ---------------------------------------------------------------------------- --- * Modalities ---------------------------------------------------------------------------- - --- | We have a tuple of modalities, which might not be fully orthogonal. --- For instance, irrelevant stuff is also run-time irrelevant. -data Modality = Modality - { modRelevance :: Relevance - -- ^ Legacy irrelevance. - -- See Pfenning, LiCS 2001; Abel/Vezzosi/Winterhalter, ICFP 2017. - , modQuantity :: Quantity - -- ^ Cardinality / runtime erasure. - -- See Conor McBride, I got plenty o' nutting, Wadlerfest 2016. - -- See Bob Atkey, Syntax and Semantics of Quantitative Type Theory, LiCS 2018. - } deriving (Data, Eq, Ord, Show, Generic) - -defaultModality :: Modality -defaultModality = Modality defaultRelevance defaultQuantity - --- | Pointwise composition. -instance Semigroup Modality where - Modality r q <> Modality r' q' = Modality (r <> r') (q <> q') - --- | Pointwise unit. -instance Monoid Modality where - mempty = Modality mempty mempty - mappend = (<>) - --- | Dominance ordering. -instance PartialOrd Modality where - comparable (Modality r q) (Modality r' q') = comparable (r, q) (r', q') - -instance POSemigroup Modality where -instance POMonoid Modality where - -instance LeftClosedPOMonoid Modality where - inverseCompose = inverseComposeModality - --- | @m `moreUsableModality` m'@ means that an @m@ can be used --- where ever an @m'@ is required. - -moreUsableModality :: Modality -> Modality -> Bool -moreUsableModality m m' = related m POLE m' - -usableModality :: LensModality a => a -> Bool -usableModality a = usableRelevance m && usableQuantity m - where m = getModality a - -composeModality :: Modality -> Modality -> Modality -composeModality = (<>) - --- | Compose with modality flag from the left. --- This function is e.g. used to update the modality information --- on pattern variables @a@ after a match against something of modality @q@. -applyModality :: LensModality a => Modality -> a -> a -applyModality m = mapModality (m `composeModality`) - --- | @inverseComposeModality r x@ returns the least modality @y@ --- such that forall @x@, @y@ we have --- @x \`moreUsableModality\` (r \`composeModality\` y)@ --- iff --- @(r \`inverseComposeModality\` x) \`moreUsableModality\` y@ (Galois connection). -inverseComposeModality :: Modality -> Modality -> Modality -inverseComposeModality (Modality r q) (Modality r' q') = - Modality (r `inverseComposeRelevance` r') - (q `inverseComposeQuantity` q') - --- | Left division by a 'Modality'. --- Used e.g. to modify context when going into a @m@ argument. -inverseApplyModality :: LensModality a => Modality -> a -> a -inverseApplyModality m = mapModality (m `inverseComposeModality`) - - --- boilerplate instances - -instance KillRange Modality where - killRange = id - -instance NFData Modality where - --- Lens stuff - -lModRelevance :: Lens' Relevance Modality -lModRelevance f m = f (modRelevance m) <&> \ r -> m { modRelevance = r } - -lModQuantity :: Lens' Quantity Modality -lModQuantity f m = f (modQuantity m) <&> \ q -> m { modQuantity = q } - -class LensModality a where - - getModality :: a -> Modality - - setModality :: Modality -> a -> a - setModality = mapModality . const - - mapModality :: (Modality -> Modality) -> a -> a - mapModality f a = setModality (f $ getModality a) a - -instance LensModality Modality where - getModality = id - setModality = const - mapModality = id - -instance LensRelevance Modality where - getRelevance = modRelevance - setRelevance h m = m { modRelevance = h } - mapRelevance f m = m { modRelevance = f (modRelevance m) } - -instance LensQuantity Modality where - getQuantity = modQuantity - setQuantity h m = m { modQuantity = h } - mapQuantity f m = m { modQuantity = f (modQuantity m) } - --- default accessors for Relevance - -getRelevanceMod :: LensModality a => LensGet Relevance a -getRelevanceMod = getRelevance . getModality - -setRelevanceMod :: LensModality a => LensSet Relevance a -setRelevanceMod = mapModality . setRelevance - -mapRelevanceMod :: LensModality a => LensMap Relevance a -mapRelevanceMod = mapModality . mapRelevance - --- default accessors for Quantity - -getQuantityMod :: LensModality a => LensGet Quantity a -getQuantityMod = getQuantity . getModality - -setQuantityMod :: LensModality a => LensSet Quantity a -setQuantityMod = mapModality . setQuantity - -mapQuantityMod :: LensModality a => LensMap Quantity a -mapQuantityMod = mapModality . mapQuantity - ---------------------------------------------------------------------------- --- * Quantities ---------------------------------------------------------------------------- - --- | Quantity for linearity. --- --- A quantity is a set of natural numbers, indicating possible semantic --- uses of a variable. A singleton set @{n}@ requires that the --- corresponding variable is used exactly @n@ times. --- -data Quantity - = Quantity0 -- ^ Zero uses @{0}@, erased at runtime. - | Quantity1 -- ^ Linear use @{1}@ (could be updated destructively). - -- Mostly TODO (needs postponable constraints between quantities to compute uses). - | Quantityω -- ^ Unrestricted use @ℕ@. - deriving (Data, Show, Generic, Eq, Enum, Bounded, Ord) - -- @Ord@ instance in case @Quantity@ is used in keys for maps etc. - -defaultQuantity :: Quantity -defaultQuantity = Quantityω - --- | Composition of quantities (multiplication). --- --- 'Quantity0' is dominant. --- 'Quantity1' is neutral. --- -instance Semigroup Quantity where - Quantity1 <> q = q - q <> Quantity1 = q - Quantity0 <> _ = Quantity0 - _ <> Quantity0 = Quantity0 - Quantityω <> _ = Quantityω - -- _ <> Quantityω = Quantityω -- redundant - --- | In the absense of finite quantities besides 0, ω is the unit. --- Otherwise, 1 is the unit. -instance Monoid Quantity where - mempty = Quantity1 - mappend = (<>) - --- | Note that the order is @ω ≤ 0,1@, more options is smaller. -instance PartialOrd Quantity where - comparable = curry $ \case - (q, q') | q == q' -> POEQ - -- ω is least - (Quantityω, _) -> POLT - (_, Quantityω) -> POGT - -- others are uncomparable - _ -> POAny - -instance POSemigroup Quantity where -instance POMonoid Quantity where - -instance LeftClosedPOMonoid Quantity where - inverseCompose = inverseComposeQuantity - --- | @m `moreUsableQuantity` m'@ means that an @m@ can be used --- where ever an @m'@ is required. - -moreQuantity :: Quantity -> Quantity -> Bool -moreQuantity m m' = related m POLE m' - --- | A thing of quantity 0 is unusable, all others are usable. - -usableQuantity :: LensQuantity a => a -> Bool -usableQuantity a = getQuantity a /= Quantity0 - -composeQuantity :: Quantity -> Quantity -> Quantity -composeQuantity = (<>) - --- | Compose with quantity flag from the left. --- This function is e.g. used to update the quantity information --- on pattern variables @a@ after a match against something of quantity @q@. -applyQuantity :: LensQuantity a => Quantity -> a -> a -applyQuantity q = mapQuantity (q `composeQuantity`) - --- | @inverseComposeQuantity r x@ returns the least quantity @y@ --- such that forall @x@, @y@ we have --- @x \`moreQuantity\` (r \`composeQuantity\` y)@ --- iff --- @(r \`inverseComposeQuantity\` x) \`moreQuantity\` y@ (Galois connection). -inverseComposeQuantity :: Quantity -> Quantity -> Quantity -inverseComposeQuantity q x = - case (q, x) of - (Quantity1 , x) -> x -- going to linear arg: nothing changes - (Quantity0 , x) -> Quantityω -- going to erased arg: every thing usable - (Quantityω , Quantityω) -> Quantityω - (Quantityω , _) -> Quantity0 -- linear resources are unusable as arguments to unrestricted functions - --- | Left division by a 'Quantity'. --- Used e.g. to modify context when going into a @q@ argument. -inverseApplyQuantity :: LensQuantity a => Quantity -> a -> a -inverseApplyQuantity q = mapQuantity (q `inverseComposeQuantity`) - - --- boilerplate instances - -class LensQuantity a where - - getQuantity :: a -> Quantity - - setQuantity :: Quantity -> a -> a - setQuantity = mapQuantity . const - - mapQuantity :: (Quantity -> Quantity) -> a -> a - mapQuantity f a = setQuantity (f $ getQuantity a) a - -instance LensQuantity Quantity where - getQuantity = id - setQuantity = const - mapQuantity = id - -instance KillRange Quantity where - killRange = id - -instance NFData Quantity where - rnf Quantity0 = () - rnf Quantity1 = () - rnf Quantityω = () - ---------------------------------------------------------------------------- --- * Relevance ---------------------------------------------------------------------------- - --- | A function argument can be relevant or irrelevant. --- See "Agda.TypeChecking.Irrelevance". -data Relevance - = Relevant -- ^ The argument is (possibly) relevant at compile-time. - | NonStrict -- ^ The argument may never flow into evaluation position. - -- Therefore, it is irrelevant at run-time. - -- It is treated relevantly during equality checking. - | Irrelevant -- ^ The argument is irrelevant at compile- and runtime. - deriving (Data, Show, Eq, Enum, Bounded, Generic) - -allRelevances :: [Relevance] -allRelevances = [minBound..maxBound] - -defaultRelevance :: Relevance -defaultRelevance = Relevant - -instance KillRange Relevance where - killRange rel = rel -- no range to kill - -instance NFData Relevance where - rnf Relevant = () - rnf NonStrict = () - rnf Irrelevant = () - --- | A lens to access the 'Relevance' attribute in data structures. --- Minimal implementation: @getRelevance@ and one of @setRelevance@ or @mapRelevance@. -class LensRelevance a where - - getRelevance :: a -> Relevance - - setRelevance :: Relevance -> a -> a - setRelevance h = mapRelevance (const h) - - mapRelevance :: (Relevance -> Relevance) -> a -> a - mapRelevance f a = setRelevance (f $ getRelevance a) a - -instance LensRelevance Relevance where - getRelevance = id - setRelevance = const - mapRelevance = id - -isRelevant :: LensRelevance a => a -> Bool -isRelevant a = getRelevance a == Relevant - -isIrrelevant :: LensRelevance a => a -> Bool -isIrrelevant a = getRelevance a == Irrelevant - -isNonStrict :: LensRelevance a => a -> Bool -isNonStrict a = getRelevance a == NonStrict - --- | Information ordering. --- @Relevant \`moreRelevant\` --- NonStrict \`moreRelevant\` --- Irrelevant@ -moreRelevant :: Relevance -> Relevance -> Bool -moreRelevant = (<=) - --- | More relevant is smaller. -instance Ord Relevance where - compare = curry $ \case - (r, r') | r == r' -> EQ - -- top - (_, Irrelevant) -> LT - (Irrelevant, _) -> GT - -- bottom - (Relevant, _) -> LT - (_, Relevant) -> GT - -- redundant case - (NonStrict,NonStrict) -> EQ - --- | More relevant is smaller. -instance PartialOrd Relevance where - comparable = comparableOrd - --- | @usableRelevance rel == False@ iff we cannot use a variable of @rel@. -usableRelevance :: LensRelevance a => a -> Bool -usableRelevance a = case getRelevance a of - Irrelevant -> False - NonStrict -> False - Relevant -> True - --- | 'Relevance' composition. --- 'Irrelevant' is dominant, 'Relevant' is neutral. -composeRelevance :: Relevance -> Relevance -> Relevance -composeRelevance r r' = - case (r, r') of - (Irrelevant, _) -> Irrelevant - (_, Irrelevant) -> Irrelevant - (NonStrict, _) -> NonStrict - (_, NonStrict) -> NonStrict - (Relevant, Relevant) -> Relevant - --- | Compose with relevance flag from the left. --- This function is e.g. used to update the relevance information --- on pattern variables @a@ after a match against something @rel@. -applyRelevance :: LensRelevance a => Relevance -> a -> a -applyRelevance rel = mapRelevance (rel `composeRelevance`) - --- | @inverseComposeRelevance r x@ returns the most irrelevant @y@ --- such that forall @x@, @y@ we have --- @x \`moreRelevant\` (r \`composeRelevance\` y)@ --- iff --- @(r \`inverseComposeRelevance\` x) \`moreRelevant\` y@ (Galois connection). -inverseComposeRelevance :: Relevance -> Relevance -> Relevance -inverseComposeRelevance r x = - case (r, x) of - (Relevant , x) -> x -- going to relevant arg.: nothing changes - -- because Relevant is comp.-neutral - (Irrelevant, x) -> Relevant -- going irrelevant: every thing usable - (NonStrict , Irrelevant) -> Irrelevant -- otherwise: irrelevant things remain unusable - (NonStrict , _) -> Relevant -- but @NonStrict@s become usable - --- | Left division by a 'Relevance'. --- Used e.g. to modify context when going into a @rel@ argument. -inverseApplyRelevance :: LensRelevance a => Relevance -> a -> a -inverseApplyRelevance rel = mapRelevance (rel `inverseComposeRelevance`) - --- | 'Relevance' forms a semigroup under composition. -instance Semigroup Relevance where - (<>) = composeRelevance - --- | 'Relevant' is the unit. -instance Monoid Relevance where - mempty = Relevant - mappend = (<>) - -instance POSemigroup Relevance where -instance POMonoid Relevance where - -instance LeftClosedPOMonoid Relevance where - inverseCompose = inverseComposeRelevance - --- | Irrelevant function arguments may appear non-strictly in the codomain type. -irrToNonStrict :: Relevance -> Relevance -irrToNonStrict Irrelevant = NonStrict -irrToNonStrict rel = rel - --- | Applied when working on types (unless --experimental-irrelevance). -nonStrictToRel :: Relevance -> Relevance -nonStrictToRel NonStrict = Relevant -nonStrictToRel rel = rel - -nonStrictToIrr :: Relevance -> Relevance -nonStrictToIrr NonStrict = Irrelevant -nonStrictToIrr rel = rel - ---------------------------------------------------------------------------- --- * Origin of arguments (user-written, inserted or reflected) ---------------------------------------------------------------------------- - --- | Origin of arguments. -data Origin - = UserWritten -- ^ From the source file / user input. (Preserve!) - | Inserted -- ^ E.g. inserted hidden arguments. - | Reflected -- ^ Produced by the reflection machinery. - | CaseSplit -- ^ Produced by an interactive case split. - | Substitution -- ^ Named application produced to represent a substitution. E.g. "?0 (x = n)" instead of "?0 n" - deriving (Data, Show, Eq, Ord) - -instance KillRange Origin where - killRange = id - -instance NFData Origin where - rnf UserWritten = () - rnf Inserted = () - rnf Reflected = () - rnf CaseSplit = () - rnf Substitution = () - --- | Decorating something with 'Origin' information. -data WithOrigin a = WithOrigin - { woOrigin :: !Origin - , woThing :: a - } - deriving (Data, Eq, Ord, Show, Functor, Foldable, Traversable) - -instance Decoration WithOrigin where - traverseF f (WithOrigin h a) = WithOrigin h <$> f a - -instance HasRange a => HasRange (WithOrigin a) where - getRange = getRange . dget - -instance SetRange a => SetRange (WithOrigin a) where - setRange = fmap . setRange - -instance KillRange a => KillRange (WithOrigin a) where - killRange = fmap killRange - -instance NFData a => NFData (WithOrigin a) where - rnf (WithOrigin _ a) = rnf a - --- | A lens to access the 'Origin' attribute in data structures. --- Minimal implementation: @getOrigin@ and one of @setOrigin@ or @mapOrigin@. - -class LensOrigin a where - - getOrigin :: a -> Origin - - setOrigin :: Origin -> a -> a - setOrigin o = mapOrigin (const o) - - mapOrigin :: (Origin -> Origin) -> a -> a - mapOrigin f a = setOrigin (f $ getOrigin a) a - -instance LensOrigin Origin where - getOrigin = id - setOrigin = const - mapOrigin = id - -instance LensOrigin (WithOrigin a) where - getOrigin (WithOrigin h _) = h - setOrigin h (WithOrigin _ a) = WithOrigin h a - mapOrigin f (WithOrigin h a) = WithOrigin (f h) a - ------------------------------------------------------------------------------ --- * Free variable annotations ------------------------------------------------------------------------------ - -data FreeVariables = UnknownFVs | KnownFVs IntSet - deriving (Data, Eq, Ord, Show) - -instance Semigroup FreeVariables where - UnknownFVs <> _ = UnknownFVs - _ <> UnknownFVs = UnknownFVs - KnownFVs vs1 <> KnownFVs vs2 = KnownFVs (IntSet.union vs1 vs2) - -instance Monoid FreeVariables where - mempty = KnownFVs IntSet.empty - mappend = (<>) - -instance NFData FreeVariables where - rnf UnknownFVs = () - rnf (KnownFVs fv) = rnf fv - -unknownFreeVariables :: FreeVariables -unknownFreeVariables = UnknownFVs - -noFreeVariables :: FreeVariables -noFreeVariables = mempty - -oneFreeVariable :: Int -> FreeVariables -oneFreeVariable = KnownFVs . IntSet.singleton - -freeVariablesFromList :: [Int] -> FreeVariables -freeVariablesFromList = mconcat . map oneFreeVariable - --- | A lens to access the 'FreeVariables' attribute in data structures. --- Minimal implementation: @getFreeVariables@ and one of @setFreeVariables@ or @mapFreeVariables@. -class LensFreeVariables a where - - getFreeVariables :: a -> FreeVariables - - setFreeVariables :: FreeVariables -> a -> a - setFreeVariables o = mapFreeVariables (const o) - - mapFreeVariables :: (FreeVariables -> FreeVariables) -> a -> a - mapFreeVariables f a = setFreeVariables (f $ getFreeVariables a) a - -instance LensFreeVariables FreeVariables where - getFreeVariables = id - setFreeVariables = const - mapFreeVariables = id - -hasNoFreeVariables :: LensFreeVariables a => a -> Bool -hasNoFreeVariables x = - case getFreeVariables x of - UnknownFVs -> False - KnownFVs fv -> IntSet.null fv - ---------------------------------------------------------------------------- --- * Argument decoration ---------------------------------------------------------------------------- - --- | A function argument can be hidden and/or irrelevant. - -data ArgInfo = ArgInfo - { argInfoHiding :: Hiding - , argInfoModality :: Modality - , argInfoOrigin :: Origin - , argInfoFreeVariables :: FreeVariables - } deriving (Data, Eq, Ord, Show) - -instance KillRange ArgInfo where - killRange i = i -- There are no ranges in ArgInfo's - -class LensArgInfo a where - getArgInfo :: a -> ArgInfo - setArgInfo :: ArgInfo -> a -> a - setArgInfo ai = mapArgInfo (const ai) - mapArgInfo :: (ArgInfo -> ArgInfo) -> a -> a - mapArgInfo f a = setArgInfo (f $ getArgInfo a) a - -instance LensArgInfo ArgInfo where - getArgInfo = id - setArgInfo = const - mapArgInfo = id - -instance NFData ArgInfo where - rnf (ArgInfo a b c d) = rnf a `seq` rnf b `seq` rnf c `seq` rnf d - -instance LensHiding ArgInfo where - getHiding = argInfoHiding - setHiding h ai = ai { argInfoHiding = h } - mapHiding f ai = ai { argInfoHiding = f (argInfoHiding ai) } - -instance LensModality ArgInfo where - getModality = argInfoModality - setModality m ai = ai { argInfoModality = m } - mapModality f ai = ai { argInfoModality = f (argInfoModality ai) } - -instance LensOrigin ArgInfo where - getOrigin = argInfoOrigin - setOrigin o ai = ai { argInfoOrigin = o } - mapOrigin f ai = ai { argInfoOrigin = f (argInfoOrigin ai) } - -instance LensFreeVariables ArgInfo where - getFreeVariables = argInfoFreeVariables - setFreeVariables o ai = ai { argInfoFreeVariables = o } - mapFreeVariables f ai = ai { argInfoFreeVariables = f (argInfoFreeVariables ai) } - --- inherited instances - -instance LensRelevance ArgInfo where - getRelevance = getRelevanceMod - setRelevance = setRelevanceMod - mapRelevance = mapRelevanceMod - -instance LensQuantity ArgInfo where - getQuantity = getQuantityMod - setQuantity = setQuantityMod - mapQuantity = mapQuantityMod - -defaultArgInfo :: ArgInfo -defaultArgInfo = ArgInfo - { argInfoHiding = NotHidden - , argInfoModality = defaultModality - , argInfoOrigin = UserWritten - , argInfoFreeVariables = UnknownFVs - } - --- Accessing through ArgInfo - --- default accessors for Hiding - -getHidingArgInfo :: LensArgInfo a => LensGet Hiding a -getHidingArgInfo = getHiding . getArgInfo - -setHidingArgInfo :: LensArgInfo a => LensSet Hiding a -setHidingArgInfo = mapArgInfo . setHiding - -mapHidingArgInfo :: LensArgInfo a => LensMap Hiding a -mapHidingArgInfo = mapArgInfo . mapHiding - --- default accessors for Modality - -getModalityArgInfo :: LensArgInfo a => LensGet Modality a -getModalityArgInfo = getModality . getArgInfo - -setModalityArgInfo :: LensArgInfo a => LensSet Modality a -setModalityArgInfo = mapArgInfo . setModality - -mapModalityArgInfo :: LensArgInfo a => LensMap Modality a -mapModalityArgInfo = mapArgInfo . mapModality - --- default accessors for Origin - -getOriginArgInfo :: LensArgInfo a => LensGet Origin a -getOriginArgInfo = getOrigin . getArgInfo - -setOriginArgInfo :: LensArgInfo a => LensSet Origin a -setOriginArgInfo = mapArgInfo . setOrigin - -mapOriginArgInfo :: LensArgInfo a => LensMap Origin a -mapOriginArgInfo = mapArgInfo . mapOrigin - --- default accessors for FreeVariables - -getFreeVariablesArgInfo :: LensArgInfo a => LensGet FreeVariables a -getFreeVariablesArgInfo = getFreeVariables . getArgInfo - -setFreeVariablesArgInfo :: LensArgInfo a => LensSet FreeVariables a -setFreeVariablesArgInfo = mapArgInfo . setFreeVariables - -mapFreeVariablesArgInfo :: LensArgInfo a => LensMap FreeVariables a -mapFreeVariablesArgInfo = mapArgInfo . mapFreeVariables - - ---------------------------------------------------------------------------- --- * Arguments ---------------------------------------------------------------------------- - -data Arg e = Arg - { argInfo :: ArgInfo - , unArg :: e - } deriving (Data, Ord, Show, Functor, Foldable, Traversable) - -instance Decoration Arg where - traverseF f (Arg ai a) = Arg ai <$> f a - -instance HasRange a => HasRange (Arg a) where - getRange = getRange . unArg - -instance SetRange a => SetRange (Arg a) where - setRange r = fmap $ setRange r - -instance KillRange a => KillRange (Arg a) where - killRange (Arg info a) = killRange2 Arg info a - --- | Ignores 'Quantity', 'Relevance', 'Origin', and 'FreeVariables'. --- Ignores content of argument if 'Irrelevant'. --- -instance Eq a => Eq (Arg a) where - Arg (ArgInfo h1 m1 _ _) x1 == Arg (ArgInfo h2 m2 _ _) x2 = - h1 == h2 && (isIrrelevant m1 || isIrrelevant m2 || x1 == x2) - -- Andreas, 2017-10-04, issue #2775, ignore irrelevant arguments during with-abstraction. - -- This is a hack, we should not use '(==)' in with-abstraction - -- and more generally not use it on Syntax. - -- Andrea: except for caching. - --- instance Show a => Show (Arg a) where --- show (Arg (ArgInfo h (Modality r q) o fv) a) = showFVs fv $ showQ q $ showR r $ showO o $ showH h $ show a --- where --- showH Hidden s = "{" ++ s ++ "}" --- showH NotHidden s = "(" ++ s ++ ")" --- showH (Instance o) s = showOv o ++ "{{" ++ s ++ "}}" --- where showOv YesOverlap = "overlap " --- showOv NoOverlap = "" --- showR r s = case r of --- Irrelevant -> "." ++ s --- NonStrict -> "?" ++ s --- Relevant -> "r" ++ s -- Andreas: I want to see it explicitly --- showQ q s = case q of --- Quantity0 -> "0" ++ s --- Quantity1 -> "1" ++ s --- Quantityω -> "ω" ++ s --- showO o s = case o of --- UserWritten -> "u" ++ s --- Inserted -> "i" ++ s --- Reflected -> "g" ++ s -- generated by reflection --- CaseSplit -> "c" ++ s -- generated by case split --- Substitution -> "s" ++ s --- showFVs UnknownFVs s = s --- showFVs (KnownFVs fv) s = "fv" ++ show (IntSet.toList fv) ++ s - --- -- defined in Concrete.Pretty --- instance Pretty a => Pretty (Arg a) where --- pretty (Arg (ArgInfo h (Modality r q) o fv) a) = prettyFVs fv $ prettyQ q $ prettyR r $ prettyO o $ prettyH h $ pretty a --- where --- prettyH Hidden s = "{" <> s <> "}" --- prettyH NotHidden s = "(" <> s <> ")" --- prettyH (Instance o) s = prettyOv o <> "{{" <> s <> "}}" --- where prettyOv YesOverlap = "overlap " --- prettyOv NoOverlap = "" --- prettyR r s = case r of --- Irrelevant -> "." <> s --- NonStrict -> "?" <> s --- Relevant -> "r" <> s -- Andreas: I want to see it explicitly --- prettyQ q s = case q of --- Quantity0 -> "0" <> s --- Quantity1 -> "1" <> s --- Quantityω -> "ω" <> s --- prettyO o s = case o of --- UserWritten -> "u" <> s --- Inserted -> "i" <> s --- Reflected -> "g" <> s -- generated by reflection --- CaseSplit -> "c" <> s -- generated by case split --- Substitution -> "s" <> s --- prettyFVs UnknownFVs s = s --- prettyFVs (KnownFVs fv) s = "fv" <> pretty (IntSet.toList fv) <> s - -instance NFData e => NFData (Arg e) where - rnf (Arg a b) = rnf a `seq` rnf b - -instance LensArgInfo (Arg a) where - getArgInfo = argInfo - setArgInfo ai arg = arg { argInfo = ai } - mapArgInfo f arg = arg { argInfo = f $ argInfo arg } - --- The other lenses are defined through LensArgInfo - -instance LensHiding (Arg e) where - getHiding = getHidingArgInfo - setHiding = setHidingArgInfo - mapHiding = mapHidingArgInfo - -instance LensModality (Arg e) where - getModality = getModalityArgInfo - setModality = setModalityArgInfo - mapModality = mapModalityArgInfo - -instance LensOrigin (Arg e) where - getOrigin = getOriginArgInfo - setOrigin = setOriginArgInfo - mapOrigin = mapOriginArgInfo - -instance LensFreeVariables (Arg e) where - getFreeVariables = getFreeVariablesArgInfo - setFreeVariables = setFreeVariablesArgInfo - mapFreeVariables = mapFreeVariablesArgInfo - --- Since we have LensModality, we get relevance and quantity by default - -instance LensRelevance (Arg e) where - getRelevance = getRelevanceMod - setRelevance = setRelevanceMod - mapRelevance = mapRelevanceMod - -instance LensQuantity (Arg e) where - getQuantity = getQuantityMod - setQuantity = setQuantityMod - mapQuantity = mapQuantityMod - -defaultArg :: a -> Arg a -defaultArg = Arg defaultArgInfo - --- | @xs \`withArgsFrom\` args@ translates @xs@ into a list of 'Arg's, --- using the elements in @args@ to fill in the non-'unArg' fields. --- --- Precondition: The two lists should have equal length. - -withArgsFrom :: [a] -> [Arg b] -> [Arg a] -xs `withArgsFrom` args = - zipWith (\x arg -> fmap (const x) arg) xs args - -withNamedArgsFrom :: [a] -> [NamedArg b] -> [NamedArg a] -xs `withNamedArgsFrom` args = - zipWith (\x -> fmap (x <$)) xs args - ---------------------------------------------------------------------------- --- * Names ---------------------------------------------------------------------------- - -class Eq a => Underscore a where - underscore :: a - isUnderscore :: a -> Bool - isUnderscore = (== underscore) - -instance Underscore String where - underscore = "_" - -instance Underscore ByteString where - underscore = ByteString.pack underscore - -instance Underscore Doc where - underscore = text underscore - ---------------------------------------------------------------------------- --- * Function type domain ---------------------------------------------------------------------------- - --- | Similar to 'Arg', but we need to distinguish --- an irrelevance annotation in a function domain --- (the domain itself is not irrelevant!) --- from an irrelevant argument. --- --- @Dom@ is used in 'Pi' of internal syntax, in 'Context' and 'Telescope'. --- 'Arg' is used for actual arguments ('Var', 'Con', 'Def' etc.) --- and in 'Abstract' syntax and other situations. --- --- [ cubical ] When @domFinite = True@ for the domain of a 'Pi' --- type, the elements should be compared by tabulating the domain type. --- Only supported in case the domain type is primIsOne, to obtain --- the correct equality for partial elements. -data Dom e = Dom - { domInfo :: ArgInfo - , domFinite :: !Bool - , domName :: Maybe RString - , unDom :: e - } deriving (Data, Ord, Show, Functor, Foldable, Traversable) - -instance Decoration Dom where - traverseF f (Dom ai b x a) = Dom ai b x <$> f a - -instance HasRange a => HasRange (Dom a) where - getRange = getRange . unDom - -instance KillRange a => KillRange (Dom a) where - killRange (Dom info b x a) = killRange4 Dom info b x a - --- | Ignores 'Origin' and 'FreeVariables'. -instance Eq a => Eq (Dom a) where - Dom (ArgInfo h1 m1 _ _) b1 s1 x1 == Dom (ArgInfo h2 m2 _ _) b2 s2 x2 = - (h1, m1, b1, s1, x1) == (h2, m2, b2, s2, x2) - --- instance Show a => Show (Dom a) where --- show = show . argFromDom - -instance LensArgInfo (Dom e) where - getArgInfo = domInfo - setArgInfo ai dom = dom { domInfo = ai } - mapArgInfo f dom = dom { domInfo = f $ domInfo dom } - --- The other lenses are defined through LensArgInfo - -instance LensHiding (Dom e) where - getHiding = getHidingArgInfo - setHiding = setHidingArgInfo - mapHiding = mapHidingArgInfo - -instance LensModality (Dom e) where - getModality = getModalityArgInfo - setModality = setModalityArgInfo - mapModality = mapModalityArgInfo - -instance LensOrigin (Dom e) where - getOrigin = getOriginArgInfo - setOrigin = setOriginArgInfo - mapOrigin = mapOriginArgInfo - -instance LensFreeVariables (Dom e) where - getFreeVariables = getFreeVariablesArgInfo - setFreeVariables = setFreeVariablesArgInfo - mapFreeVariables = mapFreeVariablesArgInfo - --- Since we have LensModality, we get relevance and quantity by default - -instance LensRelevance (Dom e) where - getRelevance = getRelevanceMod - setRelevance = setRelevanceMod - mapRelevance = mapRelevanceMod - -instance LensQuantity (Dom e) where - getQuantity = getQuantityMod - setQuantity = setQuantityMod - mapQuantity = mapQuantityMod - -argFromDom :: Dom a -> Arg a -argFromDom (Dom i _ _ a) = Arg i a - -namedArgFromDom :: Dom a -> NamedArg a -namedArgFromDom (Dom i _ s a) = Arg i $ Named s a - -domFromArg :: Arg a -> Dom a -domFromArg (Arg i a) = Dom i False Nothing a - -domFromNamedArg :: NamedArg a -> Dom a -domFromNamedArg (Arg i a) = Dom i False (nameOf a) (namedThing a) - -defaultDom :: a -> Dom a -defaultDom = defaultArgDom defaultArgInfo - -defaultArgDom :: ArgInfo -> a -> Dom a -defaultArgDom info x = Dom info False Nothing x - -defaultNamedArgDom :: ArgInfo -> String -> a -> Dom a -defaultNamedArgDom info s = Dom info False (Just $ unranged s) - ---------------------------------------------------------------------------- --- * Named arguments ---------------------------------------------------------------------------- - --- | Something potentially carrying a name. -data Named name a = - Named { nameOf :: Maybe name - , namedThing :: a - } - deriving (Eq, Ord, Show, Data, Functor, Foldable, Traversable) - --- | Standard naming. -type Named_ = Named RString - -unnamed :: a -> Named name a -unnamed = Named Nothing - -named :: name -> a -> Named name a -named = Named . Just - --- | Accessor/editor for the 'nameOf' component. -class LensNamed name a | a -> name where - lensNamed :: Lens' (Maybe name) a - -instance LensNamed name (Named name a) where - lensNamed f (Named mn a) = f mn <&> \ mn' -> Named mn' a - -getNameOf :: LensNamed name a => a -> Maybe name -getNameOf a = a ^. lensNamed - -setNameOf :: LensNamed name a => Maybe name -> a -> a -setNameOf = set lensNamed - -mapNameOf :: LensNamed name a => (Maybe name -> Maybe name) -> a -> a -mapNameOf = over lensNamed - --- Lenses lift through decorations: --- instance (Decoration f, LensNamed name a) => LensNamed name (f a) where - -instance LensNamed name a => LensNamed name (Arg a) where - lensNamed = traverseF . lensNamed - --- Standard instances for 'Named': - -instance Decoration (Named name) where - traverseF f (Named n a) = Named n <$> f a - -instance HasRange a => HasRange (Named name a) where - getRange = getRange . namedThing - -instance SetRange a => SetRange (Named name a) where - setRange r = fmap $ setRange r - -instance (KillRange name, KillRange a) => KillRange (Named name a) where - killRange (Named n a) = Named (killRange n) (killRange a) - --- instance Show a => Show (Named_ a) where --- show (Named Nothing a) = show a --- show (Named (Just n) a) = rawNameToString (rangedThing n) ++ " = " ++ show a - --- -- Defined in Concrete.Pretty --- instance Pretty a => Pretty (Named_ a) where --- pretty (Named Nothing a) = pretty a --- pretty (Named (Just n) a) = text (rawNameToString (rangedThing n)) <+> "=" <+> pretty a - -instance (NFData name, NFData a) => NFData (Named name a) where - rnf (Named a b) = rnf a `seq` rnf b - --- | Only 'Hidden' arguments can have names. -type NamedArg a = Arg (Named_ a) - --- | Get the content of a 'NamedArg'. -namedArg :: NamedArg a -> a -namedArg = namedThing . unArg - -defaultNamedArg :: a -> NamedArg a -defaultNamedArg = unnamedArg defaultArgInfo - -unnamedArg :: ArgInfo -> a -> NamedArg a -unnamedArg info = Arg info . unnamed - --- | The functor instance for 'NamedArg' would be ambiguous, --- so we give it another name here. -updateNamedArg :: (a -> b) -> NamedArg a -> NamedArg b -updateNamedArg = fmap . fmap - --- | @setNamedArg a b = updateNamedArg (const b) a@ -setNamedArg :: NamedArg a -> b -> NamedArg b -setNamedArg a b = (b <$) <$> a - ---------------------------------------------------------------------------- --- * Range decoration. ---------------------------------------------------------------------------- - --- | Thing with range info. -data Ranged a = Ranged - { rangeOf :: Range - , rangedThing :: a - } - deriving (Data, Show, Functor, Foldable, Traversable) - --- | Thing with no range info. -unranged :: a -> Ranged a -unranged = Ranged noRange - -instance Pretty a => Pretty (Ranged a) where - pretty = pretty . rangedThing - --- instance Show a => Show (Ranged a) where --- show = show . rangedThing - -instance Eq a => Eq (Ranged a) where - Ranged _ x == Ranged _ y = x == y - -instance Ord a => Ord (Ranged a) where - compare (Ranged _ x) (Ranged _ y) = compare x y - -instance HasRange (Ranged a) where - getRange = rangeOf - -instance KillRange (Ranged a) where - killRange (Ranged _ x) = Ranged noRange x - -instance Decoration Ranged where - traverseF f (Ranged r x) = Ranged r <$> f x - --- | Ranges are not forced. - -instance NFData a => NFData (Ranged a) where - rnf (Ranged _ a) = rnf a - ---------------------------------------------------------------------------- --- * Raw names (before parsing into name parts). ---------------------------------------------------------------------------- - --- | A @RawName@ is some sort of string. -type RawName = String - -rawNameToString :: RawName -> String -rawNameToString = id - -stringToRawName :: String -> RawName -stringToRawName = id - --- | String with range info. -type RString = Ranged RawName - ---------------------------------------------------------------------------- --- * Further constructor and projection info ---------------------------------------------------------------------------- - --- | Where does the 'ConP' or 'Con' come from? -data ConOrigin - = ConOSystem -- ^ Inserted by system or expanded from an implicit pattern. - | ConOCon -- ^ User wrote a constructor (pattern). - | ConORec -- ^ User wrote a record (pattern). - | ConOSplit -- ^ Generated by interactive case splitting. - deriving (Data, Show, Eq, Ord, Enum, Bounded) - -instance KillRange ConOrigin where - killRange = id - --- | Prefer user-written over system-inserted. -bestConInfo :: ConOrigin -> ConOrigin -> ConOrigin -bestConInfo ConOSystem o = o -bestConInfo o _ = o - --- | Where does a projection come from? -data ProjOrigin - = ProjPrefix -- ^ User wrote a prefix projection. - | ProjPostfix -- ^ User wrote a postfix projection. - | ProjSystem -- ^ Projection was generated by the system. - deriving (Data, Show, Eq, Ord, Enum, Bounded) - -instance KillRange ProjOrigin where - killRange = id - -data DataOrRecord = IsData | IsRecord - deriving (Data, Eq, Ord, Show) - ---------------------------------------------------------------------------- --- * Infixity, access, abstract, etc. ---------------------------------------------------------------------------- - --- | Functions can be defined in both infix and prefix style. See --- 'Agda.Syntax.Concrete.LHS'. -data IsInfix = InfixDef | PrefixDef - deriving (Data, Show, Eq, Ord) - --- | Access modifier. -data Access - = PrivateAccess Origin - -- ^ Store the 'Origin' of the private block that lead to this qualifier. - -- This is needed for more faithful printing of declarations. - | PublicAccess - | OnlyQualified -- ^ Visible from outside, but not exported when opening the module - -- Used for qualified constructors. - deriving (Data, Show, Eq, Ord) - -instance Pretty Access where - pretty = text . \case - PrivateAccess _ -> "private" - PublicAccess -> "public" - OnlyQualified -> "only-qualified" - -instance NFData Access where - rnf _ = () - -instance HasRange Access where - getRange _ = noRange - -instance KillRange Access where - killRange = id - --- | Abstract or concrete -data IsAbstract = AbstractDef | ConcreteDef - deriving (Data, Show, Eq, Ord) - -instance KillRange IsAbstract where - killRange = id - --- | Is this definition eligible for instance search? -data IsInstance = InstanceDef | NotInstanceDef - deriving (Data, Show, Eq, Ord) - -instance KillRange IsInstance where - killRange = id - -instance HasRange IsInstance where - getRange _ = noRange - -instance NFData IsInstance where - rnf InstanceDef = () - rnf NotInstanceDef = () - --- | Is this a macro definition? -data IsMacro = MacroDef | NotMacroDef - deriving (Data, Show, Eq, Ord) - -instance KillRange IsMacro where killRange = id -instance HasRange IsMacro where getRange _ = noRange - -type Nat = Int -type Arity = Nat - ---------------------------------------------------------------------------- --- * NameId ---------------------------------------------------------------------------- - --- | The unique identifier of a name. Second argument is the top-level module --- identifier. -data NameId = NameId {-# UNPACK #-} !Word64 {-# UNPACK #-} !Word64 - deriving (Eq, Ord, Data, Generic, Show) - -instance KillRange NameId where - killRange = id - -instance Pretty NameId where - pretty (NameId n m) = text $ show n ++ "@" ++ show m - -instance Enum NameId where - succ (NameId n m) = NameId (n + 1) m - pred (NameId n m) = NameId (n - 1) m - toEnum n = __IMPOSSIBLE__ -- should not be used - fromEnum (NameId n _) = fromIntegral n - -instance NFData NameId where - rnf (NameId _ _) = () - -instance Hashable NameId where - {-# INLINE hashWithSalt #-} - hashWithSalt salt (NameId n m) = hashWithSalt salt (n, m) - ---------------------------------------------------------------------------- --- * Meta variables ---------------------------------------------------------------------------- - --- | A meta variable identifier is just a natural number. --- -newtype MetaId = MetaId { metaId :: Nat } - deriving (Eq, Ord, Num, Real, Enum, Integral, Data) - -instance Pretty MetaId where - pretty (MetaId n) = text $ "_" ++ show n - --- | Show non-record version of this newtype. -instance Show MetaId where - showsPrec p (MetaId n) = showParen (p > 0) $ - showString "MetaId " . shows n - -instance NFData MetaId where - rnf (MetaId x) = rnf x - -newtype Constr a = Constr a - ------------------------------------------------------------------------- --- * Placeholders (used to parse sections) ------------------------------------------------------------------------- - --- | The position of a name part or underscore in a name. - -data PositionInName - = Beginning - -- ^ The following underscore is at the beginning of the name: - -- @_foo@. - | Middle - -- ^ The following underscore is in the middle of the name: - -- @foo_bar@. - | End - -- ^ The following underscore is at the end of the name: @foo_@. - deriving (Show, Eq, Ord, Data) - --- | Placeholders are used to represent the underscores in a section. - -data MaybePlaceholder e - = Placeholder !PositionInName - | NoPlaceholder !(Strict.Maybe PositionInName) e - -- ^ The second argument is used only (but not always) for name - -- parts other than underscores. - deriving (Data, Eq, Ord, Functor, Foldable, Traversable, Show) - --- | An abbreviation: @noPlaceholder = 'NoPlaceholder' --- 'Strict.Nothing'@. - -noPlaceholder :: e -> MaybePlaceholder e -noPlaceholder = NoPlaceholder Strict.Nothing - -instance HasRange a => HasRange (MaybePlaceholder a) where - getRange Placeholder{} = noRange - getRange (NoPlaceholder _ e) = getRange e - -instance KillRange a => KillRange (MaybePlaceholder a) where - killRange p@Placeholder{} = p - killRange (NoPlaceholder p e) = killRange1 (NoPlaceholder p) e - -instance NFData a => NFData (MaybePlaceholder a) where - rnf (Placeholder _) = () - rnf (NoPlaceholder _ a) = rnf a - ---------------------------------------------------------------------------- --- * Interaction meta variables ---------------------------------------------------------------------------- - -newtype InteractionId = InteractionId { interactionId :: Nat } - deriving ( Eq - , Ord - , Show - , Num - , Integral - , Real - , Enum - , Data - ) - -instance Pretty InteractionId where - pretty (InteractionId i) = text $ "?" ++ show i - -instance KillRange InteractionId where killRange = id - ------------------------------------------------------------------------------ --- * Import directive ------------------------------------------------------------------------------ - --- | The things you are allowed to say when you shuffle names between name --- spaces (i.e. in @import@, @namespace@, or @open@ declarations). -data ImportDirective' n m = ImportDirective - { importDirRange :: Range - , using :: Using' n m - , hiding :: [ImportedName' n m] - , impRenaming :: [Renaming' n m] - , publicOpen :: Bool -- ^ Only for @open@. Exports the opened names from the current module. - } - deriving (Data, Eq) - -data Using' n m = UseEverything | Using [ImportedName' n m] - deriving (Data, Eq) - -instance Semigroup (Using' n m) where - UseEverything <> u = u - u <> UseEverything = u - Using xs <> Using ys = Using (xs ++ ys) - -instance Monoid (Using' n m) where - mempty = UseEverything - mappend = (<>) - --- | Default is directive is @private@ (use everything, but do not export). -defaultImportDir :: ImportDirective' n m -defaultImportDir = ImportDirective noRange UseEverything [] [] False - -isDefaultImportDir :: ImportDirective' n m -> Bool -isDefaultImportDir (ImportDirective _ UseEverything [] [] False) = True -isDefaultImportDir _ = False - --- | An imported name can be a module or a defined name. -data ImportedName' n m - = ImportedModule m -- ^ Imported module name of type @m@. - | ImportedName n -- ^ Imported name of type @n@. - deriving (Data, Eq, Ord, Show) - -setImportedName :: ImportedName' a a -> a -> ImportedName' a a -setImportedName (ImportedName x) y = ImportedName y -setImportedName (ImportedModule x) y = ImportedModule y - --- -- Defined in Concrete.Pretty --- instance (Pretty n, Pretty m) => Pretty (ImportedName' n m) where --- pretty (ImportedModule x) = "module" <+> pretty x --- pretty (ImportedName x) = pretty x - --- instance (Show n, Show m) => Show (ImportedName' n m) where --- show (ImportedModule x) = "module " ++ show x --- show (ImportedName x) = show x - -data Renaming' n m = Renaming - { renFrom :: ImportedName' n m - -- ^ Rename from this name. - , renTo :: ImportedName' n m - -- ^ To this one. Must be same kind as 'renFrom'. - , renToRange :: Range - -- ^ The range of the \"to\" keyword. Retained for highlighting purposes. - } - deriving (Data, Eq) - --- ** HasRange instances - -instance (HasRange a, HasRange b) => HasRange (ImportDirective' a b) where - getRange = importDirRange - -instance (HasRange a, HasRange b) => HasRange (Using' a b) where - getRange (Using xs) = getRange xs - getRange UseEverything = noRange - -instance (HasRange a, HasRange b) => HasRange (Renaming' a b) where - getRange r = getRange (renFrom r, renTo r) - -instance (HasRange a, HasRange b) => HasRange (ImportedName' a b) where - getRange (ImportedName x) = getRange x - getRange (ImportedModule x) = getRange x - --- ** KillRange instances - -instance (KillRange a, KillRange b) => KillRange (ImportDirective' a b) where - killRange (ImportDirective _ u h r p) = - killRange3 (\u h r -> ImportDirective noRange u h r p) u h r - -instance (KillRange a, KillRange b) => KillRange (Using' a b) where - killRange (Using i) = killRange1 Using i - killRange UseEverything = UseEverything - -instance (KillRange a, KillRange b) => KillRange (Renaming' a b) where - killRange (Renaming i n _) = killRange2 (\i n -> Renaming i n noRange) i n - -instance (KillRange a, KillRange b) => KillRange (ImportedName' a b) where - killRange (ImportedModule n) = killRange1 ImportedModule n - killRange (ImportedName n) = killRange1 ImportedName n - --- ** NFData instances - --- | Ranges are not forced. - -instance (NFData a, NFData b) => NFData (ImportDirective' a b) where - rnf (ImportDirective _ a b c _) = rnf a `seq` rnf b `seq` rnf c - -instance (NFData a, NFData b) => NFData (Using' a b) where - rnf UseEverything = () - rnf (Using a) = rnf a - --- | Ranges are not forced. - -instance (NFData a, NFData b) => NFData (Renaming' a b) where - rnf (Renaming a b _) = rnf a `seq` rnf b - -instance (NFData a, NFData b) => NFData (ImportedName' a b) where - rnf (ImportedModule a) = rnf a - rnf (ImportedName a) = rnf a - ------------------------------------------------------------------------------ --- * Termination ------------------------------------------------------------------------------ - --- | Termination check? (Default = TerminationCheck). -data TerminationCheck m - = TerminationCheck - -- ^ Run the termination checker. - | NoTerminationCheck - -- ^ Skip termination checking (unsafe). - | NonTerminating - -- ^ Treat as non-terminating. - | Terminating - -- ^ Treat as terminating (unsafe). Same effect as 'NoTerminationCheck'. - | TerminationMeasure Range m - -- ^ Skip termination checking but use measure instead. - deriving (Data, Show, Eq, Functor) - -instance KillRange m => KillRange (TerminationCheck m) where - killRange (TerminationMeasure _ m) = TerminationMeasure noRange (killRange m) - killRange t = t - -instance NFData a => NFData (TerminationCheck a) where - rnf TerminationCheck = () - rnf NoTerminationCheck = () - rnf NonTerminating = () - rnf Terminating = () - rnf (TerminationMeasure _ a) = rnf a - ------------------------------------------------------------------------------ --- * Positivity ------------------------------------------------------------------------------ - --- | Positivity check? (Default = True). -type PositivityCheck = Bool - ------------------------------------------------------------------------------ --- * Universe checking ------------------------------------------------------------------------------ - --- | Universe check? (Default is yes). -data UniverseCheck = YesUniverseCheck | NoUniverseCheck - deriving (Eq, Ord, Show, Bounded, Enum, Data) - -instance KillRange UniverseCheck where - killRange = id +{-# LANGUAGE TypeFamilies #-} -- for type equality ~ +{-# LANGUAGE UndecidableInstances #-} -- for functional dependency: LensNamed name (Arg a) + +{-| Some common syntactic entities are defined in this module. +-} +module Agda.Syntax.Common where + +import Prelude hiding (null) + +import Control.DeepSeq +import Control.Arrow ((&&&)) + +#if __GLASGOW_HASKELL__ < 804 +import Data.Semigroup hiding (Arg) +#endif +import Data.ByteString.Char8 (ByteString) +import qualified Data.ByteString.Char8 as ByteString +import Data.Foldable (Foldable) +import qualified Data.Foldable as Fold +import Data.Function +import Data.Hashable (Hashable(..)) +import qualified Data.Strict.Maybe as Strict +import Data.Data (Data) +import Data.Word +import Data.IntSet (IntSet) +import qualified Data.IntSet as IntSet + +import GHC.Generics (Generic) + +import Agda.Syntax.Position + +import Agda.Utils.Functor +import Agda.Utils.Lens +import Agda.Utils.Maybe +import Agda.Utils.Null +import Agda.Utils.PartialOrd +import Agda.Utils.POMonoid +import Agda.Utils.Pretty + +import Agda.Utils.Impossible + +type Nat = Int +type Arity = Nat + +--------------------------------------------------------------------------- +-- * Delayed +--------------------------------------------------------------------------- + +-- | Used to specify whether something should be delayed. +data Delayed = Delayed | NotDelayed + deriving (Data, Show, Eq, Ord) + +instance KillRange Delayed where + killRange = id + +--------------------------------------------------------------------------- +-- * File +--------------------------------------------------------------------------- + +data FileType = AgdaFileType | MdFileType | RstFileType | TexFileType | OrgFileType + deriving (Data, Eq, Ord, Show) + +instance Pretty FileType where + pretty = \case + AgdaFileType -> "Agda" + MdFileType -> "Markdown" + RstFileType -> "ReStructedText" + TexFileType -> "LaTeX" + OrgFileType -> "org-mode" + +--------------------------------------------------------------------------- +-- * Eta-equality +--------------------------------------------------------------------------- + +data HasEta = NoEta | YesEta + deriving (Data, Show, Eq, Ord) + +instance HasRange HasEta where + getRange _ = noRange + +instance KillRange HasEta where + killRange = id + +instance NFData HasEta where + rnf NoEta = () + rnf YesEta = () + +--------------------------------------------------------------------------- +-- * Induction +--------------------------------------------------------------------------- + +data Induction = Inductive | CoInductive + deriving (Data, Eq, Ord, Show) + +instance Pretty Induction where + pretty Inductive = "inductive" + pretty CoInductive = "coinductive" + +instance HasRange Induction where + getRange _ = noRange + +instance KillRange Induction where + killRange = id + +instance NFData Induction where + rnf Inductive = () + rnf CoInductive = () + +--------------------------------------------------------------------------- +-- * Hiding +--------------------------------------------------------------------------- + +data Overlappable = YesOverlap | NoOverlap + deriving (Data, Show, Eq, Ord) + +data Hiding = Hidden | Instance Overlappable | NotHidden + deriving (Data, Show, Eq, Ord) + +instance Pretty Hiding where + pretty = \case + Hidden -> "hidden" + NotHidden -> "visible" + Instance{} -> "instance" + +-- | Just for the 'Hiding' instance. Should never combine different +-- overlapping. +instance Semigroup Overlappable where + NoOverlap <> NoOverlap = NoOverlap + YesOverlap <> YesOverlap = YesOverlap + _ <> _ = __IMPOSSIBLE__ + +-- | 'Hiding' is an idempotent partial monoid, with unit 'NotHidden'. +-- 'Instance' and 'NotHidden' are incompatible. +instance Semigroup Hiding where + NotHidden <> h = h + h <> NotHidden = h + Hidden <> Hidden = Hidden + Instance o <> Instance o' = Instance (o <> o') + _ <> _ = __IMPOSSIBLE__ + +instance Monoid Overlappable where + mempty = NoOverlap + mappend = (<>) + +instance Monoid Hiding where + mempty = NotHidden + mappend = (<>) + +instance KillRange Hiding where + killRange = id + +instance NFData Overlappable where + rnf NoOverlap = () + rnf YesOverlap = () + +instance NFData Hiding where + rnf Hidden = () + rnf (Instance o) = rnf o + rnf NotHidden = () + +-- | Decorating something with 'Hiding' information. +data WithHiding a = WithHiding + { whHiding :: !Hiding + , whThing :: a + } + deriving (Data, Eq, Ord, Show, Functor, Foldable, Traversable) + +instance Decoration WithHiding where + traverseF f (WithHiding h a) = WithHiding h <$> f a + +instance Applicative WithHiding where + pure = WithHiding mempty + WithHiding h f <*> WithHiding h' a = WithHiding (mappend h h') (f a) + +instance HasRange a => HasRange (WithHiding a) where + getRange = getRange . dget + +instance SetRange a => SetRange (WithHiding a) where + setRange = fmap . setRange + +instance KillRange a => KillRange (WithHiding a) where + killRange = fmap killRange + +instance NFData a => NFData (WithHiding a) where + rnf (WithHiding _ a) = rnf a + +-- | A lens to access the 'Hiding' attribute in data structures. +-- Minimal implementation: @getHiding@ and @mapHiding@ or @LensArgInfo@. +class LensHiding a where + + getHiding :: a -> Hiding + + setHiding :: Hiding -> a -> a + setHiding h = mapHiding (const h) + + mapHiding :: (Hiding -> Hiding) -> a -> a + + default getHiding :: LensArgInfo a => a -> Hiding + getHiding = argInfoHiding . getArgInfo + + default mapHiding :: LensArgInfo a => (Hiding -> Hiding) -> a -> a + mapHiding f = mapArgInfo $ \ ai -> ai { argInfoHiding = f $ argInfoHiding ai } + +instance LensHiding Hiding where + getHiding = id + setHiding = const + mapHiding = id + +instance LensHiding (WithHiding a) where + getHiding (WithHiding h _) = h + setHiding h (WithHiding _ a) = WithHiding h a + mapHiding f (WithHiding h a) = WithHiding (f h) a + +-- | Monoidal composition of 'Hiding' information in some data. +mergeHiding :: LensHiding a => WithHiding a -> a +mergeHiding (WithHiding h a) = mapHiding (mappend h) a + +-- | 'NotHidden' arguments are @visible@. +visible :: LensHiding a => a -> Bool +visible a = getHiding a == NotHidden + +-- | 'Instance' and 'Hidden' arguments are @notVisible@. +notVisible :: LensHiding a => a -> Bool +notVisible a = getHiding a /= NotHidden + +-- | 'Hidden' arguments are @hidden@. +hidden :: LensHiding a => a -> Bool +hidden a = getHiding a == Hidden + +hide :: LensHiding a => a -> a +hide = setHiding Hidden + +hideOrKeepInstance :: LensHiding a => a -> a +hideOrKeepInstance x = + case getHiding x of + Hidden -> x + Instance{} -> x + NotHidden -> setHiding Hidden x + +makeInstance :: LensHiding a => a -> a +makeInstance = makeInstance' NoOverlap + +makeInstance' :: LensHiding a => Overlappable -> a -> a +makeInstance' o = setHiding (Instance o) + +isOverlappable :: LensHiding a => a -> Bool +isOverlappable x = + case getHiding x of + Instance YesOverlap -> True + _ -> False + +isInstance :: LensHiding a => a -> Bool +isInstance x = + case getHiding x of + Instance{} -> True + _ -> False + +-- | Ignores 'Overlappable'. +sameHiding :: (LensHiding a, LensHiding b) => a -> b -> Bool +sameHiding x y = + case (getHiding x, getHiding y) of + (Instance{}, Instance{}) -> True + (hx, hy) -> hx == hy + +--------------------------------------------------------------------------- +-- * Modalities +--------------------------------------------------------------------------- + +-- | We have a tuple of modalities, which might not be fully orthogonal. +-- For instance, irrelevant stuff is also run-time irrelevant. +data Modality = Modality + { modRelevance :: Relevance + -- ^ Legacy irrelevance. + -- See Pfenning, LiCS 2001; Abel/Vezzosi/Winterhalter, ICFP 2017. + , modQuantity :: Quantity + -- ^ Cardinality / runtime erasure. + -- See Conor McBride, I got plenty o' nutting, Wadlerfest 2016. + -- See Bob Atkey, Syntax and Semantics of Quantitative Type Theory, LiCS 2018. + , modCohesion :: Cohesion + -- ^ Cohesion/what was in Agda-flat. + -- see "Brouwer's fixed-point theorem in real-cohesive homotopy type theory" (arXiv:1509.07584) + -- Currently only the comonad is implemented. + } deriving (Data, Eq, Ord, Show, Generic) + +defaultModality :: Modality +defaultModality = Modality defaultRelevance defaultQuantity defaultCohesion + +-- | Pointwise composition. +instance Semigroup Modality where + Modality r q c <> Modality r' q' c' = Modality (r <> r') (q <> q') (c <> c') + +-- | Pointwise unit. +instance Monoid Modality where + mempty = Modality mempty mempty mempty + mappend = (<>) + +-- | Dominance ordering. +instance PartialOrd Modality where + comparable (Modality r q c) (Modality r' q' c') = comparable (r, (q, c)) (r', (q', c')) + +instance POSemigroup Modality where +instance POMonoid Modality where + +instance LeftClosedPOMonoid Modality where + inverseCompose = inverseComposeModality + +-- | @m `moreUsableModality` m'@ means that an @m@ can be used +-- where ever an @m'@ is required. + +moreUsableModality :: Modality -> Modality -> Bool +moreUsableModality m m' = related m POLE m' + +usableModality :: LensModality a => a -> Bool +usableModality a = usableRelevance m && usableQuantity m + where m = getModality a + +-- | Multiplicative monoid (standard monoid). +composeModality :: Modality -> Modality -> Modality +composeModality = (<>) + +-- | Compose with modality flag from the left. +-- This function is e.g. used to update the modality information +-- on pattern variables @a@ after a match against something of modality @q@. +applyModality :: LensModality a => Modality -> a -> a +applyModality m = mapModality (m `composeModality`) + +-- | @inverseComposeModality r x@ returns the least modality @y@ +-- such that forall @x@, @y@ we have +-- @x \`moreUsableModality\` (r \`composeModality\` y)@ +-- iff +-- @(r \`inverseComposeModality\` x) \`moreUsableModality\` y@ (Galois connection). +inverseComposeModality :: Modality -> Modality -> Modality +inverseComposeModality (Modality r q c) (Modality r' q' c') = + Modality (r `inverseComposeRelevance` r') + (q `inverseComposeQuantity` q') + (c `inverseComposeCohesion` c') + +-- | Left division by a 'Modality'. +-- Used e.g. to modify context when going into a @m@ argument. +inverseApplyModality :: LensModality a => Modality -> a -> a +inverseApplyModality m = mapModality (m `inverseComposeModality`) + +-- | 'Modality' forms a pointwise additive monoid. +addModality :: Modality -> Modality -> Modality +addModality (Modality r q c) (Modality r' q' c') = Modality (addRelevance r r') (addQuantity q q') (addCohesion c c') + +zeroModality :: Modality +zeroModality = Modality zeroRelevance zeroQuantity zeroCohesion + +-- | Absorptive element under addition. +topModality :: Modality +topModality = Modality topRelevance topQuantity topCohesion + +-- | Equality ignoring origin. + +sameModality :: (LensModality a, LensModality b) => a -> b -> Bool +sameModality x y = case (getModality x , getModality y) of + (Modality r q c , Modality r' q' c') -> sameRelevance r r' && sameQuantity q q' && sameCohesion c c' + +-- boilerplate instances + +instance KillRange Modality where + killRange = id + +instance NFData Modality where + +-- Lens stuff + +lModRelevance :: Lens' Relevance Modality +lModRelevance f m = f (modRelevance m) <&> \ r -> m { modRelevance = r } + +lModQuantity :: Lens' Quantity Modality +lModQuantity f m = f (modQuantity m) <&> \ q -> m { modQuantity = q } + +lModCohesion :: Lens' Cohesion Modality +lModCohesion f m = f (modCohesion m) <&> \ q -> m { modCohesion = q } + +class LensModality a where + + getModality :: a -> Modality + + setModality :: Modality -> a -> a + setModality = mapModality . const + + mapModality :: (Modality -> Modality) -> a -> a + + default getModality :: LensArgInfo a => a -> Modality + getModality = argInfoModality . getArgInfo + + default mapModality :: LensArgInfo a => (Modality -> Modality) -> a -> a + mapModality f = mapArgInfo $ \ ai -> ai { argInfoModality = f $ argInfoModality ai } + +instance LensModality Modality where + getModality = id + setModality = const + mapModality = id + +instance LensRelevance Modality where + getRelevance = modRelevance + setRelevance h m = m { modRelevance = h } + mapRelevance f m = m { modRelevance = f (modRelevance m) } + +instance LensQuantity Modality where + getQuantity = modQuantity + setQuantity h m = m { modQuantity = h } + mapQuantity f m = m { modQuantity = f (modQuantity m) } + +instance LensCohesion Modality where + getCohesion = modCohesion + setCohesion h m = m { modCohesion = h } + mapCohesion f m = m { modCohesion = f (modCohesion m) } + +-- default accessors for Relevance + +getRelevanceMod :: LensModality a => LensGet Relevance a +getRelevanceMod = getRelevance . getModality + +setRelevanceMod :: LensModality a => LensSet Relevance a +setRelevanceMod = mapModality . setRelevance + +mapRelevanceMod :: LensModality a => LensMap Relevance a +mapRelevanceMod = mapModality . mapRelevance + +-- default accessors for Quantity + +getQuantityMod :: LensModality a => LensGet Quantity a +getQuantityMod = getQuantity . getModality + +setQuantityMod :: LensModality a => LensSet Quantity a +setQuantityMod = mapModality . setQuantity + +mapQuantityMod :: LensModality a => LensMap Quantity a +mapQuantityMod = mapModality . mapQuantity + +-- default accessors for Cohesion + +getCohesionMod :: LensModality a => LensGet Cohesion a +getCohesionMod = getCohesion . getModality + +setCohesionMod :: LensModality a => LensSet Cohesion a +setCohesionMod = mapModality . setCohesion + +mapCohesionMod :: LensModality a => LensMap Cohesion a +mapCohesionMod = mapModality . mapCohesion + +--------------------------------------------------------------------------- +-- * Quantities +--------------------------------------------------------------------------- + +-- ** Quantity origin. + +-- | Origin of 'Quantity0'. +data Q0Origin + = Q0Inferred -- ^ User wrote nothing. + | Q0 Range -- ^ User wrote "@0". + | Q0Erased Range -- ^ User wrote "@erased". + deriving (Data, Show, Generic, Eq, Ord) + +-- | Origin of 'Quantity1'. +data Q1Origin + = Q1Inferred -- ^ User wrote nothing. + | Q1 Range -- ^ User wrote "@1". + | Q1Linear Range -- ^ User wrote "@linear". + deriving (Data, Show, Generic, Eq, Ord) + +-- | Origin of 'Quantityω'. +data QωOrigin + = QωInferred -- ^ User wrote nothing. + | Qω Range -- ^ User wrote "@ω". + | QωPlenty Range -- ^ User wrote "@plenty". + deriving (Data, Show, Generic, Eq, Ord) + +-- *** Instances for 'Q0Origin'. + +-- | Right-biased composition, because the left quantity +-- acts as context, and the right one as occurrence. +instance Semigroup Q0Origin where + (<>) = curry $ \case + (Q0Inferred, o) -> o + (o, Q0Inferred) -> o + (o, Q0 r) -> Q0 $ fuseRange o r + (o, Q0Erased r) -> Q0 $ fuseRange o r + +instance Monoid Q0Origin where + mempty = Q0Inferred + mappend = (<>) + +instance Null Q0Origin where + empty = mempty + +instance HasRange Q0Origin where + getRange = \case + Q0Inferred -> noRange + Q0 r -> r + Q0Erased r -> r + +instance SetRange Q0Origin where + setRange r = \case + Q0Inferred -> Q0Inferred + Q0 _ -> Q0 r + Q0Erased _ -> Q0Erased r + +instance KillRange Q0Origin where + killRange = \case + Q0Inferred -> Q0Inferred + Q0 _ -> Q0 noRange + Q0Erased _ -> Q0Erased noRange + +instance NFData Q0Origin where + rnf = \case + Q0Inferred -> () + Q0 _ -> () + Q0Erased _ -> () + +-- *** Instances for 'Q1Origin'. + +-- | Right-biased composition, because the left quantity +-- acts as context, and the right one as occurrence. +instance Semigroup Q1Origin where + (<>) = curry $ \case + (Q1Inferred, o) -> o + (o, Q1Inferred) -> o + (o, Q1 r) -> Q1 $ fuseRange o r + (o, Q1Linear r) -> Q1 $ fuseRange o r + +instance Monoid Q1Origin where + mempty = Q1Inferred + mappend = (<>) + +instance Null Q1Origin where + empty = mempty + +instance HasRange Q1Origin where + getRange = \case + Q1Inferred -> noRange + Q1 r -> r + Q1Linear r -> r + +instance SetRange Q1Origin where + setRange r = \case + Q1Inferred -> Q1Inferred + Q1 _ -> Q1 r + Q1Linear _ -> Q1Linear r + +instance KillRange Q1Origin where + killRange = \case + Q1Inferred -> Q1Inferred + Q1 _ -> Q1 noRange + Q1Linear _ -> Q1Linear noRange + +instance NFData Q1Origin where + rnf = \case + Q1Inferred -> () + Q1 _ -> () + Q1Linear _ -> () + +-- *** Instances for 'QωOrigin'. + +-- | Right-biased composition, because the left quantity +-- acts as context, and the right one as occurrence. +instance Semigroup QωOrigin where + (<>) = curry $ \case + (QωInferred, o) -> o + (o, QωInferred) -> o + (o, Qω r) -> Qω $ fuseRange o r + (o, QωPlenty r) -> Qω $ fuseRange o r + +instance Monoid QωOrigin where + mempty = QωInferred + mappend = (<>) + +instance Null QωOrigin where + empty = mempty + +instance HasRange QωOrigin where + getRange = \case + QωInferred -> noRange + Qω r -> r + QωPlenty r -> r + +instance SetRange QωOrigin where + setRange r = \case + QωInferred -> QωInferred + Qω _ -> Qω r + QωPlenty _ -> QωPlenty r + +instance KillRange QωOrigin where + killRange = \case + QωInferred -> QωInferred + Qω _ -> Qω noRange + QωPlenty _ -> QωPlenty noRange + +instance NFData QωOrigin where + rnf = \case + QωInferred -> () + Qω _ -> () + QωPlenty _ -> () + +-- ** Quantity. + +-- | Quantity for linearity. +-- +-- A quantity is a set of natural numbers, indicating possible semantic +-- uses of a variable. A singleton set @{n}@ requires that the +-- corresponding variable is used exactly @n@ times. +-- +data Quantity + = Quantity0 Q0Origin -- ^ Zero uses @{0}@, erased at runtime. + | Quantity1 Q1Origin -- ^ Linear use @{1}@ (could be updated destructively). + -- Mostly TODO (needs postponable constraints between quantities to compute uses). + | Quantityω QωOrigin -- ^ Unrestricted use @ℕ@. + deriving (Data, Show, Generic, Eq, Ord) + -- @Ord@ instance in case @Quantity@ is used in keys for maps etc. + +defaultQuantity :: Quantity +defaultQuantity = topQuantity + +-- | Equality ignoring origin. + +sameQuantity :: Quantity -> Quantity -> Bool +sameQuantity = curry $ \case + (Quantity0{}, Quantity0{}) -> True + (Quantity1{}, Quantity1{}) -> True + (Quantityω{}, Quantityω{}) -> True + _ -> False + +-- | Composition of quantities (multiplication). +-- +-- 'Quantity0' is dominant. +-- 'Quantity1' is neutral. +-- +-- Right-biased for origin. +-- +instance Semigroup Quantity where + Quantity1{} <> q = q -- right-bias! + q <> Quantity1{} = q + _ <> Quantity0 o = Quantity0 o -- right-bias! + Quantity0 o <> _ = Quantity0 o + _omega <> qomega = qomega -- right-bias! + +-- | In the absense of finite quantities besides 0, ω is the unit. +-- Otherwise, 1 is the unit. +instance Monoid Quantity where + mempty = Quantity1 mempty + mappend = (<>) + +-- | Note that the order is @ω ≤ 0,1@, more options is smaller. +instance PartialOrd Quantity where + comparable = curry $ \case + (q, q') | sameQuantity q q' -> POEQ + -- ω is least + (Quantityω{}, _) -> POLT + (_, Quantityω{}) -> POGT + -- others are uncomparable + _ -> POAny + +instance POSemigroup Quantity where +instance POMonoid Quantity where + +instance LeftClosedPOMonoid Quantity where + inverseCompose = inverseComposeQuantity + +-- | 'Quantity' forms an additive monoid with zero Quantity0. +addQuantity :: Quantity -> Quantity -> Quantity +addQuantity = curry $ \case + -- ω is absorptive + (q@Quantityω{}, _) -> q + (_, q@Quantityω{}) -> q + -- 0 is neutral + (Quantity0{}, q) -> q + (q, Quantity0{}) -> q + -- 1 + 1 = ω + (Quantity1 _, Quantity1 _) -> topQuantity + +zeroQuantity :: Quantity +zeroQuantity = Quantity0 mempty + +-- | Absorptive element is ω. +topQuantity :: Quantity +topQuantity = Quantityω mempty + +-- | @m `moreUsableQuantity` m'@ means that an @m@ can be used +-- where ever an @m'@ is required. + +moreQuantity :: Quantity -> Quantity -> Bool +moreQuantity m m' = related m POLE m' + +composeQuantity :: Quantity -> Quantity -> Quantity +composeQuantity = (<>) + +-- | Compose with quantity flag from the left. +-- This function is e.g. used to update the quantity information +-- on pattern variables @a@ after a match against something of quantity @q@. + +applyQuantity :: LensQuantity a => Quantity -> a -> a +applyQuantity q = mapQuantity (q `composeQuantity`) + +-- | @inverseComposeQuantity r x@ returns the least quantity @y@ +-- such that forall @x@, @y@ we have +-- @x \`moreQuantity\` (r \`composeQuantity\` y)@ +-- iff +-- @(r \`inverseComposeQuantity\` x) \`moreQuantity\` y@ (Galois connection). + +inverseComposeQuantity :: Quantity -> Quantity -> Quantity +inverseComposeQuantity = curry $ \case + (Quantity1{} , x) -> x -- going to linear arg: nothing changes + (Quantity0{} , x) -> topQuantity -- going to erased arg: every thing usable + (Quantityω{} , x@Quantityω{}) -> x + (Quantityω{} , _) -> zeroQuantity -- linear resources are unusable as arguments to unrestricted functions + +-- | Left division by a 'Quantity'. +-- Used e.g. to modify context when going into a @q@ argument. + +inverseApplyQuantity :: LensQuantity a => Quantity -> a -> a +inverseApplyQuantity q = mapQuantity (q `inverseComposeQuantity`) + +-- | Check for 'Quantity0'. + +hasQuantity0 :: LensQuantity a => a -> Bool +hasQuantity0 a + | Quantity0{} <- getQuantity a = True + | otherwise = False + +-- | Check for 'Quantity1'. + +hasQuantity1 :: LensQuantity a => a -> Bool +hasQuantity1 a + | Quantity1{} <- getQuantity a = True + | otherwise = False + +-- | Check for 'Quantityω'. + +hasQuantityω :: LensQuantity a => a -> Bool +hasQuantityω a + | Quantityω{} <- getQuantity a = True + | otherwise = False + +-- | Did the user supply a quantity annotation? + +noUserQuantity :: LensQuantity a => a -> Bool +noUserQuantity a = case getQuantity a of + Quantity0 o -> null o + Quantity1 o -> null o + Quantityω o -> null o + +-- | A thing of quantity 0 is unusable, all others are usable. + +usableQuantity :: LensQuantity a => a -> Bool +usableQuantity = not . hasQuantity0 + +-- boilerplate instances + +class LensQuantity a where + + getQuantity :: a -> Quantity + + setQuantity :: Quantity -> a -> a + setQuantity = mapQuantity . const + + mapQuantity :: (Quantity -> Quantity) -> a -> a + + default getQuantity :: LensModality a => a -> Quantity + getQuantity = modQuantity . getModality + + default mapQuantity :: LensModality a => (Quantity -> Quantity) -> a -> a + mapQuantity f = mapModality $ \ ai -> ai { modQuantity = f $ modQuantity ai } + +instance LensQuantity Quantity where + getQuantity = id + setQuantity = const + mapQuantity = id + +instance HasRange Quantity where + getRange = \case + Quantity0 o -> getRange o + Quantity1 o -> getRange o + Quantityω o -> getRange o + +instance SetRange Quantity where + setRange r = \case + Quantity0 o -> Quantity0 $ setRange r o + Quantity1 o -> Quantity1 $ setRange r o + Quantityω o -> Quantityω $ setRange r o + +instance KillRange Quantity where + killRange = \case + Quantity0 o -> Quantity0 $ killRange o + Quantity1 o -> Quantity1 $ killRange o + Quantityω o -> Quantityω $ killRange o + +instance NFData Quantity where + rnf (Quantity0 o) = rnf o + rnf (Quantity1 o) = rnf o + rnf (Quantityω o) = rnf o + +--------------------------------------------------------------------------- +-- * Relevance +--------------------------------------------------------------------------- + +-- | A function argument can be relevant or irrelevant. +-- See "Agda.TypeChecking.Irrelevance". +data Relevance + = Relevant -- ^ The argument is (possibly) relevant at compile-time. + | NonStrict -- ^ The argument may never flow into evaluation position. + -- Therefore, it is irrelevant at run-time. + -- It is treated relevantly during equality checking. + | Irrelevant -- ^ The argument is irrelevant at compile- and runtime. + deriving (Data, Show, Eq, Enum, Bounded, Generic) + +allRelevances :: [Relevance] +allRelevances = [minBound..maxBound] + +defaultRelevance :: Relevance +defaultRelevance = Relevant + +instance HasRange Relevance where + getRange _ = noRange + +instance SetRange Relevance where + setRange _ = id + +instance KillRange Relevance where + killRange rel = rel -- no range to kill + +instance NFData Relevance where + rnf Relevant = () + rnf NonStrict = () + rnf Irrelevant = () + +-- | A lens to access the 'Relevance' attribute in data structures. +-- Minimal implementation: @getRelevance@ and @mapRelevance@ or @LensModality@. +class LensRelevance a where + + getRelevance :: a -> Relevance + + setRelevance :: Relevance -> a -> a + setRelevance h = mapRelevance (const h) + + mapRelevance :: (Relevance -> Relevance) -> a -> a + + default getRelevance :: LensModality a => a -> Relevance + getRelevance = modRelevance . getModality + + default mapRelevance :: LensModality a => (Relevance -> Relevance) -> a -> a + mapRelevance f = mapModality $ \ ai -> ai { modRelevance = f $ modRelevance ai } + +instance LensRelevance Relevance where + getRelevance = id + setRelevance = const + mapRelevance = id + +isRelevant :: LensRelevance a => a -> Bool +isRelevant a = getRelevance a == Relevant + +isIrrelevant :: LensRelevance a => a -> Bool +isIrrelevant a = getRelevance a == Irrelevant + +isNonStrict :: LensRelevance a => a -> Bool +isNonStrict a = getRelevance a == NonStrict + +-- | Information ordering. +-- @Relevant \`moreRelevant\` +-- NonStrict \`moreRelevant\` +-- Irrelevant@ +moreRelevant :: Relevance -> Relevance -> Bool +moreRelevant = (<=) + +-- | Equality ignoring origin. +sameRelevance :: Relevance -> Relevance -> Bool +sameRelevance = (==) + +-- | More relevant is smaller. +instance Ord Relevance where + compare = curry $ \case + (r, r') | r == r' -> EQ + -- top + (_, Irrelevant) -> LT + (Irrelevant, _) -> GT + -- bottom + (Relevant, _) -> LT + (_, Relevant) -> GT + -- redundant case + (NonStrict,NonStrict) -> EQ + +-- | More relevant is smaller. +instance PartialOrd Relevance where + comparable = comparableOrd + +-- | @usableRelevance rel == False@ iff we cannot use a variable of @rel@. +usableRelevance :: LensRelevance a => a -> Bool +usableRelevance a = case getRelevance a of + Irrelevant -> False + NonStrict -> False + Relevant -> True + +-- | 'Relevance' composition. +-- 'Irrelevant' is dominant, 'Relevant' is neutral. +-- Composition coincides with 'max'. +composeRelevance :: Relevance -> Relevance -> Relevance +composeRelevance r r' = + case (r, r') of + (Irrelevant, _) -> Irrelevant + (_, Irrelevant) -> Irrelevant + (NonStrict, _) -> NonStrict + (_, NonStrict) -> NonStrict + (Relevant, Relevant) -> Relevant + +-- | Compose with relevance flag from the left. +-- This function is e.g. used to update the relevance information +-- on pattern variables @a@ after a match against something @rel@. +applyRelevance :: LensRelevance a => Relevance -> a -> a +applyRelevance rel = mapRelevance (rel `composeRelevance`) + +-- | @inverseComposeRelevance r x@ returns the most irrelevant @y@ +-- such that forall @x@, @y@ we have +-- @x \`moreRelevant\` (r \`composeRelevance\` y)@ +-- iff +-- @(r \`inverseComposeRelevance\` x) \`moreRelevant\` y@ (Galois connection). +inverseComposeRelevance :: Relevance -> Relevance -> Relevance +inverseComposeRelevance r x = + case (r, x) of + (Relevant , x) -> x -- going to relevant arg.: nothing changes + -- because Relevant is comp.-neutral + (Irrelevant, x) -> Relevant -- going irrelevant: every thing usable + (NonStrict , Irrelevant) -> Irrelevant -- otherwise: irrelevant things remain unusable + (NonStrict , _) -> Relevant -- but @NonStrict@s become usable + +-- | Left division by a 'Relevance'. +-- Used e.g. to modify context when going into a @rel@ argument. +inverseApplyRelevance :: LensRelevance a => Relevance -> a -> a +inverseApplyRelevance rel = mapRelevance (rel `inverseComposeRelevance`) + +-- | 'Relevance' forms a semigroup under composition. +instance Semigroup Relevance where + (<>) = composeRelevance + +-- | 'Relevant' is the unit. +instance Monoid Relevance where + mempty = Relevant + mappend = (<>) + +instance POSemigroup Relevance where +instance POMonoid Relevance where + +instance LeftClosedPOMonoid Relevance where + inverseCompose = inverseComposeRelevance + +-- | Combine inferred 'Relevance'. +-- The unit is 'Irrelevant'. +addRelevance :: Relevance -> Relevance -> Relevance +addRelevance = min + +-- | 'Relevance' forms a monoid under addition, and even a semiring. +zeroRelevance :: Relevance +zeroRelevance = Irrelevant + +-- | Absorptive element under addition. +topRelevance :: Relevance +topRelevance = Relevant + +-- | Irrelevant function arguments may appear non-strictly in the codomain type. +irrToNonStrict :: Relevance -> Relevance +irrToNonStrict Irrelevant = NonStrict +irrToNonStrict rel = rel + +-- | Applied when working on types (unless --experimental-irrelevance). +nonStrictToRel :: Relevance -> Relevance +nonStrictToRel NonStrict = Relevant +nonStrictToRel rel = rel + +nonStrictToIrr :: Relevance -> Relevance +nonStrictToIrr NonStrict = Irrelevant +nonStrictToIrr rel = rel + +--------------------------------------------------------------------------- +-- * Cohesion +--------------------------------------------------------------------------- + +-- | Cohesion modalities +-- see "Brouwer's fixed-point theorem in real-cohesive homotopy type theory" (arXiv:1509.07584) +-- types are now given an additional topological layer which the modalities interact with. +data Cohesion + = Flat -- ^ same points, discrete topology, idempotent comonad, box-like. + | Continuous -- ^ identity modality. + -- | Sharp -- ^ same points, codiscrete topology, idempotent monad, diamond-like. + | Squash -- ^ single point space, artificially added for Flat left-composition. + deriving (Data, Show, Eq, Enum, Bounded, Generic) + +allCohesions :: [Cohesion] +allCohesions = [minBound..maxBound] + +defaultCohesion :: Cohesion +defaultCohesion = Continuous + +instance HasRange Cohesion where + getRange _ = noRange + +instance SetRange Cohesion where + setRange _ = id + +instance KillRange Cohesion where + killRange rel = rel -- no range to kill + +instance NFData Cohesion where + rnf Flat = () + rnf Continuous = () + rnf Squash = () + +-- | A lens to access the 'Cohesion' attribute in data structures. +-- Minimal implementation: @getCohesion@ and @mapCohesion@ or @LensModality@. +class LensCohesion a where + + getCohesion :: a -> Cohesion + + setCohesion :: Cohesion -> a -> a + setCohesion h = mapCohesion (const h) + + mapCohesion :: (Cohesion -> Cohesion) -> a -> a + + default getCohesion :: LensModality a => a -> Cohesion + getCohesion = modCohesion . getModality + + default mapCohesion :: LensModality a => (Cohesion -> Cohesion) -> a -> a + mapCohesion f = mapModality $ \ ai -> ai { modCohesion = f $ modCohesion ai } + +instance LensCohesion Cohesion where + getCohesion = id + setCohesion = const + mapCohesion = id + +-- | Information ordering. +-- @Flat \`moreCohesion\` +-- Continuous \`moreCohesion\` +-- Sharp \`moreCohesion\` +-- Squash@ +moreCohesion :: Cohesion -> Cohesion -> Bool +moreCohesion = (<=) + +-- | Equality ignoring origin. +sameCohesion :: Cohesion -> Cohesion -> Bool +sameCohesion = (==) + +-- | Order is given by implication: flatter is smaller. +instance Ord Cohesion where + compare = curry $ \case + (r, r') | r == r' -> EQ + -- top + (_, Squash) -> LT + (Squash, _) -> GT + -- bottom + (Flat, _) -> LT + (_, Flat) -> GT + -- redundant case + (Continuous,Continuous) -> EQ + +-- | Flatter is smaller. +instance PartialOrd Cohesion where + comparable = comparableOrd + +-- | @usableCohesion rel == False@ iff we cannot use a variable of @rel@. +usableCohesion :: LensCohesion a => a -> Bool +usableCohesion a = getCohesion a `moreCohesion` Continuous + +-- | 'Cohesion' composition. +-- 'Squash' is dominant, 'Continuous' is neutral. +composeCohesion :: Cohesion -> Cohesion -> Cohesion +composeCohesion r r' = + case (r, r') of + (Squash, _) -> Squash + (_, Squash) -> Squash + (Flat, _) -> Flat + (_, Flat) -> Flat + (Continuous, Continuous) -> Continuous + +-- | Compose with cohesion flag from the left. +-- This function is e.g. used to update the cohesion information +-- on pattern variables @a@ after a match against something of cohesion @rel@. +applyCohesion :: LensCohesion a => Cohesion -> a -> a +applyCohesion rel = mapCohesion (rel `composeCohesion`) + +-- | @inverseComposeCohesion r x@ returns the least @y@ +-- such that forall @x@, @y@ we have +-- @x \`moreCohesion\` (r \`composeCohesion\` y)@ +-- iff +-- @(r \`inverseComposeCohesion\` x) \`moreCohesion\` y@ (Galois connection). +-- The above law fails for @r = Squash@. +inverseComposeCohesion :: Cohesion -> Cohesion -> Cohesion +inverseComposeCohesion r x = + case (r, x) of + (Continuous , x) -> x -- going to continous arg.: nothing changes + -- because Continuous is comp.-neutral + (Squash, x) -> Squash -- artificial case, should not be needed. + (Flat , Flat) -> Flat -- otherwise: Flat things remain Flat + (Flat , _) -> Squash -- but everything else becomes unusable. + +-- | Left division by a 'Cohesion'. +-- Used e.g. to modify context when going into a @rel@ argument. +inverseApplyCohesion :: LensCohesion a => Cohesion -> a -> a +inverseApplyCohesion rel = mapCohesion (rel `inverseComposeCohesion`) + +-- | 'Cohesion' forms a semigroup under composition. +instance Semigroup Cohesion where + (<>) = composeCohesion + +-- | 'Continous' is the unit. +instance Monoid Cohesion where + mempty = Continuous + mappend = (<>) + +instance POSemigroup Cohesion where +instance POMonoid Cohesion where + +instance LeftClosedPOMonoid Cohesion where + inverseCompose = inverseComposeCohesion + +-- | Combine inferred 'Cohesion'. +-- The unit is 'Squash'. +addCohesion :: Cohesion -> Cohesion -> Cohesion +addCohesion = min + +-- | 'Cohesion' forms a monoid under addition, and even a semiring. +zeroCohesion :: Cohesion +zeroCohesion = Squash + +-- | Absorptive element under addition. +topCohesion :: Cohesion +topCohesion = Flat + +--------------------------------------------------------------------------- +-- * Origin of arguments (user-written, inserted or reflected) +--------------------------------------------------------------------------- + +-- | Origin of arguments. +data Origin + = UserWritten -- ^ From the source file / user input. (Preserve!) + | Inserted -- ^ E.g. inserted hidden arguments. + | Reflected -- ^ Produced by the reflection machinery. + | CaseSplit -- ^ Produced by an interactive case split. + | Substitution -- ^ Named application produced to represent a substitution. E.g. "?0 (x = n)" instead of "?0 n" + deriving (Data, Show, Eq, Ord) + +instance KillRange Origin where + killRange = id + +instance NFData Origin where + rnf UserWritten = () + rnf Inserted = () + rnf Reflected = () + rnf CaseSplit = () + rnf Substitution = () + +-- | Decorating something with 'Origin' information. +data WithOrigin a = WithOrigin + { woOrigin :: !Origin + , woThing :: a + } + deriving (Data, Eq, Ord, Show, Functor, Foldable, Traversable) + +instance Decoration WithOrigin where + traverseF f (WithOrigin h a) = WithOrigin h <$> f a + +instance Pretty a => Pretty (WithOrigin a) where + prettyPrec p = prettyPrec p . woThing + +instance HasRange a => HasRange (WithOrigin a) where + getRange = getRange . dget + +instance SetRange a => SetRange (WithOrigin a) where + setRange = fmap . setRange + +instance KillRange a => KillRange (WithOrigin a) where + killRange = fmap killRange + +instance NFData a => NFData (WithOrigin a) where + rnf (WithOrigin _ a) = rnf a + +-- | A lens to access the 'Origin' attribute in data structures. +-- Minimal implementation: @getOrigin@ and @mapOrigin@ or @LensArgInfo@. + +class LensOrigin a where + + getOrigin :: a -> Origin + + setOrigin :: Origin -> a -> a + setOrigin o = mapOrigin (const o) + + mapOrigin :: (Origin -> Origin) -> a -> a + + default getOrigin :: LensArgInfo a => a -> Origin + getOrigin = argInfoOrigin . getArgInfo + + default mapOrigin :: LensArgInfo a => (Origin -> Origin) -> a -> a + mapOrigin f = mapArgInfo $ \ ai -> ai { argInfoOrigin = f $ argInfoOrigin ai } + +instance LensOrigin Origin where + getOrigin = id + setOrigin = const + mapOrigin = id + +instance LensOrigin (WithOrigin a) where + getOrigin (WithOrigin h _) = h + setOrigin h (WithOrigin _ a) = WithOrigin h a + mapOrigin f (WithOrigin h a) = WithOrigin (f h) a + +----------------------------------------------------------------------------- +-- * Free variable annotations +----------------------------------------------------------------------------- + +data FreeVariables = UnknownFVs | KnownFVs IntSet + deriving (Data, Eq, Ord, Show) + +instance Semigroup FreeVariables where + UnknownFVs <> _ = UnknownFVs + _ <> UnknownFVs = UnknownFVs + KnownFVs vs1 <> KnownFVs vs2 = KnownFVs (IntSet.union vs1 vs2) + +instance Monoid FreeVariables where + mempty = KnownFVs IntSet.empty + mappend = (<>) + +instance NFData FreeVariables where + rnf UnknownFVs = () + rnf (KnownFVs fv) = rnf fv + +unknownFreeVariables :: FreeVariables +unknownFreeVariables = UnknownFVs + +noFreeVariables :: FreeVariables +noFreeVariables = mempty + +oneFreeVariable :: Int -> FreeVariables +oneFreeVariable = KnownFVs . IntSet.singleton + +freeVariablesFromList :: [Int] -> FreeVariables +freeVariablesFromList = mconcat . map oneFreeVariable + +-- | A lens to access the 'FreeVariables' attribute in data structures. +-- Minimal implementation: @getFreeVariables@ and @mapFreeVariables@ or @LensArgInfo@. +class LensFreeVariables a where + + getFreeVariables :: a -> FreeVariables + + setFreeVariables :: FreeVariables -> a -> a + setFreeVariables o = mapFreeVariables (const o) + + mapFreeVariables :: (FreeVariables -> FreeVariables) -> a -> a + + default getFreeVariables :: LensArgInfo a => a -> FreeVariables + getFreeVariables = argInfoFreeVariables . getArgInfo + + default mapFreeVariables :: LensArgInfo a => (FreeVariables -> FreeVariables) -> a -> a + mapFreeVariables f = mapArgInfo $ \ ai -> ai { argInfoFreeVariables = f $ argInfoFreeVariables ai } + +instance LensFreeVariables FreeVariables where + getFreeVariables = id + setFreeVariables = const + mapFreeVariables = id + +hasNoFreeVariables :: LensFreeVariables a => a -> Bool +hasNoFreeVariables x = + case getFreeVariables x of + UnknownFVs -> False + KnownFVs fv -> IntSet.null fv + +--------------------------------------------------------------------------- +-- * Argument decoration +--------------------------------------------------------------------------- + +-- | A function argument can be hidden and/or irrelevant. + +data ArgInfo = ArgInfo + { argInfoHiding :: Hiding + , argInfoModality :: Modality + , argInfoOrigin :: Origin + , argInfoFreeVariables :: FreeVariables + } deriving (Data, Eq, Ord, Show) + +instance KillRange ArgInfo where + killRange i = i -- There are no ranges in ArgInfo's + +class LensArgInfo a where + getArgInfo :: a -> ArgInfo + setArgInfo :: ArgInfo -> a -> a + setArgInfo ai = mapArgInfo (const ai) + mapArgInfo :: (ArgInfo -> ArgInfo) -> a -> a + mapArgInfo f a = setArgInfo (f $ getArgInfo a) a + +instance LensArgInfo ArgInfo where + getArgInfo = id + setArgInfo = const + mapArgInfo = id + +instance NFData ArgInfo where + rnf (ArgInfo a b c d) = rnf a `seq` rnf b `seq` rnf c `seq` rnf d + +instance LensHiding ArgInfo where + getHiding = argInfoHiding + setHiding h ai = ai { argInfoHiding = h } + mapHiding f ai = ai { argInfoHiding = f (argInfoHiding ai) } + +instance LensModality ArgInfo where + getModality = argInfoModality + setModality m ai = ai { argInfoModality = m } + mapModality f ai = ai { argInfoModality = f (argInfoModality ai) } + +instance LensOrigin ArgInfo where + getOrigin = argInfoOrigin + setOrigin o ai = ai { argInfoOrigin = o } + mapOrigin f ai = ai { argInfoOrigin = f (argInfoOrigin ai) } + +instance LensFreeVariables ArgInfo where + getFreeVariables = argInfoFreeVariables + setFreeVariables o ai = ai { argInfoFreeVariables = o } + mapFreeVariables f ai = ai { argInfoFreeVariables = f (argInfoFreeVariables ai) } + +-- inherited instances + +instance LensRelevance ArgInfo where + getRelevance = getRelevanceMod + setRelevance = setRelevanceMod + mapRelevance = mapRelevanceMod + +instance LensQuantity ArgInfo where + getQuantity = getQuantityMod + setQuantity = setQuantityMod + mapQuantity = mapQuantityMod + +instance LensCohesion ArgInfo where + getCohesion = getCohesionMod + setCohesion = setCohesionMod + mapCohesion = mapCohesionMod + +defaultArgInfo :: ArgInfo +defaultArgInfo = ArgInfo + { argInfoHiding = NotHidden + , argInfoModality = defaultModality + , argInfoOrigin = UserWritten + , argInfoFreeVariables = UnknownFVs + } + +-- Accessing through ArgInfo + +-- default accessors for Hiding + +getHidingArgInfo :: LensArgInfo a => LensGet Hiding a +getHidingArgInfo = getHiding . getArgInfo + +setHidingArgInfo :: LensArgInfo a => LensSet Hiding a +setHidingArgInfo = mapArgInfo . setHiding + +mapHidingArgInfo :: LensArgInfo a => LensMap Hiding a +mapHidingArgInfo = mapArgInfo . mapHiding + +-- default accessors for Modality + +getModalityArgInfo :: LensArgInfo a => LensGet Modality a +getModalityArgInfo = getModality . getArgInfo + +setModalityArgInfo :: LensArgInfo a => LensSet Modality a +setModalityArgInfo = mapArgInfo . setModality + +mapModalityArgInfo :: LensArgInfo a => LensMap Modality a +mapModalityArgInfo = mapArgInfo . mapModality + +-- default accessors for Origin + +getOriginArgInfo :: LensArgInfo a => LensGet Origin a +getOriginArgInfo = getOrigin . getArgInfo + +setOriginArgInfo :: LensArgInfo a => LensSet Origin a +setOriginArgInfo = mapArgInfo . setOrigin + +mapOriginArgInfo :: LensArgInfo a => LensMap Origin a +mapOriginArgInfo = mapArgInfo . mapOrigin + +-- default accessors for FreeVariables + +getFreeVariablesArgInfo :: LensArgInfo a => LensGet FreeVariables a +getFreeVariablesArgInfo = getFreeVariables . getArgInfo + +setFreeVariablesArgInfo :: LensArgInfo a => LensSet FreeVariables a +setFreeVariablesArgInfo = mapArgInfo . setFreeVariables + +mapFreeVariablesArgInfo :: LensArgInfo a => LensMap FreeVariables a +mapFreeVariablesArgInfo = mapArgInfo . mapFreeVariables + +-- inserted hidden arguments + +isInsertedHidden :: (LensHiding a, LensOrigin a) => a -> Bool +isInsertedHidden a = getHiding a == Hidden && getOrigin a == Inserted + +--------------------------------------------------------------------------- +-- * Arguments +--------------------------------------------------------------------------- + +data Arg e = Arg + { argInfo :: ArgInfo + , unArg :: e + } deriving (Data, Eq, Ord, Show, Functor, Foldable, Traversable) + +instance Decoration Arg where + traverseF f (Arg ai a) = Arg ai <$> f a + +instance HasRange a => HasRange (Arg a) where + getRange = getRange . unArg + +instance SetRange a => SetRange (Arg a) where + setRange r = fmap $ setRange r + +instance KillRange a => KillRange (Arg a) where + killRange (Arg info a) = killRange2 Arg info a + +-- Andreas, 2019-07-05, issue #3889 +-- A dedicated equality for with-abstraction now exists, +-- thus, we can use intensional equality for Arg. +-- +-- -- | Ignores 'Quantity', 'Relevance', 'Origin', and 'FreeVariables'. +-- -- Ignores content of argument if 'Irrelevant'. +-- -- +-- instance Eq a => Eq (Arg a) where +-- Arg (ArgInfo h1 m1 _ _) x1 == Arg (ArgInfo h2 m2 _ _) x2 = +-- h1 == h2 && (isIrrelevant m1 || isIrrelevant m2 || x1 == x2) +-- -- Andreas, 2017-10-04, issue #2775, ignore irrelevant arguments during with-abstraction. +-- -- This is a hack, we should not use '(==)' in with-abstraction +-- -- and more generally not use it on Syntax. +-- -- Andrea: except for caching. + +-- instance Show a => Show (Arg a) where +-- show (Arg (ArgInfo h (Modality r q) o fv) a) = showFVs fv $ showQ q $ showR r $ showO o $ showH h $ show a +-- where +-- showH Hidden s = "{" ++ s ++ "}" +-- showH NotHidden s = "(" ++ s ++ ")" +-- showH (Instance o) s = showOv o ++ "{{" ++ s ++ "}}" +-- where showOv YesOverlap = "overlap " +-- showOv NoOverlap = "" +-- showR r s = case r of +-- Irrelevant -> "." ++ s +-- NonStrict -> "?" ++ s +-- Relevant -> "r" ++ s -- Andreas: I want to see it explicitly +-- showQ q s = case q of +-- Quantity0 -> "0" ++ s +-- Quantity1 -> "1" ++ s +-- Quantityω -> "ω" ++ s +-- showO o s = case o of +-- UserWritten -> "u" ++ s +-- Inserted -> "i" ++ s +-- Reflected -> "g" ++ s -- generated by reflection +-- CaseSplit -> "c" ++ s -- generated by case split +-- Substitution -> "s" ++ s +-- showFVs UnknownFVs s = s +-- showFVs (KnownFVs fv) s = "fv" ++ show (IntSet.toList fv) ++ s + +-- -- defined in Concrete.Pretty +-- instance Pretty a => Pretty (Arg a) where +-- pretty (Arg (ArgInfo h (Modality r q) o fv) a) = prettyFVs fv $ prettyQ q $ prettyR r $ prettyO o $ prettyH h $ pretty a +-- where +-- prettyH Hidden s = "{" <> s <> "}" +-- prettyH NotHidden s = "(" <> s <> ")" +-- prettyH (Instance o) s = prettyOv o <> "{{" <> s <> "}}" +-- where prettyOv YesOverlap = "overlap " +-- prettyOv NoOverlap = "" +-- prettyR r s = case r of +-- Irrelevant -> "." <> s +-- NonStrict -> "?" <> s +-- Relevant -> "r" <> s -- Andreas: I want to see it explicitly +-- prettyQ q s = case q of +-- Quantity0 -> "0" <> s +-- Quantity1 -> "1" <> s +-- Quantityω -> "ω" <> s +-- prettyO o s = case o of +-- UserWritten -> "u" <> s +-- Inserted -> "i" <> s +-- Reflected -> "g" <> s -- generated by reflection +-- CaseSplit -> "c" <> s -- generated by case split +-- Substitution -> "s" <> s +-- prettyFVs UnknownFVs s = s +-- prettyFVs (KnownFVs fv) s = "fv" <> pretty (IntSet.toList fv) <> s + +instance NFData e => NFData (Arg e) where + rnf (Arg a b) = rnf a `seq` rnf b + +instance LensArgInfo (Arg a) where + getArgInfo = argInfo + setArgInfo ai arg = arg { argInfo = ai } + mapArgInfo f arg = arg { argInfo = f $ argInfo arg } + +-- The other lenses are defined through LensArgInfo + +instance LensHiding (Arg e) where + getHiding = getHidingArgInfo + setHiding = setHidingArgInfo + mapHiding = mapHidingArgInfo + +instance LensModality (Arg e) where + getModality = getModalityArgInfo + setModality = setModalityArgInfo + mapModality = mapModalityArgInfo + +instance LensOrigin (Arg e) where + getOrigin = getOriginArgInfo + setOrigin = setOriginArgInfo + mapOrigin = mapOriginArgInfo + +instance LensFreeVariables (Arg e) where + getFreeVariables = getFreeVariablesArgInfo + setFreeVariables = setFreeVariablesArgInfo + mapFreeVariables = mapFreeVariablesArgInfo + +-- Since we have LensModality, we get relevance and quantity by default + +instance LensRelevance (Arg e) where + getRelevance = getRelevanceMod + setRelevance = setRelevanceMod + mapRelevance = mapRelevanceMod + +instance LensQuantity (Arg e) where + getQuantity = getQuantityMod + setQuantity = setQuantityMod + mapQuantity = mapQuantityMod + +instance LensCohesion (Arg e) where + getCohesion = getCohesionMod + setCohesion = setCohesionMod + mapCohesion = mapCohesionMod + +defaultArg :: a -> Arg a +defaultArg = Arg defaultArgInfo + +-- | @xs \`withArgsFrom\` args@ translates @xs@ into a list of 'Arg's, +-- using the elements in @args@ to fill in the non-'unArg' fields. +-- +-- Precondition: The two lists should have equal length. + +withArgsFrom :: [a] -> [Arg b] -> [Arg a] +xs `withArgsFrom` args = + zipWith (\x arg -> fmap (const x) arg) xs args + +withNamedArgsFrom :: [a] -> [NamedArg b] -> [NamedArg a] +xs `withNamedArgsFrom` args = + zipWith (\x -> fmap (x <$)) xs args + +--------------------------------------------------------------------------- +-- * Names +--------------------------------------------------------------------------- + +class Eq a => Underscore a where + underscore :: a + isUnderscore :: a -> Bool + isUnderscore = (== underscore) + +instance Underscore String where + underscore = "_" + +instance Underscore ByteString where + underscore = ByteString.pack underscore + +instance Underscore Doc where + underscore = text underscore + +--------------------------------------------------------------------------- +-- * Named arguments +--------------------------------------------------------------------------- + +-- | Something potentially carrying a name. +data Named name a = + Named { nameOf :: Maybe name + , namedThing :: a + } + deriving (Eq, Ord, Show, Data, Functor, Foldable, Traversable) + +-- | Standard naming. +type Named_ = Named NamedName + +-- | Standard argument names. +type NamedName = WithOrigin (Ranged ArgName) + +-- | Equality of argument names of things modulo 'Range' and 'Origin'. +sameName :: NamedName -> NamedName -> Bool +sameName = (==) `on` (rangedThing . woThing) + +unnamed :: a -> Named name a +unnamed = Named Nothing + +named :: name -> a -> Named name a +named = Named . Just + +userNamed :: Ranged ArgName -> a -> Named_ a +userNamed = Named . Just . WithOrigin UserWritten + +-- | Accessor/editor for the 'nameOf' component. +class LensNamed name a | a -> name where + lensNamed :: Lens' (Maybe name) a + + -- Lenses lift through decorations: + default lensNamed :: (Decoration f, LensNamed name b, f b ~ a) => Lens' (Maybe name) a + lensNamed = traverseF . lensNamed + +instance LensNamed name a => LensNamed name (Arg a) where + +instance LensNamed name (Maybe name) where + lensNamed = id + +instance LensNamed name (Named name a) where + lensNamed f (Named mn a) = f mn <&> \ mn' -> Named mn' a + +getNameOf :: LensNamed name a => a -> Maybe name +getNameOf a = a ^. lensNamed + +setNameOf :: LensNamed name a => Maybe name -> a -> a +setNameOf = set lensNamed + +mapNameOf :: LensNamed name a => (Maybe name -> Maybe name) -> a -> a +mapNameOf = over lensNamed + +bareNameOf :: LensNamed NamedName a => a -> Maybe ArgName +bareNameOf a = rangedThing . woThing <$> getNameOf a + +bareNameWithDefault :: LensNamed NamedName a => ArgName -> a -> ArgName +bareNameWithDefault x a = maybe x (rangedThing . woThing) $ getNameOf a + +-- | Equality of argument names of things modulo 'Range' and 'Origin'. +namedSame :: (LensNamed NamedName a, LensNamed NamedName b) => a -> b -> Bool +namedSame a b = case (getNameOf a, getNameOf b) of + (Nothing, Nothing) -> True + (Just x , Just y ) -> sameName x y + _ -> False + +-- | Does an argument @arg@ fit the shape @dom@ of the next expected argument? +-- +-- The hiding has to match, and if the argument has a name, it should match +-- the name of the domain. +-- +-- 'Nothing' should be '__IMPOSSIBLE__', so use as +-- @@ +-- fromMaybe __IMPOSSIBLE__ $ fittingNamedArg arg dom +-- @@ +-- +fittingNamedArg + :: ( LensNamed NamedName arg, LensHiding arg + , LensNamed NamedName dom, LensHiding dom ) + => arg -> dom -> Maybe Bool +fittingNamedArg arg dom + | not $ sameHiding arg dom = no + | visible arg = yes + | otherwise = + caseMaybe (bareNameOf arg) yes $ \ x -> + caseMaybe (bareNameOf dom) impossible $ \ y -> + return $ x == y + where + yes = return True + no = return False + impossible = Nothing + +-- Standard instances for 'Named': + +instance Decoration (Named name) where + traverseF f (Named n a) = Named n <$> f a + +instance HasRange a => HasRange (Named name a) where + getRange = getRange . namedThing + +instance SetRange a => SetRange (Named name a) where + setRange r = fmap $ setRange r + +instance (KillRange name, KillRange a) => KillRange (Named name a) where + killRange (Named n a) = Named (killRange n) (killRange a) + +-- instance Show a => Show (Named_ a) where +-- show (Named Nothing a) = show a +-- show (Named (Just n) a) = rawNameToString (rangedThing n) ++ " = " ++ show a + +-- -- Defined in Concrete.Pretty +-- instance Pretty a => Pretty (Named_ a) where +-- pretty (Named Nothing a) = pretty a +-- pretty (Named (Just n) a) = text (rawNameToString (rangedThing n)) <+> "=" <+> pretty a + +instance (NFData name, NFData a) => NFData (Named name a) where + rnf (Named a b) = rnf a `seq` rnf b + +-- | Only 'Hidden' arguments can have names. +type NamedArg a = Arg (Named_ a) + +-- | Get the content of a 'NamedArg'. +namedArg :: NamedArg a -> a +namedArg = namedThing . unArg + +defaultNamedArg :: a -> NamedArg a +defaultNamedArg = unnamedArg defaultArgInfo + +unnamedArg :: ArgInfo -> a -> NamedArg a +unnamedArg info = Arg info . unnamed + +-- | The functor instance for 'NamedArg' would be ambiguous, +-- so we give it another name here. +updateNamedArg :: (a -> b) -> NamedArg a -> NamedArg b +updateNamedArg = fmap . fmap + +updateNamedArgA :: Applicative f => (a -> f b) -> NamedArg a -> f (NamedArg b) +updateNamedArgA = traverse . traverse + +-- | @setNamedArg a b = updateNamedArg (const b) a@ +setNamedArg :: NamedArg a -> b -> NamedArg b +setNamedArg a b = (b <$) <$> a + +-- ** ArgName + +-- | Names in binders and arguments. +type ArgName = String + +argNameToString :: ArgName -> String +argNameToString = id + +stringToArgName :: String -> ArgName +stringToArgName = id + +appendArgNames :: ArgName -> ArgName -> ArgName +appendArgNames = (++) + +--------------------------------------------------------------------------- +-- * Range decoration. +--------------------------------------------------------------------------- + +-- | Thing with range info. +data Ranged a = Ranged + { rangeOf :: Range + , rangedThing :: a + } + deriving (Data, Show, Functor, Foldable, Traversable) + +-- | Thing with no range info. +unranged :: a -> Ranged a +unranged = Ranged noRange + +instance Pretty a => Pretty (Ranged a) where + pretty = pretty . rangedThing + +-- instance Show a => Show (Ranged a) where +-- show = show . rangedThing + +instance Eq a => Eq (Ranged a) where + Ranged _ x == Ranged _ y = x == y + +instance Ord a => Ord (Ranged a) where + compare (Ranged _ x) (Ranged _ y) = compare x y + +instance HasRange (Ranged a) where + getRange = rangeOf + +instance KillRange (Ranged a) where + killRange (Ranged _ x) = Ranged noRange x + +instance Decoration Ranged where + traverseF f (Ranged r x) = Ranged r <$> f x + +-- | Ranges are not forced. + +instance NFData a => NFData (Ranged a) where + rnf (Ranged _ a) = rnf a + +--------------------------------------------------------------------------- +-- * Raw names (before parsing into name parts). +--------------------------------------------------------------------------- + +-- | A @RawName@ is some sort of string. +type RawName = String + +rawNameToString :: RawName -> String +rawNameToString = id + +stringToRawName :: String -> RawName +stringToRawName = id + +-- | String with range info. +type RString = Ranged RawName + +--------------------------------------------------------------------------- +-- * Further constructor and projection info +--------------------------------------------------------------------------- + +-- | Where does the 'ConP' or 'Con' come from? +data ConOrigin + = ConOSystem -- ^ Inserted by system or expanded from an implicit pattern. + | ConOCon -- ^ User wrote a constructor (pattern). + | ConORec -- ^ User wrote a record (pattern). + | ConOSplit -- ^ Generated by interactive case splitting. + deriving (Data, Show, Eq, Ord, Enum, Bounded) + +instance KillRange ConOrigin where + killRange = id + +-- | Prefer user-written over system-inserted. +bestConInfo :: ConOrigin -> ConOrigin -> ConOrigin +bestConInfo ConOSystem o = o +bestConInfo o _ = o + +-- | Where does a projection come from? +data ProjOrigin + = ProjPrefix -- ^ User wrote a prefix projection. + | ProjPostfix -- ^ User wrote a postfix projection. + | ProjSystem -- ^ Projection was generated by the system. + deriving (Data, Show, Eq, Ord, Enum, Bounded) + +instance KillRange ProjOrigin where + killRange = id + +data DataOrRecord = IsData | IsRecord + deriving (Data, Eq, Ord, Show) + +--------------------------------------------------------------------------- +-- * Infixity, access, abstract, etc. +--------------------------------------------------------------------------- + +-- | Functions can be defined in both infix and prefix style. See +-- 'Agda.Syntax.Concrete.LHS'. +data IsInfix = InfixDef | PrefixDef + deriving (Data, Show, Eq, Ord) + +-- ** private blocks, public imports + +-- | Access modifier. +data Access + = PrivateAccess Origin + -- ^ Store the 'Origin' of the private block that lead to this qualifier. + -- This is needed for more faithful printing of declarations. + | PublicAccess + deriving (Data, Show, Eq, Ord) + +instance Pretty Access where + pretty = text . \case + PrivateAccess _ -> "private" + PublicAccess -> "public" + +instance NFData Access where + rnf _ = () + +instance HasRange Access where + getRange _ = noRange + +instance KillRange Access where + killRange = id + +-- ** abstract blocks + +-- | Abstract or concrete. +data IsAbstract = AbstractDef | ConcreteDef + deriving (Data, Show, Eq, Ord) + +-- | Semigroup computes if any of several is an 'AbstractDef'. +instance Semigroup IsAbstract where + AbstractDef <> _ = AbstractDef + ConcreteDef <> a = a + +-- | Default is 'ConcreteDef'. +instance Monoid IsAbstract where + mempty = ConcreteDef + mappend = (<>) + +instance KillRange IsAbstract where + killRange = id + +class LensIsAbstract a where + lensIsAbstract :: Lens' IsAbstract a + +instance LensIsAbstract IsAbstract where + lensIsAbstract = id + +-- | Is any element of a collection an 'AbstractDef'. +class AnyIsAbstract a where + anyIsAbstract :: a -> IsAbstract + + default anyIsAbstract :: (Foldable t, AnyIsAbstract b, t b ~ a) => a -> IsAbstract + anyIsAbstract = Fold.foldMap anyIsAbstract + +instance AnyIsAbstract IsAbstract where + anyIsAbstract = id + +instance AnyIsAbstract a => AnyIsAbstract [a] where +instance AnyIsAbstract a => AnyIsAbstract (Maybe a) where + +-- ** instance blocks + +-- | Is this definition eligible for instance search? +data IsInstance + = InstanceDef Range -- ^ Range of the @instance@ keyword. + | NotInstanceDef + deriving (Data, Show, Eq, Ord) + +instance KillRange IsInstance where + killRange = \case + InstanceDef _ -> InstanceDef noRange + i@NotInstanceDef -> i + +instance HasRange IsInstance where + getRange = \case + InstanceDef r -> r + NotInstanceDef -> noRange + +instance NFData IsInstance where + rnf (InstanceDef _) = () + rnf NotInstanceDef = () + +-- ** macro blocks + +-- | Is this a macro definition? +data IsMacro = MacroDef | NotMacroDef + deriving (Data, Show, Eq, Ord) + +instance KillRange IsMacro where killRange = id +instance HasRange IsMacro where getRange _ = noRange + +--------------------------------------------------------------------------- +-- * NameId +--------------------------------------------------------------------------- + +-- | The unique identifier of a name. Second argument is the top-level module +-- identifier. +data NameId = NameId {-# UNPACK #-} !Word64 {-# UNPACK #-} !Word64 + deriving (Eq, Ord, Data, Generic, Show) + +instance KillRange NameId where + killRange = id + +instance Pretty NameId where + pretty (NameId n m) = text $ show n ++ "@" ++ show m + +instance Enum NameId where + succ (NameId n m) = NameId (n + 1) m + pred (NameId n m) = NameId (n - 1) m + toEnum n = __IMPOSSIBLE__ -- should not be used + fromEnum (NameId n _) = fromIntegral n + +instance NFData NameId where + rnf (NameId _ _) = () + +instance Hashable NameId where + {-# INLINE hashWithSalt #-} + hashWithSalt salt (NameId n m) = hashWithSalt salt (n, m) + +--------------------------------------------------------------------------- +-- * Meta variables +--------------------------------------------------------------------------- + +-- | A meta variable identifier is just a natural number. +-- +newtype MetaId = MetaId { metaId :: Nat } + deriving (Eq, Ord, Num, Real, Enum, Integral, Data, Generic) + +instance Pretty MetaId where + pretty (MetaId n) = text $ "_" ++ show n + +-- | Show non-record version of this newtype. +instance Show MetaId where + showsPrec p (MetaId n) = showParen (p > 0) $ + showString "MetaId " . shows n + +instance NFData MetaId where + rnf (MetaId x) = rnf x + +instance Hashable MetaId + +newtype Constr a = Constr a + +------------------------------------------------------------------------ +-- * Placeholders (used to parse sections) +------------------------------------------------------------------------ + +-- | The position of a name part or underscore in a name. + +data PositionInName + = Beginning + -- ^ The following underscore is at the beginning of the name: + -- @_foo@. + | Middle + -- ^ The following underscore is in the middle of the name: + -- @foo_bar@. + | End + -- ^ The following underscore is at the end of the name: @foo_@. + deriving (Show, Eq, Ord, Data) + +-- | Placeholders are used to represent the underscores in a section. + +data MaybePlaceholder e + = Placeholder !PositionInName + | NoPlaceholder !(Strict.Maybe PositionInName) e + -- ^ The second argument is used only (but not always) for name + -- parts other than underscores. + deriving (Data, Eq, Ord, Functor, Foldable, Traversable, Show) + +-- | An abbreviation: @noPlaceholder = 'NoPlaceholder' +-- 'Strict.Nothing'@. + +noPlaceholder :: e -> MaybePlaceholder e +noPlaceholder = NoPlaceholder Strict.Nothing + +instance HasRange a => HasRange (MaybePlaceholder a) where + getRange Placeholder{} = noRange + getRange (NoPlaceholder _ e) = getRange e + +instance KillRange a => KillRange (MaybePlaceholder a) where + killRange p@Placeholder{} = p + killRange (NoPlaceholder p e) = killRange1 (NoPlaceholder p) e + +instance NFData a => NFData (MaybePlaceholder a) where + rnf (Placeholder _) = () + rnf (NoPlaceholder _ a) = rnf a + +--------------------------------------------------------------------------- +-- * Interaction meta variables +--------------------------------------------------------------------------- + +newtype InteractionId = InteractionId { interactionId :: Nat } + deriving ( Eq + , Ord + , Show + , Num + , Integral + , Real + , Enum + , Data + ) + +instance Pretty InteractionId where + pretty (InteractionId i) = text $ "?" ++ show i + +instance KillRange InteractionId where killRange = id + +--------------------------------------------------------------------------- +-- * Fixity +--------------------------------------------------------------------------- + +-- | Precedence levels for operators. + +type PrecedenceLevel = Double + +data FixityLevel + = Unrelated + -- ^ No fixity declared. + | Related !PrecedenceLevel + -- ^ Fixity level declared as the number. + deriving (Eq, Ord, Show, Data) + +instance Null FixityLevel where + null Unrelated = True + null Related{} = False + empty = Unrelated + +-- | Associativity. + +data Associativity = NonAssoc | LeftAssoc | RightAssoc + deriving (Eq, Ord, Show, Data) + +-- | Fixity of operators. + +data Fixity = Fixity + { fixityRange :: Range + -- ^ Range of the whole fixity declaration. + , fixityLevel :: !FixityLevel + , fixityAssoc :: !Associativity + } + deriving (Data, Show) + +noFixity :: Fixity +noFixity = Fixity noRange Unrelated NonAssoc + +defaultFixity :: Fixity +defaultFixity = Fixity noRange (Related 20) NonAssoc + +-- For @instance Pretty Fixity@, see Agda.Syntax.Concrete.Pretty + +instance Eq Fixity where + f1 == f2 = compare f1 f2 == EQ + +instance Ord Fixity where + compare = compare `on` (fixityLevel &&& fixityAssoc) + +instance Null Fixity where + null = null . fixityLevel + empty = noFixity + +instance HasRange Fixity where + getRange = fixityRange + +instance KillRange Fixity where + killRange f = f { fixityRange = noRange } + +instance NFData Fixity where + rnf (Fixity _ _ _) = () -- Ranges are not forced, the other fields are strict. + +-- * Notation coupled with 'Fixity' + +-- | The notation is handled as the fixity in the renamer. +-- Hence, they are grouped together in this type. +data Fixity' = Fixity' + { theFixity :: !Fixity + , theNotation :: Notation + , theNameRange :: Range + -- ^ Range of the name in the fixity declaration + -- (used for correct highlighting, see issue #2140). + } + deriving (Data, Show) + +noFixity' :: Fixity' +noFixity' = Fixity' noFixity noNotation noRange + +instance Eq Fixity' where + Fixity' f n _ == Fixity' f' n' _ = f == f' && n == n' + +instance Null Fixity' where + null (Fixity' f n _) = null f && null n + empty = noFixity' + +instance NFData Fixity' where + rnf (Fixity' _ a _) = rnf a + +instance KillRange Fixity' where + killRange (Fixity' f n r) = killRange3 Fixity' f n r + +-- lenses + +_fixityAssoc :: Lens' Associativity Fixity +_fixityAssoc f r = f (fixityAssoc r) <&> \x -> r { fixityAssoc = x } + +_fixityLevel :: Lens' FixityLevel Fixity +_fixityLevel f r = f (fixityLevel r) <&> \x -> r { fixityLevel = x } + +-- Lens focusing on Fixity + +class LensFixity a where + lensFixity :: Lens' Fixity a + +instance LensFixity Fixity where + lensFixity = id + +instance LensFixity Fixity' where + lensFixity f fix' = f (theFixity fix') <&> \ fx -> fix' { theFixity = fx } + +-- Lens focusing on Fixity' + +class LensFixity' a where + lensFixity' :: Lens' Fixity' a + +instance LensFixity' Fixity' where + lensFixity' = id +--------------------------------------------------------------------------- +-- * Import directive +--------------------------------------------------------------------------- + +-- | The things you are allowed to say when you shuffle names between name +-- spaces (i.e. in @import@, @namespace@, or @open@ declarations). +data ImportDirective' n m = ImportDirective + { importDirRange :: Range + , using :: Using' n m + , hiding :: [ImportedName' n m] + , impRenaming :: [Renaming' n m] + , publicOpen :: Maybe Range -- ^ Only for @open@. Exports the opened names from the current module. + } + deriving (Data, Eq) + +-- | @null@ for import directives holds when everything is imported unchanged +-- (no names are hidden or renamed). +instance Null (ImportDirective' n m) where + null = \case + ImportDirective _ UseEverything [] [] _ -> True + _ -> False + empty = defaultImportDir + +-- | Default is directive is @private@ (use everything, but do not export). +defaultImportDir :: ImportDirective' n m +defaultImportDir = ImportDirective noRange UseEverything [] [] Nothing + +-- | @isDefaultImportDir@ implies @null@, but not the other way round. +isDefaultImportDir :: ImportDirective' n m -> Bool +isDefaultImportDir dir = null dir && null (publicOpen dir) + +-- | The @using@ clause of import directive. +data Using' n m + = UseEverything -- ^ No @using@ clause given. + | Using [ImportedName' n m] -- ^ @using@ the specified names. + deriving (Data, Eq) + +instance Semigroup (Using' n m) where + UseEverything <> u = u + u <> UseEverything = u + Using xs <> Using ys = Using (xs ++ ys) + +instance Monoid (Using' n m) where + mempty = UseEverything + mappend = (<>) + +instance Null (Using' n m) where + null UseEverything = True + null Using{} = False + empty = mempty + +mapUsing :: ([ImportedName' n1 m1] -> [ImportedName' n2 m2]) -> Using' n1 m1 -> Using' n2 m2 +mapUsing f = \case + UseEverything -> UseEverything + Using xs -> Using $ f xs + +-- | An imported name can be a module or a defined name. +data ImportedName' n m + = ImportedModule m -- ^ Imported module name of type @m@. + | ImportedName n -- ^ Imported name of type @n@. + deriving (Data, Eq, Ord, Show) + +setImportedName :: ImportedName' a a -> a -> ImportedName' a a +setImportedName (ImportedName x) y = ImportedName y +setImportedName (ImportedModule x) y = ImportedModule y + +-- -- Defined in Concrete.Pretty +-- instance (Pretty n, Pretty m) => Pretty (ImportedName' n m) where +-- pretty (ImportedModule x) = "module" <+> pretty x +-- pretty (ImportedName x) = pretty x + +-- instance (Show n, Show m) => Show (ImportedName' n m) where +-- show (ImportedModule x) = "module " ++ show x +-- show (ImportedName x) = show x + +data Renaming' n m = Renaming + { renFrom :: ImportedName' n m + -- ^ Rename from this name. + , renTo :: ImportedName' n m + -- ^ To this one. Must be same kind as 'renFrom'. + , renFixity :: Maybe Fixity + -- ^ New fixity of 'renTo' (optional). + , renToRange :: Range + -- ^ The range of the \"to\" keyword. Retained for highlighting purposes. + } + deriving (Data, Eq) + +-- ** HasRange instances + +instance (HasRange a, HasRange b) => HasRange (ImportDirective' a b) where + getRange = importDirRange + +instance (HasRange a, HasRange b) => HasRange (Using' a b) where + getRange (Using xs) = getRange xs + getRange UseEverything = noRange + +instance (HasRange a, HasRange b) => HasRange (Renaming' a b) where + getRange r = getRange (renFrom r, renTo r) + +instance (HasRange a, HasRange b) => HasRange (ImportedName' a b) where + getRange (ImportedName x) = getRange x + getRange (ImportedModule x) = getRange x + +-- ** KillRange instances + +instance (KillRange a, KillRange b) => KillRange (ImportDirective' a b) where + killRange (ImportDirective _ u h r p) = + killRange3 (\u h r -> ImportDirective noRange u h r p) u h r + +instance (KillRange a, KillRange b) => KillRange (Using' a b) where + killRange (Using i) = killRange1 Using i + killRange UseEverything = UseEverything + +instance (KillRange a, KillRange b) => KillRange (Renaming' a b) where + killRange (Renaming i n mf _to) = killRange3 (\ i n mf -> Renaming i n mf noRange) i n mf + +instance (KillRange a, KillRange b) => KillRange (ImportedName' a b) where + killRange (ImportedModule n) = killRange1 ImportedModule n + killRange (ImportedName n) = killRange1 ImportedName n + +-- ** NFData instances + +-- | Ranges are not forced. + +instance (NFData a, NFData b) => NFData (ImportDirective' a b) where + rnf (ImportDirective _ a b c _) = rnf a `seq` rnf b `seq` rnf c + +instance (NFData a, NFData b) => NFData (Using' a b) where + rnf UseEverything = () + rnf (Using a) = rnf a + +-- | Ranges are not forced. + +instance (NFData a, NFData b) => NFData (Renaming' a b) where + rnf (Renaming a b c _) = rnf a `seq` rnf b `seq` rnf c + +instance (NFData a, NFData b) => NFData (ImportedName' a b) where + rnf (ImportedModule a) = rnf a + rnf (ImportedName a) = rnf a + +----------------------------------------------------------------------------- +-- * Termination +----------------------------------------------------------------------------- + +-- | Termination check? (Default = TerminationCheck). +data TerminationCheck m + = TerminationCheck + -- ^ Run the termination checker. + | NoTerminationCheck + -- ^ Skip termination checking (unsafe). + | NonTerminating + -- ^ Treat as non-terminating. + | Terminating + -- ^ Treat as terminating (unsafe). Same effect as 'NoTerminationCheck'. + | TerminationMeasure Range m + -- ^ Skip termination checking but use measure instead. + deriving (Data, Show, Eq, Functor) + +instance KillRange m => KillRange (TerminationCheck m) where + killRange (TerminationMeasure _ m) = TerminationMeasure noRange (killRange m) + killRange t = t + +instance NFData a => NFData (TerminationCheck a) where + rnf TerminationCheck = () + rnf NoTerminationCheck = () + rnf NonTerminating = () + rnf Terminating = () + rnf (TerminationMeasure _ a) = rnf a + +----------------------------------------------------------------------------- +-- * Positivity +----------------------------------------------------------------------------- + +-- | Positivity check? (Default = True). +data PositivityCheck = YesPositivityCheck | NoPositivityCheck + deriving (Eq, Ord, Show, Bounded, Enum, Data) + +instance KillRange PositivityCheck where + killRange = id + +-- Semigroup and Monoid via conjunction +instance Semigroup PositivityCheck where + NoPositivityCheck <> _ = NoPositivityCheck + _ <> NoPositivityCheck = NoPositivityCheck + _ <> _ = YesPositivityCheck + +instance Monoid PositivityCheck where + mempty = YesPositivityCheck + mappend = (<>) + +----------------------------------------------------------------------------- +-- * Universe checking +----------------------------------------------------------------------------- + +-- | Universe check? (Default is yes). +data UniverseCheck = YesUniverseCheck | NoUniverseCheck + deriving (Eq, Ord, Show, Bounded, Enum, Data) + +instance KillRange UniverseCheck where + killRange = id + +----------------------------------------------------------------------------- +-- * Universe checking +----------------------------------------------------------------------------- + +-- | Coverage check? (Default is yes). +data CoverageCheck = YesCoverageCheck | NoCoverageCheck + deriving (Eq, Ord, Show, Bounded, Enum, Data) + +instance KillRange CoverageCheck where + killRange = id + +-- Semigroup and Monoid via conjunction +instance Semigroup CoverageCheck where + NoCoverageCheck <> _ = NoCoverageCheck + _ <> NoCoverageCheck = NoCoverageCheck + _ <> _ = YesCoverageCheck + +instance Monoid CoverageCheck where + mempty = YesCoverageCheck + mappend = (<>) + +----------------------------------------------------------------------------- +-- * Rewrite Directives on the LHS +----------------------------------------------------------------------------- + +-- | @RewriteEqn' qn p e@ represents the @rewrite@ and irrefutable @with@ +-- clauses of the LHS. +-- @qn@ stands for the QName of the auxiliary function generated to implement the feature +-- @p@ is the type of patterns +-- @e@ is the type of expressions + +data RewriteEqn' qn p e + = Rewrite [(qn, e)] -- ^ @rewrite e@ + | Invert qn [(p, e)] -- ^ @with p <- e@ + deriving (Data, Eq, Show, Functor, Foldable, Traversable) + +instance (NFData qn, NFData p, NFData e) => NFData (RewriteEqn' qn p e) where + rnf = \case + Rewrite es -> rnf es + Invert qn pes -> rnf (qn, pes) + +instance (Pretty p, Pretty e) => Pretty (RewriteEqn' qn p e) where + pretty = \case + Rewrite es -> prefixedThings (text "rewrite") (pretty . snd <$> es) + Invert _ pes -> prefixedThings (text "invert") (pes <&> \ (p, e) -> pretty p <+> "<-" <+> pretty e) + +instance (HasRange qn, HasRange p, HasRange e) => HasRange (RewriteEqn' qn p e) where + getRange = \case + Rewrite es -> getRange es + Invert qn pes -> getRange (qn, pes) + +instance (KillRange qn, KillRange e, KillRange p) => KillRange (RewriteEqn' qn p e) where + killRange = \case + Rewrite es -> killRange1 Rewrite es + Invert qn pes -> killRange2 Invert qn pes + +----------------------------------------------------------------------------- +-- * Information on expanded ellipsis (@...@) +----------------------------------------------------------------------------- + +-- ^ When the ellipsis in a clause are expanded, we remember that we +-- did so. We also store the number of with-arguments that are +-- included in the expanded ellipsis. +data ExpandedEllipsis + = ExpandedEllipsis + { ellipsisRange :: Range + , ellipsisWithArgs :: Int + } + | NoEllipsis + deriving (Data, Show, Eq) + +instance Null ExpandedEllipsis where + null = (== NoEllipsis) + empty = NoEllipsis + +instance KillRange ExpandedEllipsis where + killRange (ExpandedEllipsis _ k) = ExpandedEllipsis noRange k + killRange NoEllipsis = NoEllipsis + +instance NFData ExpandedEllipsis where + rnf (ExpandedEllipsis _ a) = rnf a + rnf NoEllipsis = () + +-- | Notation as provided by the @syntax@ declaration. +type Notation = [GenPart] + +noNotation :: Notation +noNotation = [] + +-- | Part of a Notation +data GenPart + = BindHole Range (Ranged Int) + -- ^ Argument is the position of the hole (with binding) where the binding should occur. + -- First range is the rhs range and second is the binder. + | NormalHole Range (NamedArg (Ranged Int)) + -- ^ Argument is where the expression should go. + | WildHole (Ranged Int) + -- ^ An underscore in binding position. + | IdPart RString + deriving (Data, Show) + +instance Eq GenPart where + BindHole _ i == BindHole _ j = i == j + NormalHole _ x == NormalHole _ y = x == y + WildHole i == WildHole j = i == j + IdPart x == IdPart y = x == y + _ == _ = False + +instance Ord GenPart where + BindHole _ i `compare` BindHole _ j = i `compare` j + NormalHole _ x `compare` NormalHole _ y = x `compare` y + WildHole i `compare` WildHole j = i `compare` j + IdPart x `compare` IdPart y = x `compare` y + BindHole{} `compare` _ = LT + _ `compare` BindHole{} = GT + NormalHole{} `compare` _ = LT + _ `compare` NormalHole{} = GT + WildHole{} `compare` _ = LT + _ `compare` WildHole{} = GT + +instance HasRange GenPart where + getRange p = case p of + IdPart x -> getRange x + BindHole r _ -> r + WildHole i -> getRange i + NormalHole r _ -> r + +instance SetRange GenPart where + setRange r p = case p of + IdPart x -> IdPart x + BindHole _ i -> BindHole r i + WildHole i -> WildHole i + NormalHole _ i -> NormalHole r i + +instance KillRange GenPart where + killRange p = case p of + IdPart x -> IdPart $ killRange x + BindHole _ i -> BindHole noRange $ killRange i + WildHole i -> WildHole $ killRange i + NormalHole _ x -> NormalHole noRange $ killRange x + +instance NFData GenPart where + rnf (BindHole _ a) = rnf a + rnf (NormalHole _ a) = rnf a + rnf (WildHole a) = rnf a + rnf (IdPart a) = rnf a diff --git a/src/full/Agda/Syntax/Concrete.hs b/src/full/Agda/Syntax/Concrete.hs --- a/src/full/Agda/Syntax/Concrete.hs +++ b/src/full/Agda/Syntax/Concrete.hs @@ -1,9 +1,4 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE DeriveDataTypeable #-} -{-# LANGUAGE DeriveFunctor #-} -{-# LANGUAGE DeriveFoldable #-} -{-# LANGUAGE DeriveTraversable #-} -{-# LANGUAGE LambdaCase #-} {-| The concrete syntax is a raw representation of the program text without any desugaring at all. This is what the parser produces. @@ -17,7 +12,12 @@ , module Agda.Syntax.Concrete.Name , appView, AppView(..) , isSingleIdentifierP, removeSingletonRawAppP + , isPattern, isAbsurdP, isBinderP -- * Bindings + , Binder'(..) + , Binder + , mkBinder_ + , mkBinder , LamBinding , LamBinding'(..) , TypedBinding @@ -27,6 +27,7 @@ , FieldAssignment, FieldAssignment'(..), nameFieldA, exprFieldA , ModuleAssignment(..) , BoundName(..), mkBoundName_, mkBoundName + , TacticAttribute , Telescope -- (..) , countTelVars , lamBindingsToTelescope @@ -41,6 +42,7 @@ , AsName'(..), AsName , OpenShortHand(..), RewriteEqn, WithExpr , LHS(..), Pattern(..), LHSCore(..) + , observeHiding , LamClause(..) , RHS, RHS'(..), WhereClause, WhereClause'(..), ExprWhere(..) , DoStmt(..) @@ -57,10 +59,9 @@ import Control.DeepSeq import Data.Foldable (Foldable) -import Data.Traversable (Traversable) +import Data.Traversable (Traversable, forM, mapM) import Data.List hiding (null) import Data.Set (Set) -import Data.Monoid import Data.Data (Data) @@ -75,10 +76,10 @@ import Agda.TypeChecking.Positivity.Occurrence +import Agda.Utils.Either ( maybeLeft ) import Agda.Utils.Lens import Agda.Utils.Null -#include "undefined.h" import Agda.Utils.Impossible data OpApp e @@ -86,7 +87,7 @@ -- ^ An abstraction inside a special syntax declaration -- (see Issue 358 why we introduce this). | Ordinary e - deriving (Data, Functor, Foldable, Traversable) + deriving (Data, Functor, Foldable, Traversable, Eq) fromOrdinary :: e -> OpApp e -> e fromOrdinary d (Ordinary e) = e @@ -102,7 +103,8 @@ , _exprModA :: [Expr] , _importDirModA :: ImportDirective } - deriving Data + deriving (Data, Eq) + type RecordAssignment = Either FieldAssignment ModuleAssignment type RecordAssignments = [RecordAssignment] @@ -112,14 +114,15 @@ exprFieldA :: Lens' a (FieldAssignment' a) exprFieldA f r = f (_exprFieldA r) <&> \x -> r { _exprFieldA = x } -qnameModA :: Lens' QName ModuleAssignment -qnameModA f r = f (_qnameModA r) <&> \x -> r { _qnameModA = x } - -exprModA :: Lens' [Expr] ModuleAssignment -exprModA f r = f (_exprModA r) <&> \x -> r { _exprModA = x } - -importDirModA :: Lens' ImportDirective ModuleAssignment -importDirModA f r = f (_importDirModA r) <&> \x -> r { _importDirModA = x } +-- UNUSED Liang-Ting Chen 2019-07-16 +--qnameModA :: Lens' QName ModuleAssignment +--qnameModA f r = f (_qnameModA r) <&> \x -> r { _qnameModA = x } +-- +--exprModA :: Lens' [Expr] ModuleAssignment +--exprModA f r = f (_exprModA r) <&> \x -> r { _exprModA = x } +-- +--importDirModA :: Lens' ImportDirective ModuleAssignment +--importDirModA f r = f (_importDirModA r) <&> \x -> r { _importDirModA = x } -- | Concrete expressions. Should represent exactly what the user wrote. data Expr @@ -154,23 +157,22 @@ | RecUpdate Range Expr [FieldAssignment] -- ^ ex: @record e {x = a; y = b}@ | Let Range [Declaration] (Maybe Expr) -- ^ ex: @let Ds in e@, missing body when parsing do-notation let | Paren Range Expr -- ^ ex: @(e)@ - | IdiomBrackets Range Expr -- ^ ex: @(| e |)@ + | IdiomBrackets Range [Expr] -- ^ ex: @(| e1 | e2 | .. | en |)@ or @(|)@ | DoBlock Range [DoStmt] -- ^ ex: @do x <- m1; m2@ | Absurd Range -- ^ ex: @()@ or @{}@, only in patterns | As Range Name Expr -- ^ ex: @x\@p@, only in patterns | Dot Range Expr -- ^ ex: @.p@, only in patterns + | DoubleDot Range Expr -- ^ ex: @..A@, used for parsing @..A -> B@ | ETel Telescope -- ^ only used for printing telescopes - | QuoteGoal Range Name Expr -- ^ ex: @quoteGoal x in e@ - | QuoteContext Range -- ^ ex: @quoteContext@ | Quote Range -- ^ ex: @quote@, should be applied to a name | QuoteTerm Range -- ^ ex: @quoteTerm@, should be applied to a term - | Tactic Range Expr [Expr] -- ^ @tactic solve | subgoal1 | .. | subgoalN@ + | Tactic Range Expr -- ^ ex: @\@(tactic t)@, used to declare tactic arguments | Unquote Range -- ^ ex: @unquote@, should be applied to a term of type @Term@ | DontCare Expr -- ^ to print irrelevant things | Equal Range Expr Expr -- ^ ex: @a = b@, used internally in the parser | Ellipsis Range -- ^ @...@, used internally to parse patterns. | Generalized Expr - deriving Data + deriving (Data, Eq) -- | Concrete patterns. No literals in patterns at the moment. data Pattern @@ -196,41 +198,63 @@ | EqualP Range [(Expr,Expr)] -- ^ @i = i1@ i.e. cubical face lattice generator | EllipsisP Range -- ^ @...@, only as left-most pattern. | WithP Range Pattern -- ^ @| p@, for with-patterns. - deriving Data + deriving (Data, Eq) data DoStmt = DoBind Range Pattern Expr [LamClause] -- ^ @p ← e where cs@ | DoThen Expr | DoLet Range [Declaration] - deriving Data + deriving (Data, Eq) +-- | A Binder @x\@p@, the pattern is optional +data Binder' a = Binder + { binderPattern :: Maybe Pattern + , binderName :: a + } deriving (Data, Eq, Functor, Foldable, Traversable) + +type Binder = Binder' BoundName + +mkBinder_ :: Name -> Binder +mkBinder_ = mkBinder . mkBoundName_ + +mkBinder :: a -> Binder' a +mkBinder = Binder Nothing + -- | A lambda binding is either domain free or typed. + type LamBinding = LamBinding' TypedBinding data LamBinding' a - = DomainFree (NamedArg BoundName) -- ^ . @x@ or @{x}@ or @.x@ or @.{x}@ or @{.x}@ - | DomainFull a -- ^ . @(xs : e)@ or @{xs : e}@ - deriving (Data, Functor, Foldable, Traversable) + = DomainFree (NamedArg Binder) + -- ^ . @x@ or @{x}@ or @.x@ or @.{x}@ or @{.x}@ or @x\@p@ or @(p)@ + | DomainFull a + -- ^ . @(xs : e)@ or @{xs : e}@ + deriving (Data, Functor, Foldable, Traversable, Eq) data BoundName = BName { boundName :: Name , bnameFixity :: Fixity' + , bnameTactic :: TacticAttribute -- From @tactic attribute } - deriving (Data, Eq, Show) + deriving (Data, Eq) +type TacticAttribute = Maybe Expr + mkBoundName_ :: Name -> BoundName mkBoundName_ x = mkBoundName x noFixity' mkBoundName :: Name -> Fixity' -> BoundName -mkBoundName x f = BName x f +mkBoundName x f = BName x f Nothing -- | A typed binding. type TypedBinding = TypedBinding' Expr data TypedBinding' e - = TBind Range [NamedArg BoundName] e -- ^ Binding @(x1 ... xn : A)@. - | TLet Range [Declaration] -- ^ Let binding @(let Ds)@ or @(open M args)@. - deriving (Data, Functor, Foldable, Traversable) + = TBind Range [NamedArg Binder] e + -- ^ Binding @(x1\@p1 ... xn\@pn : A)@. + | TLet Range [Declaration] + -- ^ Let binding @(let Ds)@ or @(open M args)@. + deriving (Data, Functor, Foldable, Traversable, Eq) -- | A telescope is a sequence of typed bindings. Bound variables are in scope -- in later types. @@ -265,13 +289,15 @@ We use fixity information to see which name is actually defined. -} data LHS = LHS - { lhsOriginalPattern :: Pattern -- ^ e.g. @f ps | wps@ - , lhsRewriteEqn :: [RewriteEqn] -- ^ @rewrite e@ (many) - , lhsWithExpr :: [WithExpr] -- ^ @with e@ (many) + { lhsOriginalPattern :: Pattern -- ^ e.g. @f ps | wps@ + , lhsRewriteEqn :: [RewriteEqn] -- ^ @(rewrite e | with p <- e)@ (many) + , lhsWithExpr :: [WithHiding WithExpr] -- ^ @with e1 | {e2} | ...@ (many) + , lhsExpandedEllipsis :: ExpandedEllipsis -- ^ Did we expand an ellipsis? } -- ^ Original pattern (including with-patterns), rewrite equations and with-expressions. - deriving Data + deriving (Data, Eq) -type RewriteEqn = Expr +type RewriteEqn = RewriteEqn' () Pattern Expr + type WithExpr = Expr -- | Processed (operator-parsed) intermediate form of the core @f ps@ of 'LHS'. @@ -289,12 +315,13 @@ , lhsWithPatterns :: [Pattern] -- ^ Non-empty; at least one @(| p)@. , lhsPats :: [NamedArg Pattern] -- ^ More application patterns. } + deriving (Data, Eq) type RHS = RHS' Expr data RHS' e = AbsurdRHS -- ^ No right hand side because of absurd match. | RHS e - deriving (Data, Functor, Foldable, Traversable) + deriving (Data, Functor, Foldable, Traversable, Eq) type WhereClause = WhereClause' [Declaration] @@ -305,13 +332,13 @@ -- ^ Named where: @module M where@. -- The 'Access' flag applies to the 'Name' (not the module contents!) -- and is propagated from the parent function. - deriving (Data, Functor, Foldable, Traversable) + deriving (Data, Functor, Foldable, Traversable, Eq) data LamClause = LamClause { lamLHS :: LHS , lamRHS :: RHS , lamWhere :: WhereClause -- ^ always 'NoWhere' (see parser) , lamCatchAll :: Bool } - deriving Data + deriving (Data, Eq) -- | An expression followed by a where clause. -- Currently only used to give better a better error message in interaction. @@ -333,7 +360,7 @@ , asRange :: Range -- ^ The range of the \"as\" keyword. Retained for highlighting purposes. } - deriving (Data, Show, Functor, Foldable, Traversable) + deriving (Data, Show, Functor, Foldable, Traversable, Eq) -- | From the parser, we get an expression for the @as@-'Name', which -- we have to parse into a 'Name'. @@ -346,6 +373,9 @@ -- | Just type signatures. type TypeSignature = Declaration +-- | Just field signatures +type FieldSignature = Declaration + -- | Just type signatures or instance blocks. type TypeSignatureOrInstanceBlock = Declaration @@ -354,14 +384,15 @@ -} data Declaration - = TypeSig ArgInfo Name Expr + = TypeSig ArgInfo TacticAttribute Name Expr + | FieldSig IsInstance TacticAttribute Name (Arg Expr) -- ^ Axioms and functions can be irrelevant. (Hiding should be NotHidden) | Generalize Range [TypeSignature] -- ^ Variables to be generalized, can be hidden and/or irrelevant. - | Field IsInstance Name (Arg Expr) -- ^ Record field, can be hidden and/or irrelevant. + | Field Range [FieldSignature] | FunClause LHS RHS WhereClause Bool - | DataSig Range Induction Name [LamBinding] Expr -- ^ lone data signature in mutual block - | Data Range Induction Name [LamBinding] Expr [TypeSignatureOrInstanceBlock] - | DataDef Range Induction Name [LamBinding] [TypeSignatureOrInstanceBlock] + | DataSig Range Name [LamBinding] Expr -- ^ lone data signature in mutual block + | Data Range Name [LamBinding] Expr [TypeSignatureOrInstanceBlock] + | DataDef Range Name [LamBinding] [TypeSignatureOrInstanceBlock] | RecordSig Range Name [LamBinding] Expr -- ^ lone record signature in mutual block | RecordDef Range Name (Maybe (Ranged Induction)) (Maybe HasEta) (Maybe (Name, IsInstance)) [LamBinding] [Declaration] | Record Range Name (Maybe (Ranged Induction)) (Maybe HasEta) (Maybe (Name, IsInstance)) [LamBinding] Expr [Declaration] @@ -376,6 +407,9 @@ -- temporarily, which should be treated different that user-declared -- private blocks. Thus the 'Origin'. | InstanceB Range [Declaration] + -- ^ The 'Range' here (exceptionally) only refers to the range of the + -- @instance@ keyword. The range of the whole block @InstanceB r ds@ + -- is @fuseRange r ds@. | Macro Range [Declaration] | Postulate Range [TypeSignatureOrInstanceBlock] | Primitive Range [TypeSignature] @@ -386,14 +420,14 @@ | UnquoteDecl Range [Name] Expr | UnquoteDef Range [Name] Expr | Pragma Pragma - deriving Data + deriving (Data, Eq) data ModuleApplication = SectionApp Range Telescope Expr -- ^ @tel. M args@ | RecordModuleInstance Range QName -- ^ @M {{...}}@ - deriving Data + deriving (Data, Eq) data OpenShortHand = DoOpen | DontOpen deriving (Data, Eq, Show) @@ -402,10 +436,10 @@ data Pragma = OptionsPragma Range [String] - | BuiltinPragma Range String QName - | RewritePragma Range [QName] - | ForeignPragma Range String String -- ^ first string is backend name - | CompilePragma Range String QName String -- ^ first string is backend name + | BuiltinPragma Range RString QName + | RewritePragma Range Range [QName] -- ^ Second Range is for REWRITE keyword. + | ForeignPragma Range RString String -- ^ first string is backend name + | CompilePragma Range RString QName String -- ^ first string is backend name | StaticPragma Range QName | InlinePragma Range Bool QName -- ^ INLINE or NOINLINE @@ -416,6 +450,8 @@ -- @eta-equality@ definition (as it is might make Agda loop). | WarningOnUsage Range QName String -- ^ Applies to the named function + | WarningOnImport Range String + -- ^ Applies to the current module | InjectivePragma Range QName -- ^ Mark a definition as injective for the pattern matching unifier. | DisplayPragma Range Pattern Expr @@ -427,12 +463,15 @@ | TerminationCheckPragma Range (TerminationCheck Name) -- ^ Applies to the following function (and all that are mutually recursive with it) -- or to the functions in the following mutual block. + | NoCoverageCheckPragma Range + -- ^ Applies to the following function (and all that are mutually recursive with it) + -- or to the functions in the following mutual block. | NoPositivityCheckPragma Range -- ^ Applies to the following data/record type or mutual block. | PolarityPragma Range Name [Occurrence] | NoUniverseCheckPragma Range -- ^ Applies to the following data/record type. - deriving Data + deriving (Data, Eq) --------------------------------------------------------------------------- @@ -473,12 +512,12 @@ --------------------------------------------------------------------------} -- | Extended content of an interaction hole. -data HoleContent' e - = HoleContentExpr e -- ^ @e@ - | HoleContentRewrite [e] -- ^ @rewrite e0 | ... | en@ +data HoleContent' qn p e + = HoleContentExpr e -- ^ @e@ + | HoleContentRewrite [RewriteEqn' qn p e] -- ^ @(rewrite | invert) e0 | ... | en@ deriving (Functor, Foldable, Traversable) -type HoleContent = HoleContent' Expr +type HoleContent = HoleContent' () Pattern Expr {-------------------------------------------------------------------------- Views @@ -492,7 +531,7 @@ case e of App r e1 e2 -> vApp (appView e1) e2 RawApp _ (e:es) -> AppView e $ map arg es - _ -> AppView e [] + _ -> AppView e [] where vApp (AppView e es) arg = AppView e (es ++ [arg]) @@ -512,6 +551,78 @@ ParenP _ p' -> removeSingletonRawAppP p' _ -> p +-- | Observe the hiding status of an expression + +observeHiding :: Expr -> WithHiding Expr +observeHiding = \case + RawApp _ [e] -> observeHiding e + HiddenArg _ (Named Nothing e) -> WithHiding Hidden e + InstanceArg _ (Named Nothing e) -> WithHiding (Instance NoOverlap) e + e -> WithHiding NotHidden e + +-- | Turn an expression into a pattern. Fails if the expression is not a +-- valid pattern. + +isPattern :: Expr -> Maybe Pattern +isPattern = \case + Ident x -> return $ IdentP x + App _ e1 e2 -> AppP <$> isPattern e1 <*> mapM (mapM isPattern) e2 + Paren r e -> ParenP r <$> isPattern e + Underscore r _ -> return $ WildP r + Absurd r -> return $ AbsurdP r + As r x e -> pushUnderBracesP r (AsP r x) <$> isPattern e + Dot r e -> return $ pushUnderBracesE r (DotP r) e + Lit l -> return $ LitP l + HiddenArg r e -> HiddenP r <$> mapM isPattern e + InstanceArg r e -> InstanceP r <$> mapM isPattern e + RawApp r es -> RawAppP r <$> mapM isPattern es + Quote r -> return $ QuoteP r + Equal r e1 e2 -> return $ EqualP r [(e1, e2)] + Ellipsis r -> return $ EllipsisP r + Rec r es -> do + fs <- mapM maybeLeft es + RecP r <$> mapM (mapM isPattern) fs + -- WithApp has already lost the range information of the bars '|' + WithApp r e es -> do + p <- isPattern e + ps <- forM es $ \ e -> do + p <- isPattern e + pure $ defaultNamedArg $ WithP (getRange e) p -- TODO #2822: Range! + return $ foldl AppP p ps + _ -> Nothing + + where + + pushUnderBracesP :: Range -> (Pattern -> Pattern) -> (Pattern -> Pattern) + pushUnderBracesP r f = \case + HiddenP _ p -> HiddenP r (fmap f p) + InstanceP _ p -> InstanceP r (fmap f p) + p -> f p + + pushUnderBracesE :: Range -> (Expr -> Pattern) -> (Expr -> Pattern) + pushUnderBracesE r f = \case + HiddenArg _ p -> HiddenP r (fmap f p) + InstanceArg _ p -> InstanceP r (fmap f p) + p -> f p + +isAbsurdP :: Pattern -> Maybe (Range, Hiding) +isAbsurdP = \case + AbsurdP r -> pure (r, NotHidden) + AsP _ _ p -> isAbsurdP p + ParenP _ p -> isAbsurdP p + RawAppP _ [p] -> isAbsurdP p + HiddenP _ np -> (Hidden <$) <$> isAbsurdP (namedThing np) + InstanceP _ np -> (Instance YesOverlap <$) <$> isAbsurdP (namedThing np) + _ -> Nothing + +isBinderP :: Pattern -> Maybe Binder +isBinderP = \case + IdentP qn -> mkBinder_ <$> isUnqualified qn + WildP r -> pure $ mkBinder_ (Name r InScope [Hole]) + AsP r n p -> pure $ Binder (Just p) (mkBoundName_ n) + ParenP r p -> pure $ Binder (Just p) (mkBoundName_ $ Name r InScope [Hole]) + _ -> Nothing + {-------------------------------------------------------------------------- Instances --------------------------------------------------------------------------} @@ -560,8 +671,7 @@ SyntaxBindingLambda r _ _ -> r instance HasRange Expr where - getRange e = - case e of + getRange = \case Ident x -> getRange x Lit x -> getRange x QuestionMark r _ -> r @@ -585,18 +695,17 @@ DoBlock r _ -> r As r _ _ -> r Dot r _ -> r + DoubleDot r _ -> r Absurd r -> r HiddenArg r _ -> r InstanceArg r _ -> r Rec r _ -> r RecUpdate r _ _ -> r ETel tel -> getRange tel - QuoteGoal r _ _ -> r - QuoteContext r -> r Quote r -> r QuoteTerm r -> r Unquote r -> r - Tactic r _ _ -> r + Tactic r _ -> r DontCare{} -> noRange Equal r _ _ -> r Ellipsis r -> r @@ -606,6 +715,9 @@ -- getRange (TeleBind bs) = getRange bs -- getRange (TeleFun x y) = fuseRange x y +instance HasRange Binder where + getRange (Binder a b) = fuseRange a b + instance HasRange TypedBinding where getRange (TBind r _ _) = r getRange (TLet r _) = r @@ -633,12 +745,13 @@ getRange (ModuleAssignment a b c) = fuseRange a b `fuseRange` c instance HasRange Declaration where - getRange (TypeSig _ x t) = fuseRange x t - getRange (Field _ x t) = fuseRange x t + getRange (TypeSig _ _ x t) = fuseRange x t + getRange (FieldSig _ _ x t) = fuseRange x t + getRange (Field r _) = r getRange (FunClause lhs rhs wh _) = fuseRange lhs rhs `fuseRange` wh - getRange (DataSig r _ _ _ _) = r - getRange (Data r _ _ _ _ _) = r - getRange (DataDef r _ _ _ _) = r + getRange (DataSig r _ _ _) = r + getRange (Data r _ _ _ _) = r + getRange (DataDef r _ _ _) = r getRange (RecordSig r _ _ _) = r getRange (RecordDef r _ _ _ _ _ _) = r getRange (Record r _ _ _ _ _ _ _) = r @@ -662,7 +775,7 @@ getRange (Pragma p) = getRange p instance HasRange LHS where - getRange (LHS p eqns ws) = fuseRange p (eqns ++ ws) + getRange (LHS p eqns ws ell) = p `fuseRange` eqns `fuseRange` ws instance HasRange LHSCore where getRange (LHSHead f ps) = fuseRange f ps @@ -684,7 +797,7 @@ instance HasRange Pragma where getRange (OptionsPragma r _) = r getRange (BuiltinPragma r _ _) = r - getRange (RewritePragma r _) = r + getRange (RewritePragma r _ _) = r getRange (CompilePragma r _ _ _) = r getRange (ForeignPragma r _ _) = r getRange (StaticPragma r _) = r @@ -693,7 +806,9 @@ getRange (ImpossiblePragma r) = r getRange (EtaPragma r _) = r getRange (TerminationCheckPragma r _) = r + getRange (NoCoverageCheckPragma r) = r getRange (WarningOnUsage r _ _) = r + getRange (WarningOnImport r _) = r getRange (CatchallPragma r) = r getRange (DisplayPragma r _ _) = r getRange (NoPositivityCheckPragma r) = r @@ -760,17 +875,21 @@ instance KillRange AsName where killRange (AsName n _) = killRange1 (flip AsName noRange) n +instance KillRange Binder where + killRange (Binder a b) = killRange2 Binder a b + instance KillRange BoundName where - killRange (BName n f) = killRange2 BName n f + killRange (BName n f t) = killRange3 BName n f t instance KillRange Declaration where - killRange (TypeSig i n e) = killRange2 (TypeSig i) n e + killRange (TypeSig i t n e) = killRange3 (TypeSig i) t n e + killRange (FieldSig i t n e) = killRange4 FieldSig i t n e killRange (Generalize r ds ) = killRange1 (Generalize noRange) ds - killRange (Field i n a) = killRange2 (Field i) n a + killRange (Field r fs) = killRange1 (Field noRange) fs killRange (FunClause l r w ca) = killRange4 FunClause l r w ca - killRange (DataSig _ i n l e) = killRange4 (DataSig noRange) i n l e - killRange (Data _ i n l e c) = killRange4 (Data noRange i) n l e c - killRange (DataDef _ i n l c) = killRange3 (DataDef noRange i) n l c + killRange (DataSig _ n l e) = killRange3 (DataSig noRange) n l e + killRange (Data _ n l e c) = killRange4 (Data noRange) n l e c + killRange (DataDef _ n l c) = killRange3 (DataDef noRange) n l c killRange (RecordSig _ n l e) = killRange3 (RecordSig noRange) n l e killRange (RecordDef _ n mi mb mn k d) = killRange6 (RecordDef noRange) n mi mb mn k d killRange (Record _ n mi mb mn k e d) = killRange7 (Record noRange) n mi mb mn k e d @@ -816,18 +935,17 @@ killRange (RecUpdate _ e ne) = killRange2 (RecUpdate noRange) e ne killRange (Let _ d e) = killRange2 (Let noRange) d e killRange (Paren _ e) = killRange1 (Paren noRange) e - killRange (IdiomBrackets _ e) = killRange1 (IdiomBrackets noRange) e + killRange (IdiomBrackets _ es) = killRange1 (IdiomBrackets noRange) es killRange (DoBlock _ ss) = killRange1 (DoBlock noRange) ss killRange (Absurd _) = Absurd noRange killRange (As _ n e) = killRange2 (As noRange) n e killRange (Dot _ e) = killRange1 (Dot noRange) e + killRange (DoubleDot _ e) = killRange1 (DoubleDot noRange) e killRange (ETel t) = killRange1 ETel t - killRange (QuoteGoal _ n e) = killRange2 (QuoteGoal noRange) n e - killRange (QuoteContext _) = QuoteContext noRange killRange (Quote _) = Quote noRange killRange (QuoteTerm _) = QuoteTerm noRange killRange (Unquote _) = Unquote noRange - killRange (Tactic _ t es) = killRange2 (Tactic noRange) t es + killRange (Tactic _ t) = killRange1 (Tactic noRange) t killRange (DontCare e) = killRange1 DontCare e killRange (Equal _ x y) = Equal noRange x y killRange (Ellipsis _) = Ellipsis noRange @@ -838,7 +956,7 @@ killRange (DomainFull t) = killRange1 DomainFull t instance KillRange LHS where - killRange (LHS p r w) = killRange3 LHS p r w + killRange (LHS p r w e) = killRange4 LHS p r w e instance KillRange LamClause where killRange (LamClause a b c d) = killRange4 LamClause a b c d @@ -878,7 +996,7 @@ instance KillRange Pragma where killRange (OptionsPragma _ s) = OptionsPragma noRange s killRange (BuiltinPragma _ s e) = killRange1 (BuiltinPragma noRange s) e - killRange (RewritePragma _ qs) = killRange1 (RewritePragma noRange) qs + killRange (RewritePragma _ _ qs) = killRange1 (RewritePragma noRange noRange) qs killRange (StaticPragma _ q) = killRange1 (StaticPragma noRange) q killRange (InjectivePragma _ q) = killRange1 (InjectivePragma noRange) q killRange (InlinePragma _ b q) = killRange1 (InlinePragma noRange b) q @@ -886,7 +1004,9 @@ killRange (ForeignPragma _ b s) = ForeignPragma noRange b s killRange (ImpossiblePragma _) = ImpossiblePragma noRange killRange (TerminationCheckPragma _ t) = TerminationCheckPragma noRange (killRange t) + killRange (NoCoverageCheckPragma _) = NoCoverageCheckPragma noRange killRange (WarningOnUsage _ nm str) = WarningOnUsage noRange (killRange nm) str + killRange (WarningOnImport _ str) = WarningOnImport noRange str killRange (CatchallPragma _) = CatchallPragma noRange killRange (DisplayPragma _ lhs rhs) = killRange2 (DisplayPragma noRange) lhs rhs killRange (EtaPragma _ q) = killRange1 (EtaPragma noRange) q @@ -941,12 +1061,11 @@ rnf (Absurd _) = () rnf (As _ a b) = rnf a `seq` rnf b rnf (Dot _ a) = rnf a + rnf (DoubleDot _ a) = rnf a rnf (ETel a) = rnf a - rnf (QuoteGoal _ a b) = rnf a `seq` rnf b - rnf (QuoteContext _) = () rnf (Quote _) = () rnf (QuoteTerm _) = () - rnf (Tactic _ a b) = rnf a `seq` rnf b + rnf (Tactic _ a) = rnf a rnf (Unquote _) = () rnf (DontCare a) = rnf a rnf (Equal _ a b) = rnf a `seq` rnf b @@ -977,13 +1096,14 @@ -- | Ranges are not forced. instance NFData Declaration where - rnf (TypeSig a b c) = rnf a `seq` rnf b `seq` rnf c + rnf (TypeSig a b c d) = rnf a `seq` rnf b `seq` rnf c `seq` rnf d + rnf (FieldSig a b c d) = rnf a `seq` rnf b `seq` rnf c `seq` rnf d rnf (Generalize _ a) = rnf a - rnf (Field a b c) = rnf a `seq` rnf b `seq` rnf c + rnf (Field _ fs) = rnf fs rnf (FunClause a b c d) = rnf a `seq` rnf b `seq` rnf c `seq` rnf d - rnf (DataSig _ a b c d) = rnf a `seq` rnf b `seq` rnf c `seq` rnf d - rnf (Data _ a b c d e) = rnf a `seq` rnf b `seq` rnf c `seq` rnf d `seq` rnf e - rnf (DataDef _ a b c d) = rnf a `seq` rnf b `seq` rnf c `seq` rnf d + rnf (DataSig _ a b c) = rnf a `seq` rnf b `seq` rnf c + rnf (Data _ a b c d) = rnf a `seq` rnf b `seq` rnf c `seq` rnf d + rnf (DataDef _ a b c) = rnf a `seq` rnf b `seq` rnf c rnf (RecordSig _ a b c) = rnf a `seq` rnf b `seq` rnf c rnf (RecordDef _ a b c d e f) = rnf a `seq` rnf b `seq` rnf c `seq` rnf d `seq` rnf e `seq` rnf f rnf (Record _ a b c d e f g) = rnf a `seq` rnf b `seq` rnf c `seq` rnf d `seq` rnf e `seq` rnf f `seq` rnf g @@ -1010,7 +1130,7 @@ instance NFData Pragma where rnf (OptionsPragma _ a) = rnf a rnf (BuiltinPragma _ a b) = rnf a `seq` rnf b - rnf (RewritePragma _ a) = rnf a + rnf (RewritePragma _ _ a) = rnf a rnf (CompilePragma _ a b c) = rnf a `seq` rnf b `seq` rnf c rnf (ForeignPragma _ b s) = rnf b `seq` rnf s rnf (StaticPragma _ a) = rnf a @@ -1019,7 +1139,9 @@ rnf (ImpossiblePragma _) = () rnf (EtaPragma _ a) = rnf a rnf (TerminationCheckPragma _ a) = rnf a + rnf (NoCoverageCheckPragma _) = () rnf (WarningOnUsage _ a b) = rnf a `seq` rnf b + rnf (WarningOnImport _ a) = rnf a rnf (CatchallPragma _) = () rnf (DisplayPragma _ a b) = rnf a `seq` rnf b rnf (NoPositivityCheckPragma _) = () @@ -1052,7 +1174,7 @@ -- | Ranges are not forced. instance NFData LHS where - rnf (LHS a b c) = rnf a `seq` rnf b `seq` rnf c + rnf (LHS a b c d) = rnf a `seq` rnf b `seq` rnf c `seq` rnf d instance NFData a => NFData (FieldAssignment' a) where rnf (FieldAssignment a b) = rnf a `seq` rnf b @@ -1072,8 +1194,11 @@ rnf (DomainFree a) = rnf a rnf (DomainFull a) = rnf a +instance NFData Binder where + rnf (Binder a b) = rnf a `seq` rnf b + instance NFData BoundName where - rnf (BName a b) = rnf a `seq` rnf b + rnf (BName a b c) = rnf a `seq` rnf b `seq` rnf c instance NFData a => NFData (RHS' a) where rnf AbsurdRHS = () diff --git a/src/full/Agda/Syntax/Concrete/Attribute.hs b/src/full/Agda/Syntax/Concrete/Attribute.hs --- a/src/full/Agda/Syntax/Concrete/Attribute.hs +++ b/src/full/Agda/Syntax/Concrete/Attribute.hs @@ -1,6 +1,3 @@ -{-# LANGUAGE TupleSections #-} -{-# LANGUAGE LambdaCase #-} -{-# LANGUAGE ConstraintKinds #-} -- | Attributes: concrete syntax for ArgInfo, esp. modalities. @@ -15,8 +12,12 @@ import Data.Maybe import Agda.Syntax.Common -import Agda.Syntax.Concrete.Name +import Agda.Syntax.Concrete (Expr(..)) +import Agda.Syntax.Concrete.Pretty () --instance only +import Agda.Syntax.Position +import Agda.Utils.Pretty (prettyShow) + -- import Agda.Utils.Functor -- | An attribute is a modifier for `ArgInfo`. @@ -24,11 +25,34 @@ data Attribute = RelevanceAttribute Relevance | QuantityAttribute Quantity - deriving (Eq, Ord, Show) + | TacticAttribute Expr + | CohesionAttribute Cohesion + deriving (Show) +instance HasRange Attribute where + getRange = \case + RelevanceAttribute r -> getRange r + QuantityAttribute q -> getRange q + CohesionAttribute c -> getRange c + TacticAttribute e -> getRange e + +instance SetRange Attribute where + setRange r = \case + RelevanceAttribute a -> RelevanceAttribute $ setRange r a + QuantityAttribute q -> QuantityAttribute $ setRange r q + CohesionAttribute c -> CohesionAttribute $ setRange r c + TacticAttribute e -> TacticAttribute e -- -- $ setRange r e -- SetRange Expr not yet implemented + +instance KillRange Attribute where + killRange = \case + RelevanceAttribute a -> RelevanceAttribute $ killRange a + QuantityAttribute q -> QuantityAttribute $ killRange q + CohesionAttribute c -> CohesionAttribute $ killRange c + TacticAttribute e -> TacticAttribute $ killRange e + -- | (Conjunctive constraint.) -type LensAttribute a = (LensRelevance a, LensQuantity a) +type LensAttribute a = (LensRelevance a, LensQuantity a, LensCohesion a) -- | Modifiers for 'Relevance'. @@ -42,19 +66,35 @@ -- | Modifiers for 'Quantity'. quantityAttributeTable :: [(String, Quantity)] -quantityAttributeTable = concat - [ map (, Quantity0) [ "0", "erased" ] -- , "static", "compile-time" ] - , map (, Quantityω) [ "ω", "plenty" ] -- , "dynamic", "runtime", "unrestricted", "abundant" ] - -- , map (, Quantity1) [ "1", "linear" ] - -- , map (, Quantity01) [ "01", "affine" ] +quantityAttributeTable = + [ ("0" , Quantity0 $ Q0 noRange) + , ("erased" , Quantity0 $ Q0Erased noRange) + -- TODO: linearity + -- , ("1" , Quantity1 $ Q1 noRange) + -- , ("linear" , Quantity1 $ Q1Linear noRange) + , ("ω" , Quantityω $ Qω noRange) + , ("plenty" , Quantityω $ QωPlenty noRange) ] +-- quantityAttributeTable = concat +-- [ map (, Quantity0) [ "0", "erased" ] -- , "static", "compile-time" ] +-- , map (, Quantityω) [ "ω", "plenty" ] -- , "dynamic", "runtime", "unrestricted", "abundant" ] +-- -- , map (, Quantity1) [ "1", "linear" ] +-- -- , map (, Quantity01) [ "01", "affine" ] +-- ] +cohesionAttributeTable :: [(String, Cohesion)] +cohesionAttributeTable = + [ ("♭" , Flat) + , ("flat" , Flat) + ] + -- | Concrete syntax for all attributes. attributesMap :: Map String Attribute attributesMap = Map.fromList $ concat [ map (second RelevanceAttribute) relevanceAttributeTable , map (second QuantityAttribute) quantityAttributeTable + , map (second CohesionAttribute) cohesionAttributeTable ] -- | Parsing a string into an attribute. @@ -62,12 +102,20 @@ stringToAttribute :: String -> Maybe Attribute stringToAttribute = (`Map.lookup` attributesMap) +-- | Parsing an expression into an attribute. + +exprToAttribute :: Expr -> Maybe Attribute +exprToAttribute (Paren _ (RawApp _ [Tactic _ t])) = Just $ TacticAttribute t +exprToAttribute e = setRange (getRange e) $ stringToAttribute $ prettyShow e + -- | Setting an attribute (in e.g. an 'Arg'). Overwrites previous value. setAttribute :: (LensAttribute a) => Attribute -> a -> a setAttribute = \case RelevanceAttribute r -> setRelevance r QuantityAttribute q -> setQuantity q + CohesionAttribute c -> setCohesion c + TacticAttribute t -> id -- | Setting some attributes in left-to-right order. @@ -92,15 +140,24 @@ setPristineQuantity :: (LensQuantity a) => Quantity -> a -> Maybe a setPristineQuantity q a - | getQuantity a == defaultQuantity = Just $ setQuantity q a + | noUserQuantity a = Just $ setQuantity q a | otherwise = Nothing +-- | Setting 'Cohesion' if unset. + +setPristineCohesion :: (LensCohesion a) => Cohesion -> a -> Maybe a +setPristineCohesion c a + | getCohesion a == defaultCohesion = Just $ setCohesion c a + | otherwise = Nothing + -- | Setting an unset attribute (to e.g. an 'Arg'). setPristineAttribute :: (LensAttribute a) => Attribute -> a -> Maybe a setPristineAttribute = \case RelevanceAttribute r -> setPristineRelevance r QuantityAttribute q -> setPristineQuantity q + CohesionAttribute c -> setPristineCohesion c + TacticAttribute{} -> Just -- | Setting a list of unset attributes. @@ -121,8 +178,15 @@ QuantityAttribute q -> Just q _ -> Nothing +isTacticAttribute :: Attribute -> Maybe Expr +isTacticAttribute (TacticAttribute t) = Just t +isTacticAttribute _ = Nothing + relevanceAttributes :: [Attribute] -> [Attribute] relevanceAttributes = filter $ isJust . isRelevanceAttribute quantityAttributes :: [Attribute] -> [Attribute] quantityAttributes = filter $ isJust . isQuantityAttribute + +tacticAttributes :: [Attribute] -> [Attribute] +tacticAttributes = filter $ isJust . isTacticAttribute diff --git a/src/full/Agda/Syntax/Concrete/Definitions.hs b/src/full/Agda/Syntax/Concrete/Definitions.hs --- a/src/full/Agda/Syntax/Concrete/Definitions.hs +++ b/src/full/Agda/Syntax/Concrete/Definitions.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} @@ -35,7 +34,7 @@ , NiceConstructor, NiceTypeSignature , Clause(..) , DeclarationException(..) - , DeclarationWarning(..) + , DeclarationWarning(..), unsafeDeclarationWarning , Nice, runNice , niceDeclarations , notSoNiceDeclarations @@ -46,20 +45,15 @@ import Prelude hiding (null) -import Control.Arrow ((&&&), (***), first, second) -import Control.Applicative hiding (empty) +import Control.Arrow ((&&&), (***), second) import Control.Monad.Except import Control.Monad.State -import Data.Either ( partitionEithers ) -import Data.Function ( on ) import qualified Data.Map as Map import Data.Map (Map) import Data.Maybe -import Data.Monoid ( Monoid, mempty, mappend ) -import Data.Semigroup ( Semigroup, (<>) ) import qualified Data.List as List -import qualified Data.Set as Set +import qualified Data.Foldable as Fold import Data.Traversable (Traversable, traverse) import qualified Data.Traversable as Trav @@ -70,30 +64,26 @@ import Agda.Syntax.Common hiding (TerminationCheck()) import qualified Agda.Syntax.Common as Common import Agda.Syntax.Position -import Agda.Syntax.Fixity import Agda.Syntax.Notation -import Agda.Syntax.Concrete.Pretty () +import Agda.Syntax.Concrete.Pretty () --instance only import Agda.Syntax.Concrete.Fixity import Agda.Interaction.Options.Warnings import Agda.Utils.AffineHole -import Agda.Utils.Except ( MonadError(throwError,catchError) ) -import Agda.Utils.Function +import Agda.Utils.Except ( MonadError(throwError) ) import Agda.Utils.Functor import Agda.Utils.Lens -import Agda.Utils.List (caseList, headMaybe, isSublistOf) +import Agda.Utils.List (isSublistOf) import Agda.Utils.Maybe -import Agda.Utils.Monad import Agda.Utils.Null import qualified Agda.Utils.Pretty as Pretty -import Agda.Utils.Pretty hiding ((<>)) +import Agda.Utils.Pretty import Agda.Utils.Singleton import Agda.Utils.Three import Agda.Utils.Tuple import Agda.Utils.Update -#include "undefined.h" import Agda.Utils.Impossible {-------------------------------------------------------------------------- @@ -127,9 +117,9 @@ -- -- 'ArgInfo' argument: Axioms and functions can be declared irrelevant. -- ('Hiding' should be 'NotHidden'.) - | NiceField Range Access IsAbstract IsInstance Name (Arg Expr) + | NiceField Range Access IsAbstract IsInstance TacticAttribute Name (Arg Expr) | PrimitiveFunction Range Access IsAbstract Name Expr - | NiceMutual Range TerminationCheck PositivityCheck [NiceDeclaration] + | NiceMutual Range TerminationCheck CoverageCheck PositivityCheck [NiceDeclaration] | NiceModule Range Access IsAbstract QName Telescope [Declaration] | NiceModuleMacro Range Access Name ModuleApplication OpenShortHand ImportDirective | NiceOpen Range QName ImportDirective @@ -137,12 +127,12 @@ | NicePragma Range Pragma | NiceRecSig Range Access IsAbstract PositivityCheck UniverseCheck Name [LamBinding] Expr | NiceDataSig Range Access IsAbstract PositivityCheck UniverseCheck Name [LamBinding] Expr - | NiceFunClause Range Access IsAbstract TerminationCheck Catchall Declaration + | NiceFunClause Range Access IsAbstract TerminationCheck CoverageCheck Catchall Declaration -- ^ An uncategorized function clause, could be a function clause -- without type signature or a pattern lhs (e.g. for irrefutable let). -- The 'Declaration' is the actual 'FunClause'. - | FunSig Range Access IsAbstract IsInstance IsMacro ArgInfo TerminationCheck Name Expr - | FunDef Range [Declaration] IsAbstract IsInstance TerminationCheck Name [Clause] + | FunSig Range Access IsAbstract IsInstance IsMacro ArgInfo TerminationCheck CoverageCheck Name Expr + | FunDef Range [Declaration] IsAbstract IsInstance TerminationCheck CoverageCheck Name [Clause] -- ^ Block of function clauses (we have seen the type signature before). -- The 'Declaration's are the original declarations that were processed -- into this 'FunDef' and are only used in 'notSoNiceDeclaration'. @@ -151,10 +141,10 @@ | NiceDataDef Range Origin IsAbstract PositivityCheck UniverseCheck Name [LamBinding] [NiceConstructor] | NiceRecDef Range Origin IsAbstract PositivityCheck UniverseCheck Name (Maybe (Ranged Induction)) (Maybe HasEta) (Maybe (Name, IsInstance)) [LamBinding] [Declaration] - | NicePatternSyn Range Name [Arg Name] Pattern - | NiceGeneralize Range Access ArgInfo Name Expr - | NiceUnquoteDecl Range Access IsAbstract IsInstance TerminationCheck [Name] Expr - | NiceUnquoteDef Range Access IsAbstract TerminationCheck [Name] Expr + | NicePatternSyn Range Access Name [Arg Name] Pattern + | NiceGeneralize Range Access ArgInfo TacticAttribute Name Expr + | NiceUnquoteDecl Range Access IsAbstract IsInstance TerminationCheck CoverageCheck [Name] Expr + | NiceUnquoteDef Range Access IsAbstract TerminationCheck CoverageCheck [Name] Expr deriving (Data, Show) type TerminationCheck = Common.TerminationCheck Measure @@ -182,7 +172,6 @@ | DuplicateDefinition Name | MissingWithClauses Name LHS | WrongDefinition Name DataRecOrFun DataRecOrFun - | Codata Range | DeclarationPanic String | WrongContentBlock KindOfBlock Range | AmbiguousFunClauses LHS [Name] -- ^ in a mutual block, a clause could belong to any of the @[Name]@ type signatures @@ -193,19 +182,24 @@ | BadMacroDef NiceDeclaration deriving (Data, Show) --- | Non-fatal errors encountered in the Nicifier + +-- | Non-fatal errors encountered in the Nicifier. data DeclarationWarning + -- Please keep in alphabetical order. = EmptyAbstract Range -- ^ Empty @abstract@ block. + | EmptyField Range -- ^ Empty @field@ block. + | EmptyGeneralize Range -- ^ Empty @variable@ block. | EmptyInstance Range -- ^ Empty @instance@ block | EmptyMacro Range -- ^ Empty @macro@ block. | EmptyMutual Range -- ^ Empty @mutual@ block. | EmptyPostulate Range -- ^ Empty @postulate@ block. | EmptyPrivate Range -- ^ Empty @private@ block. - | EmptyGeneralize Range -- ^ Empty @variable@ block. | EmptyPrimitive Range -- ^ Empty @primitive@ block. | InvalidCatchallPragma Range -- ^ A {-\# CATCHALL \#-} pragma -- that does not precede a function clause. + | InvalidCoverageCheckPragma Range + -- ^ A {-\# NON_COVERING \#-} pragma that does not apply to any function. | InvalidNoPositivityCheckPragma Range -- ^ A {-\# NO_POSITIVITY_CHECK \#-} pragma -- that does not apply to any data or record type. @@ -215,41 +209,56 @@ | InvalidTerminationCheckPragma Range -- ^ A {-\# TERMINATING \#-} and {-\# NON_TERMINATING \#-} pragma -- that does not apply to any function. - | MissingDefinitions [Name] + | MissingDefinitions [(Name, Range)] + -- ^ Declarations (e.g. type signatures) without a definition. | NotAllowedInMutual Range String + | OpenPublicPrivate Range + -- ^ @private@ has no effect on @open public@. (But the user might think so.) + | OpenPublicAbstract Range + -- ^ @abstract@ has no effect on @open public@. (But the user might think so.) | PolarityPragmasButNotPostulates [Name] | PragmaNoTerminationCheck Range -- ^ Pragma @{-\# NO_TERMINATION_CHECK \#-}@ has been replaced -- by @{-\# TERMINATING \#-}@ and @{-\# NON_TERMINATING \#-}@. | PragmaCompiled Range -- ^ @COMPILE@ pragmas are not allowed in safe mode + | ShadowingInTelescope [(Name, [Range])] | UnknownFixityInMixfixDecl [Name] | UnknownNamesInFixityDecl [Name] | UnknownNamesInPolarityPragmas [Name] | UselessAbstract Range + -- ^ @abstract@ block with nothing that can (newly) be made abstract. | UselessInstance Range + -- ^ @instance@ block with nothing that can (newly) become an instance. | UselessPrivate Range + -- ^ @private@ block with nothing that can (newly) be made private. deriving (Data, Show) declarationWarningName :: DeclarationWarning -> WarningName -declarationWarningName dw = case dw of +declarationWarningName = \case + -- Please keep in alphabetical order. EmptyAbstract{} -> EmptyAbstract_ + EmptyField{} -> EmptyField_ + EmptyGeneralize{} -> EmptyGeneralize_ EmptyInstance{} -> EmptyInstance_ EmptyMacro{} -> EmptyMacro_ EmptyMutual{} -> EmptyMutual_ EmptyPrivate{} -> EmptyPrivate_ EmptyPostulate{} -> EmptyPostulate_ - EmptyGeneralize{} -> EmptyGeneralize_ EmptyPrimitive{} -> EmptyPrimitive_ InvalidCatchallPragma{} -> InvalidCatchallPragma_ InvalidNoPositivityCheckPragma{} -> InvalidNoPositivityCheckPragma_ InvalidNoUniverseCheckPragma{} -> InvalidNoUniverseCheckPragma_ InvalidTerminationCheckPragma{} -> InvalidTerminationCheckPragma_ + InvalidCoverageCheckPragma{} -> InvalidCoverageCheckPragma_ MissingDefinitions{} -> MissingDefinitions_ NotAllowedInMutual{} -> NotAllowedInMutual_ + OpenPublicPrivate{} -> OpenPublicPrivate_ + OpenPublicAbstract{} -> OpenPublicAbstract_ PolarityPragmasButNotPostulates{} -> PolarityPragmasButNotPostulates_ PragmaNoTerminationCheck{} -> PragmaNoTerminationCheck_ PragmaCompiled{} -> PragmaCompiled_ + ShadowingInTelescope{} -> ShadowingInTelescope_ UnknownFixityInMixfixDecl{} -> UnknownFixityInMixfixDecl_ UnknownNamesInFixityDecl{} -> UnknownNamesInFixityDecl_ UnknownNamesInPolarityPragmas{} -> UnknownNamesInPolarityPragmas_ @@ -257,6 +266,39 @@ UselessInstance{} -> UselessInstance_ UselessPrivate{} -> UselessPrivate_ +-- | Nicifier warnings turned into errors in @--safe@ mode. +unsafeDeclarationWarning :: DeclarationWarning -> Bool +unsafeDeclarationWarning = \case + -- Please keep in alphabetical order. + EmptyAbstract{} -> False + EmptyField{} -> False + EmptyGeneralize{} -> False + EmptyInstance{} -> False + EmptyMacro{} -> False + EmptyMutual{} -> False + EmptyPrivate{} -> False + EmptyPostulate{} -> False + EmptyPrimitive{} -> False + InvalidCatchallPragma{} -> False + InvalidNoPositivityCheckPragma{} -> False + InvalidNoUniverseCheckPragma{} -> False + InvalidTerminationCheckPragma{} -> False + InvalidCoverageCheckPragma{} -> False + MissingDefinitions{} -> True -- not safe + NotAllowedInMutual{} -> False -- really safe? + OpenPublicPrivate{} -> False + OpenPublicAbstract{} -> False + PolarityPragmasButNotPostulates{} -> False + PragmaNoTerminationCheck{} -> True -- not safe + PragmaCompiled{} -> True -- not safe + ShadowingInTelescope{} -> False + UnknownFixityInMixfixDecl{} -> False + UnknownNamesInFixityDecl{} -> False + UnknownNamesInPolarityPragmas{} -> False + UselessAbstract{} -> False + UselessInstance{} -> False + UselessPrivate{} -> False + -- | Several declarations expect only type signatures as sub-declarations. These are: data KindOfBlock = PostulateBlock -- ^ @postulate@ @@ -274,7 +316,6 @@ getRange (MissingWithClauses x lhs) = getRange lhs getRange (WrongDefinition x k k') = getRange x getRange (AmbiguousFunClauses lhs xs) = getRange lhs - getRange (Codata r) = r getRange (DeclarationPanic _) = noRange getRange (WrongContentBlock _ r) = r getRange (InvalidMeasureMutual r) = r @@ -282,11 +323,11 @@ getRange (BadMacroDef d) = getRange d instance HasRange DeclarationWarning where - getRange (UnknownNamesInFixityDecl xs) = getRange . head $ xs - getRange (UnknownFixityInMixfixDecl xs) = getRange . head $ xs - getRange (UnknownNamesInPolarityPragmas xs) = getRange . head $ xs - getRange (PolarityPragmasButNotPostulates xs) = getRange . head $ xs - getRange (MissingDefinitions xs) = getRange . head $ xs + getRange (UnknownNamesInFixityDecl xs) = getRange xs + getRange (UnknownFixityInMixfixDecl xs) = getRange xs + getRange (UnknownNamesInPolarityPragmas xs) = getRange xs + getRange (PolarityPragmasButNotPostulates xs) = getRange xs + getRange (MissingDefinitions xs) = getRange xs getRange (UselessPrivate r) = r getRange (NotAllowedInMutual r x) = r getRange (UselessAbstract r) = r @@ -299,39 +340,44 @@ getRange (EmptyPostulate r) = r getRange (EmptyGeneralize r) = r getRange (EmptyPrimitive r) = r + getRange (EmptyField r) = r getRange (InvalidTerminationCheckPragma r) = r + getRange (InvalidCoverageCheckPragma r) = r getRange (InvalidNoPositivityCheckPragma r) = r getRange (InvalidCatchallPragma r) = r getRange (InvalidNoUniverseCheckPragma r) = r getRange (PragmaNoTerminationCheck r) = r getRange (PragmaCompiled r) = r + getRange (OpenPublicAbstract r) = r + getRange (OpenPublicPrivate r) = r + getRange (ShadowingInTelescope ns) = getRange ns instance HasRange NiceDeclaration where getRange (Axiom r _ _ _ _ _ _) = r - getRange (NiceField r _ _ _ _ _) = r - getRange (NiceMutual r _ _ _) = r + getRange (NiceField r _ _ _ _ _ _) = r + getRange (NiceMutual r _ _ _ _) = r getRange (NiceModule r _ _ _ _ _ ) = r getRange (NiceModuleMacro r _ _ _ _ _) = r getRange (NiceOpen r _ _) = r getRange (NiceImport r _ _ _ _) = r getRange (NicePragma r _) = r getRange (PrimitiveFunction r _ _ _ _) = r - getRange (FunSig r _ _ _ _ _ _ _ _) = r - getRange (FunDef r _ _ _ _ _ _) = r + getRange (FunSig r _ _ _ _ _ _ _ _ _) = r + getRange (FunDef r _ _ _ _ _ _ _) = r getRange (NiceDataDef r _ _ _ _ _ _ _) = r getRange (NiceRecDef r _ _ _ _ _ _ _ _ _ _) = r getRange (NiceRecSig r _ _ _ _ _ _ _) = r getRange (NiceDataSig r _ _ _ _ _ _ _) = r - getRange (NicePatternSyn r _ _ _) = r - getRange (NiceGeneralize r _ _ _ _) = r - getRange (NiceFunClause r _ _ _ _ _) = r - getRange (NiceUnquoteDecl r _ _ _ _ _ _) = r - getRange (NiceUnquoteDef r _ _ _ _ _) = r + getRange (NicePatternSyn r _ _ _ _) = r + getRange (NiceGeneralize r _ _ _ _ _) = r + getRange (NiceFunClause r _ _ _ _ _ _) = r + getRange (NiceUnquoteDecl r _ _ _ _ _ _ _) = r + getRange (NiceUnquoteDef r _ _ _ _ _ _) = r instance Pretty NiceDeclaration where pretty = \case Axiom _ _ _ _ _ x _ -> text "postulate" <+> pretty x <+> colon <+> text "_" - NiceField _ _ _ _ x _ -> text "field" <+> pretty x + NiceField _ _ _ _ _ x _ -> text "field" <+> pretty x PrimitiveFunction _ _ _ x _ -> text "primitive" <+> pretty x NiceMutual{} -> text "mutual" NiceModule _ _ _ x _ _ -> text "module" <+> pretty x <+> text "where" @@ -342,14 +388,14 @@ NiceRecSig _ _ _ _ _ x _ _ -> text "record" <+> pretty x NiceDataSig _ _ _ _ _ x _ _ -> text "data" <+> pretty x NiceFunClause{} -> text "" - FunSig _ _ _ _ _ _ _ x _ -> pretty x <+> colon <+> text "_" - FunDef _ _ _ _ _ x _ -> pretty x <+> text "= _" + FunSig _ _ _ _ _ _ _ _ x _ -> pretty x <+> colon <+> text "_" + FunDef _ _ _ _ _ _ x _ -> pretty x <+> text "= _" NiceDataDef _ _ _ _ _ x _ _ -> text "data" <+> pretty x <+> text "where" NiceRecDef _ _ _ _ _ x _ _ _ _ _ -> text "record" <+> pretty x <+> text "where" - NicePatternSyn _ x _ _ -> text "pattern" <+> pretty x - NiceGeneralize _ _ _ x _ -> text "variable" <+> pretty x - NiceUnquoteDecl _ _ _ _ _ xs _ -> text "" - NiceUnquoteDef _ _ _ _ xs _ -> text "" + NicePatternSyn _ _ x _ _ -> text "pattern" <+> pretty x + NiceGeneralize _ _ _ _ x _ -> text "variable" <+> pretty x + NiceUnquoteDecl _ _ _ _ _ _ xs _ -> text "" + NiceUnquoteDef _ _ _ _ _ xs _ -> text "" -- These error messages can (should) be terminated by a dot ".", -- there is no error context printed after them. @@ -383,9 +429,6 @@ pwords "Missing type signatures for unquoteDef" ++ map pretty xs pretty (BadMacroDef nd) = fsep $ [text $ declName nd] ++ pwords "are not allowed in macro blocks" - pretty (Codata _) = text $ - "The codata construction has been removed. " ++ - "Use the INFINITY builtin instead." pretty (DeclarationPanic s) = text s instance Pretty DeclarationWarning where @@ -400,9 +443,9 @@ ++ punctuate comma (map pretty xs) pretty (MissingDefinitions xs) = fsep $ pwords "The following names are declared but not accompanied by a definition:" - ++ punctuate comma (map pretty xs) + ++ punctuate comma (map (pretty . fst) xs) pretty (NotAllowedInMutual r nd) = fsep $ - [text nd] ++ pwords "in mutual blocks are not supported. Suggestion: get rid of mutual block by manually ordering declarations" + [text nd] ++ pwords "in mutual blocks are not supported. Suggestion: get rid of the mutual block by manually ordering declarations" pretty (PolarityPragmasButNotPostulates xs) = fsep $ pwords "Polarity pragmas have been given for the following identifiers which are not postulates:" ++ punctuate comma (map pretty xs) @@ -420,8 +463,11 @@ pretty (EmptyPostulate _) = fsep $ pwords "Empty postulate block." pretty (EmptyGeneralize _) = fsep $ pwords "Empty variable block." pretty (EmptyPrimitive _) = fsep $ pwords "Empty primitive block." + pretty (EmptyField _) = fsep $ pwords "Empty field block." pretty (InvalidTerminationCheckPragma _) = fsep $ pwords "Termination checking pragmas can only precede a function definition or a mutual block (that contains a function definition)." + pretty (InvalidCoverageCheckPragma _) = fsep $ + pwords "Coverage checking pragmas can only precede a function definition or a mutual block (that contains a function definition)." pretty (InvalidNoPositivityCheckPragma _) = fsep $ pwords "NO_POSITIVITY_CHECKING pragmas can only precede a data/record definition or a mutual block (that contains a data/record definition)." pretty (InvalidCatchallPragma _) = fsep $ @@ -432,6 +478,13 @@ pwords "Pragma {-# NO_TERMINATION_CHECK #-} has been removed. To skip the termination check, label your definitions either as {-# TERMINATING #-} or {-# NON_TERMINATING #-}." pretty (PragmaCompiled _) = fsep $ pwords "COMPILE pragma not allowed in safe mode." + pretty (OpenPublicAbstract _) = fsep $ + pwords "public does not have any effect in an abstract block." + pretty (OpenPublicPrivate _) = fsep $ + pwords "public does not have any effect in a private block." + pretty (ShadowingInTelescope nrs) = fsep $ + pwords "Shadowing in telescope, repeated variable names:" + ++ punctuate comma (map (pretty . fst) nrs) declName :: NiceDeclaration -> String declName Axiom{} = "Postulates" @@ -468,16 +521,16 @@ data DataRecOrFun = DataName - { kindPosCheck :: PositivityCheck - , kindUniCheck :: UniverseCheck + { _kindPosCheck :: PositivityCheck + , _kindUniCheck :: UniverseCheck } -- ^ Name of a data type | RecName - { kindPosCheck :: PositivityCheck - , kindUniCheck :: UniverseCheck + { _kindPosCheck :: PositivityCheck + , _kindUniCheck :: UniverseCheck } -- ^ Name of a record type - | FunName TerminationCheck + | FunName TerminationCheck CoverageCheck -- ^ Name of a function. deriving Data @@ -501,13 +554,17 @@ sameKind = (==) terminationCheck :: DataRecOrFun -> TerminationCheck -terminationCheck (FunName tc) = tc +terminationCheck (FunName tc _) = tc terminationCheck _ = TerminationCheck +coverageCheck :: DataRecOrFun -> CoverageCheck +coverageCheck (FunName _ cc) = cc +coverageCheck _ = YesCoverageCheck + positivityCheck :: DataRecOrFun -> PositivityCheck positivityCheck (DataName pc _) = pc positivityCheck (RecName pc _) = pc -positivityCheck _ = True +positivityCheck _ = YesPositivityCheck universeCheck :: DataRecOrFun -> UniverseCheck universeCheck (DataName _ uc) = uc @@ -517,8 +574,8 @@ -- | Check that declarations in a mutual block are consistently -- equipped with MEASURE pragmas, or whether there is a -- NO_TERMINATION_CHECK pragma. -combineTermChecks :: Range -> [TerminationCheck] -> Nice TerminationCheck -combineTermChecks r tcs = loop tcs where +combineTerminationChecks :: Range -> [TerminationCheck] -> Nice TerminationCheck +combineTerminationChecks r tcs = loop tcs where loop :: [TerminationCheck] -> Nice TerminationCheck loop [] = return TerminationCheck loop (tc : tcs) = do @@ -544,6 +601,12 @@ (NonTerminating , NoTerminationCheck ) -> failure r (NonTerminating , Terminating ) -> failure r +combineCoverageChecks :: [CoverageCheck] -> CoverageCheck +combineCoverageChecks = Fold.fold + +combinePositivityChecks :: [PositivityCheck] -> PositivityCheck +combinePositivityChecks = Fold.fold + -- | Nicifier monad. -- Preserve the state when throwing an exception. @@ -571,11 +634,25 @@ -- ^ Universe checking pragma waiting for a data/rec signature or definition. , _catchall :: Catchall -- ^ Catchall pragma waiting for a function clause. + , _covChk :: CoverageCheck + -- ^ Coverage pragma waiting for a definition. , niceWarn :: NiceWarnings -- ^ Stack of warnings. Head is last warning. } -type LoneSigs = Map Name DataRecOrFun +data LoneSig = LoneSig + { loneSigRange :: Range + , loneSigName :: Name + , loneSigKind :: DataRecOrFun + } + +type LoneSigs = Map Name LoneSig + -- ^ We retain the 'Name' also in the codomain since + -- 'Name' as a key is up to @Eq Name@ which ignores the range. + -- However, without range names are not unique in case the + -- user gives a second definition of the same name. + -- This causes then problems in 'replaceSigs' which might + -- replace the wrong signature. type NiceWarnings = [DeclarationWarning] -- ^ Stack of warnings. Head is last warning. @@ -585,9 +662,10 @@ initNiceEnv = NiceEnv { _loneSigs = empty , _termChk = TerminationCheck - , _posChk = True + , _posChk = YesPositivityCheck , _uniChk = YesUniverseCheck , _catchall = False + , _covChk = YesCoverageCheck , niceWarn = [] } @@ -600,9 +678,9 @@ -- | Adding a lone signature to the state. -addLoneSig :: Name -> DataRecOrFun -> Nice () -addLoneSig x k = loneSigs %== \ s -> do - let (mr, s') = Map.insertLookupWithKey (\ k new old -> new) x k s +addLoneSig :: Range -> Name -> DataRecOrFun -> Nice () +addLoneSig r x k = loneSigs %== \ s -> do + let (mr, s') = Map.insertLookupWithKey (\ _k new _old -> new) x (LoneSig r x k) s case mr of Nothing -> return s' Just{} -> throwError $ DuplicateDefinition x @@ -615,7 +693,7 @@ -- | Search for forward type signature. getSig :: Name -> Nice (Maybe DataRecOrFun) -getSig x = Map.lookup x <$> use loneSigs +getSig x = fmap loneSigKind . Map.lookup x <$> use loneSigs -- | Check that no lone signatures are left in the state. @@ -624,11 +702,25 @@ -- | Ensure that all forward declarations have been given a definition. -checkLoneSigs :: Map Name DataRecOrFun -> Nice () +forgetLoneSigs :: Nice () +forgetLoneSigs = loneSigs .= Map.empty + +checkLoneSigs :: LoneSigs -> Nice () checkLoneSigs xs = do - loneSigs .= Map.empty - unless (Map.null xs) (niceWarning $ MissingDefinitions $ Map.keys xs) + forgetLoneSigs + unless (Map.null xs) $ niceWarning $ MissingDefinitions $ + map (\s -> (loneSigName s , loneSigRange s)) $ Map.elems xs +-- | Get names of lone function signatures. + +loneFuns :: LoneSigs -> [Name] +loneFuns = map fst . filter (isFunName . loneSigKind . snd) . Map.toList + +-- | Create a 'LoneSigs' map from an association list. + +loneSigsFromLoneNames :: [(Range, Name, DataRecOrFun)] -> LoneSigs +loneSigsFromLoneNames = Map.fromList . map (\(r,x,k) -> (x, LoneSig r x k)) + -- | Lens for field '_termChk'. terminationCheckPragma :: Lens' TerminationCheck NiceEnv @@ -642,6 +734,17 @@ terminationCheckPragma .= tc_old return result +coverageCheckPragma :: Lens' CoverageCheck NiceEnv +coverageCheckPragma f e = f (_covChk e) <&> \ s -> e { _covChk = s } + +withCoverageCheckPragma :: CoverageCheck -> Nice a -> Nice a +withCoverageCheckPragma tc f = do + tc_old <- use coverageCheckPragma + coverageCheckPragma .= tc + result <- f + coverageCheckPragma .= tc_old + return result + -- | Lens for field '_posChk'. positivityCheckPragma :: Lens' PositivityCheck NiceEnv @@ -700,19 +803,19 @@ niceWarning w = modify $ \ st -> st { niceWarn = w : niceWarn st } data DeclKind - = LoneSig DataRecOrFun Name + = LoneSigDecl Range DataRecOrFun Name | LoneDefs DataRecOrFun [Name] | OtherDecl deriving (Eq, Show) declKind :: NiceDeclaration -> DeclKind -declKind (FunSig _ _ _ _ _ _ tc x _) = LoneSig (FunName tc) x -declKind (NiceRecSig _ _ _ pc uc x pars _) = LoneSig (RecName pc uc) x -declKind (NiceDataSig _ _ _ pc uc x pars _) = LoneSig (DataName pc uc) x -declKind (FunDef r _ abs ins tc x _) = LoneDefs (FunName tc) [x] +declKind (FunSig r _ _ _ _ _ tc cc x _) = LoneSigDecl r (FunName tc cc) x +declKind (NiceRecSig r _ _ pc uc x pars _) = LoneSigDecl r (RecName pc uc) x +declKind (NiceDataSig r _ _ pc uc x pars _) = LoneSigDecl r (DataName pc uc) x +declKind (FunDef r _ abs ins tc cc x _) = LoneDefs (FunName tc cc) [x] declKind (NiceDataDef _ _ _ pc uc x pars _) = LoneDefs (DataName pc uc) [x] declKind (NiceRecDef _ _ _ pc uc x _ _ _ pars _)= LoneDefs (RecName pc uc) [x] -declKind (NiceUnquoteDef _ _ _ tc xs _) = LoneDefs (FunName tc) xs +declKind (NiceUnquoteDef _ _ _ tc cc xs _) = LoneDefs (FunName tc cc) xs declKind Axiom{} = OtherDecl declKind NiceField{} = OtherDecl declKind PrimitiveFunction{} = OtherDecl @@ -730,7 +833,7 @@ -- | Replace (Data/Rec/Fun)Sigs with Axioms for postulated names -- The first argument is a list of axioms only. replaceSigs - :: Map Name DataRecOrFun -- ^ Lone signatures to be turned into Axioms + :: LoneSigs -- ^ Lone signatures to be turned into Axioms -> [NiceDeclaration] -- ^ Declarations containing them -> [NiceDeclaration] -- ^ In the output, everything should be defined replaceSigs ps = if Map.null ps then id else \case @@ -739,7 +842,11 @@ case replaceable d of -- If declaration d of x is mentioned in the map of lone signatures then replace -- it with an axiom - Just (x, axiom) | (Just{}, ps') <- Map.updateLookupWithKey (\ _ _ -> Nothing) x ps + Just (x, axiom) + | (Just (LoneSig _ x' _), ps') <- Map.updateLookupWithKey (\ _ _ -> Nothing) x ps + , getRange x == getRange x' + -- Use the range as UID to ensure we do not replace the wrong signature. + -- This could happen if the user wrote a duplicate definition. -> axiom : replaceSigs ps' ds _ -> d : replaceSigs ps ds @@ -749,7 +856,7 @@ -- @Axiom@ out of it. replaceable :: NiceDeclaration -> Maybe (Name, NiceDeclaration) replaceable = \case - FunSig r acc abst inst _ argi _ x e -> + FunSig r acc abst inst _ argi _ _ x e -> Just (x, Axiom r acc abst inst argi x e) NiceRecSig r acc abst _ _ x pars t -> let e = Generalized $ makePi (lamBindingsToTelescope r pars) t in @@ -792,37 +899,42 @@ case declKind d of OtherDecl -> (d :) <$> inferMutualBlocks ds LoneDefs{} -> (d :) <$> inferMutualBlocks ds -- Andreas, 2017-10-09, issue #2576: report error in ConcreteToAbstract - LoneSig k x -> do - addLoneSig x k - let tcpc = (pure . terminationCheck) &&& (pure . positivityCheck) $ k - ((tcs, pcs), (nds0, ds1)) <- untilAllDefined tcpc ds + LoneSigDecl r k x -> do + addLoneSig r x k + let tcccpc = ([terminationCheck k], [coverageCheck k], [positivityCheck k]) + ((tcs, ccs, pcs), (nds0, ds1)) <- untilAllDefined tcccpc ds -- If we still have lone signatures without any accompanying definition, -- we postulate the definition and substitute the axiom for the lone signature ps <- use loneSigs checkLoneSigs ps let ds0 = replaceSigs ps (d : nds0) -- NB: don't forget the LoneSig the block started with! -- We then keep processing the rest of the block - tc <- combineTermChecks (getRange d) tcs - (NiceMutual (getRange ds0) tc (and pcs) ds0 :) <$> inferMutualBlocks ds1 + tc <- combineTerminationChecks (getRange d) tcs + let cc = combineCoverageChecks ccs + let pc = combinePositivityChecks pcs + (NiceMutual (getRange ds0) tc cc pc ds0 :) <$> inferMutualBlocks ds1 where - untilAllDefined :: ([TerminationCheck], [PositivityCheck]) + untilAllDefined :: ([TerminationCheck], [CoverageCheck], [PositivityCheck]) -> [NiceDeclaration] - -> Nice (([TerminationCheck], [PositivityCheck]), ([NiceDeclaration], [NiceDeclaration])) - untilAllDefined tcpc@(tc, pc) ds = do + -> Nice (([TerminationCheck], [CoverageCheck], [PositivityCheck]) -- checks for this block + , ([NiceDeclaration] -- mutual block + , [NiceDeclaration]) -- leftovers + ) + untilAllDefined tcccpc@(tc, cc, pc) ds = do done <- noLoneSigs - if done then return (tcpc, ([], ds)) else + if done then return (tcccpc, ([], ds)) else case ds of - [] -> return (tcpc, ([], ds)) + [] -> return (tcccpc, ([], ds)) d : ds -> case declKind d of - LoneSig k x -> do - addLoneSig x k - let tcpc' = (terminationCheck k : tc, positivityCheck k : pc) - cons d (untilAllDefined tcpc' ds) + LoneSigDecl r k x -> do + addLoneSig r x k + let tcccpc' = (terminationCheck k : tc, coverageCheck k : cc, positivityCheck k : pc) + cons d (untilAllDefined tcccpc' ds) LoneDefs k xs -> do mapM_ removeLoneSig xs - let tcpc' = (terminationCheck k : tc, positivityCheck k : pc) - cons d (untilAllDefined tcpc' ds) - OtherDecl -> cons d (untilAllDefined tcpc ds) + let tcccpc' = (terminationCheck k : tc, coverageCheck k : cc, positivityCheck k : pc) + cons d (untilAllDefined tcccpc' ds) + OtherDecl -> cons d (untilAllDefined tcccpc ds) where -- ASR (26 December 2015): Type annotated version of the @cons@ function. -- cons d = fmap $ @@ -847,26 +959,30 @@ case d of - (TypeSig info x t) -> do + TypeSig info _tac x t -> do termCheck <- use terminationCheckPragma + covCheck <- use coverageCheckPragma let r = getRange d -- register x as lone type signature, to recognize clauses later - addLoneSig x $ FunName termCheck - return ([FunSig r PublicAccess ConcreteDef NotInstanceDef NotMacroDef info termCheck x t] , ds) + addLoneSig r x $ FunName termCheck covCheck + return ([FunSig r PublicAccess ConcreteDef NotInstanceDef NotMacroDef info termCheck covCheck x t] , ds) + -- Should not show up: all FieldSig are part of a Field block + FieldSig{} -> __IMPOSSIBLE__ + Generalize r [] -> justWarning $ EmptyGeneralize r Generalize r sigs -> do gs <- forM sigs $ \case - sig@(TypeSig info x t) -> do - return $ NiceGeneralize (getRange sig) PublicAccess info x t + sig@(TypeSig info tac x t) -> do + return $ NiceGeneralize (getRange sig) PublicAccess info tac x t _ -> __IMPOSSIBLE__ return (gs, ds) (FunClause lhs _ _ _) -> do termCheck <- use terminationCheckPragma + covCheck <- use coverageCheckPragma catchall <- popCatchallPragma - xs <- map fst . filter (isFunName . snd) . Map.toList - <$> use loneSigs + xs <- loneFuns <$> use loneSigs -- for each type signature 'x' waiting for clauses, we try -- if we have some clauses for 'x' case [ (x, (fits, rest)) @@ -882,38 +998,37 @@ [] -> case lhs of -- Subcase: The lhs is single identifier (potentially anonymous). -- Treat it as a function clause without a type signature. - LHS p [] [] | Just x <- isSingleIdentifierP p -> do - d <- mkFunDef defaultArgInfo termCheck x Nothing [d] -- fun def without type signature is relevant + LHS p [] [] _ | Just x <- isSingleIdentifierP p -> do + d <- mkFunDef defaultArgInfo termCheck covCheck x Nothing [d] -- fun def without type signature is relevant return (d , ds) -- Subcase: The lhs is a proper pattern. -- This could be a let-pattern binding. Pass it on. -- A missing type signature error might be raise in ConcreteToAbstract _ -> do - return ([NiceFunClause (getRange d) PublicAccess ConcreteDef termCheck catchall d] , ds) + return ([NiceFunClause (getRange d) PublicAccess ConcreteDef termCheck covCheck catchall d] , ds) -- case: clauses match exactly one of the sigs [(x,(fits,rest))] -> do removeLoneSig x ds <- expandEllipsis fits cs <- mkClauses x ds False - return ([FunDef (getRange fits) fits ConcreteDef NotInstanceDef termCheck x cs] , rest) + return ([FunDef (getRange fits) fits ConcreteDef NotInstanceDef termCheck covCheck x cs] , rest) -- case: clauses match more than one sigs (ambiguity) - l -> throwError $ AmbiguousFunClauses lhs $ reverse $ map fst l -- "ambiguous function clause; cannot assign it uniquely to one type signature" + l -> throwError $ AmbiguousFunClauses lhs $ reverse $ map fst l + -- "ambiguous function clause; cannot assign it uniquely to one type signature" - Field{} -> (,ds) <$> niceAxioms FieldBlock [ d ] - DataSig r CoInductive _ _ _ -> throwError (Codata r) - Data r CoInductive _ _ _ _ -> throwError (Codata r) - DataDef r CoInductive _ _ _ -> throwError (Codata r) + Field r [] -> justWarning $ EmptyField r + Field _ fs -> (,ds) <$> niceAxioms FieldBlock fs - DataSig r Inductive x tel t -> do + DataSig r x tel t -> do pc <- use positivityCheckPragma uc <- use universeCheckPragma - addLoneSig x $ DataName pc uc + addLoneSig r x $ DataName pc uc (,) <$> dataOrRec pc uc NiceDataDef NiceDataSig (niceAxioms DataBlock) r x (Just (tel, t)) Nothing <*> return ds - Data r Inductive x tel t cs -> do + Data r x tel t cs -> do pc <- use positivityCheckPragma -- Andreas, 2018-10-27, issue #3327 -- Propagate {-# NO_UNIVERSE_CHECK #-} pragma from signature to definition. @@ -925,7 +1040,7 @@ (,) <$> dataOrRec pc uc NiceDataDef NiceDataSig (niceAxioms DataBlock) r x ((tel,) <$> mt) (Just (tel, cs)) <*> return ds - DataDef r Inductive x tel cs -> do + DataDef r x tel cs -> do pc <- use positivityCheckPragma -- Andreas, 2018-10-27, issue #3327 -- Propagate {-# NO_UNIVERSE_CHECK #-} pragma from signature to definition. @@ -940,7 +1055,7 @@ RecordSig r x tel t -> do pc <- use positivityCheckPragma uc <- use universeCheckPragma - addLoneSig x $ RecName pc uc + addLoneSig r x $ RecName pc uc return ([NiceRecSig r PublicAccess ConcreteDef pc uc x tel t] , ds) Record r x i e c tel t cs -> do @@ -969,9 +1084,13 @@ return r x ((tel,) <$> mt) (Just (tel, cs)) <*> return ds - Mutual r [] -> justWarning $ EmptyMutual r - Mutual r ds' -> - (,ds) <$> (singleton <$> (mkOldMutual r =<< nice ds')) + Mutual r ds' -> do + -- The lone signatures encountered so far are not in scope + -- for the mutual definition + forgetLoneSigs + case ds' of + [] -> justWarning $ EmptyMutual r + _ -> (,ds) <$> (singleton <$> (mkOldMutual r =<< nice ds')) Abstract r [] -> justWarning $ EmptyAbstract r Abstract r ds' -> @@ -1008,21 +1127,22 @@ Syntax _ _ -> return ([], ds) PatternSyn r n as p -> do - return ([NicePatternSyn r n as p] , ds) + return ([NicePatternSyn r PublicAccess n as p] , ds) Open r x is -> return ([NiceOpen r x is] , ds) Import r x as op is -> return ([NiceImport r x as op is] , ds) UnquoteDecl r xs e -> do - tc <- use terminationCheckPragma - return ([NiceUnquoteDecl r PublicAccess ConcreteDef NotInstanceDef tc xs e] , ds) + tc <- use terminationCheckPragma + cc <- use coverageCheckPragma + return ([NiceUnquoteDecl r PublicAccess ConcreteDef NotInstanceDef tc cc xs e] , ds) UnquoteDef r xs e -> do - sigs <- map fst . filter (isFunName . snd) . Map.toList <$> use loneSigs + sigs <- loneFuns <$> use loneSigs let missing = filter (`notElem` sigs) xs if null missing then do mapM_ removeLoneSig xs - return ([NiceUnquoteDef r PublicAccess ConcreteDef TerminationCheck xs e] , ds) + return ([NiceUnquoteDef r PublicAccess ConcreteDef TerminationCheck YesCoverageCheck xs e] , ds) else throwError $ UnquoteDefRequiresSignature missing Pragma p -> nicePragma p ds @@ -1049,6 +1169,13 @@ niceWarning $ InvalidTerminationCheckPragma r nice1 ds + nicePragma (NoCoverageCheckPragma r) ds = + if canHaveCoverageCheckPragma ds then + withCoverageCheckPragma NoCoverageCheck $ nice1 ds + else do + niceWarning $ InvalidCoverageCheckPragma r + nice1 ds + nicePragma (CatchallPragma r) ds = if canHaveCatchallPragma ds then withCatchallPragma True $ nice1 ds @@ -1058,7 +1185,7 @@ nicePragma (NoPositivityCheckPragma r) ds = if canHaveNoPositivityCheckPragma ds then - withPositivityCheckPragma False $ nice1 ds + withPositivityCheckPragma NoPositivityCheck $ nice1 ds else do niceWarning $ InvalidNoPositivityCheckPragma r nice1 ds @@ -1098,6 +1225,9 @@ (Pragma p) | isAttachedPragma p -> canHaveTerminationCheckPragma ds _ -> False + canHaveCoverageCheckPragma :: [Declaration] -> Bool + canHaveCoverageCheckPragma = canHaveTerminationCheckPragma + canHaveCatchallPragma :: [Declaration] -> Bool canHaveCatchallPragma [] = False canHaveCatchallPragma (d:ds) = case d of @@ -1109,9 +1239,9 @@ canHaveNoPositivityCheckPragma [] = False canHaveNoPositivityCheckPragma (d:ds) = case d of Mutual _ ds -> any (canHaveNoPositivityCheckPragma . singleton) ds - Data _ Inductive _ _ _ _ -> True - DataSig _ Inductive _ _ _ -> True - DataDef _ Inductive _ _ _ -> True + Data{} -> True + DataSig{} -> True + DataDef{} -> True Record{} -> True RecordSig{} -> True RecordDef{} -> True @@ -1121,9 +1251,9 @@ canHaveNoUniverseCheckPragma :: [Declaration] -> Bool canHaveNoUniverseCheckPragma [] = False canHaveNoUniverseCheckPragma (d:ds) = case d of - Data _ Inductive _ _ _ _ -> True - DataSig _ Inductive _ _ _ -> True - DataDef _ Inductive _ _ _ -> True + Data{} -> True + DataSig{} -> True + DataDef{} -> True Record{} -> True RecordSig{} -> True RecordDef{} -> True @@ -1191,13 +1321,13 @@ niceAxiom :: KindOfBlock -> TypeSignatureOrInstanceBlock -> Nice [NiceDeclaration] niceAxiom b d = case d of - TypeSig rel x t -> do + TypeSig rel _tac x t -> do return [ Axiom (getRange d) PublicAccess ConcreteDef NotInstanceDef rel x t ] - Field i x argt | b == FieldBlock -> do - return [ NiceField (getRange d) PublicAccess ConcreteDef i x argt ] + FieldSig i tac x argt | b == FieldBlock -> do + return [ NiceField (getRange d) PublicAccess ConcreteDef i tac x argt ] InstanceB r decls -> do instanceBlock r =<< niceAxioms InstanceBlock decls - Pragma p@(RewritePragma r _) -> do + Pragma p@(RewritePragma r _ _) -> do return [ NicePragma r p ] _ -> throwError $ WrongContentBlock b $ getRange d @@ -1206,11 +1336,11 @@ toPrim _ = __IMPOSSIBLE__ -- Create a function definition. - mkFunDef info termCheck x mt ds0 = do + mkFunDef info termCheck covCheck x mt ds0 = do ds <- expandEllipsis ds0 cs <- mkClauses x ds False - return [ FunSig (fuseRange x t) PublicAccess ConcreteDef NotInstanceDef NotMacroDef info termCheck x t - , FunDef (getRange ds0) ds0 ConcreteDef NotInstanceDef termCheck x cs ] + return [ FunSig (fuseRange x t) PublicAccess ConcreteDef NotInstanceDef NotMacroDef info termCheck covCheck x t + , FunDef (getRange ds0) ds0 ConcreteDef NotInstanceDef termCheck covCheck x cs ] where t = case mt of Just t -> t @@ -1221,7 +1351,8 @@ expandEllipsis :: [Declaration] -> Nice [Declaration] expandEllipsis [] = return [] - expandEllipsis (d@(FunClause lhs@(LHS p _ _) _ _ _) : ds) + expandEllipsis (d@(FunClause lhs@(LHS p _ _ ell) _ _ _) : ds) + | ExpandedEllipsis{} <- ell = __IMPOSSIBLE__ | hasEllipsis p = (d :) <$> expandEllipsis ds | otherwise = (d :) <$> expand (killRange p) ds where @@ -1231,13 +1362,14 @@ case d of Pragma (CatchallPragma _) -> do (d :) <$> expand p ds - FunClause (LHS p0 eqs es) rhs wh ca -> do + FunClause (LHS p0 eqs es NoEllipsis) rhs wh ca -> do case hasEllipsis' p0 of ManyHoles -> throwError $ MultipleEllipses p0 - OneHole cxt -> do + OneHole cxt ~(EllipsisP r) -> do -- Replace the ellipsis by @p@. let p1 = cxt p - let d' = FunClause (LHS p1 eqs es) rhs wh ca + let ell = ExpandedEllipsis r (numberOfWithPatterns p) + let d' = FunClause (LHS p1 eqs es ell) rhs wh ca -- If we have with-expressions (es /= []) then the following -- ellipses also get the additional patterns in p0. (d' :) <$> expand (if null es then p else killRange p1) ds @@ -1276,10 +1408,10 @@ -- A clause is a subclause if the number of with-patterns is -- greater or equal to the current number of with-patterns plus the -- number of with arguments. - numWith = numberOfWithPatterns p + length es where LHS p _ es = lhs + numWith = numberOfWithPatterns p + length (filter visible es) where LHS p _ es _ = lhs subClauses :: [Declaration] -> ([Declaration],[Declaration]) - subClauses (c@(FunClause (LHS p0 _ _) _ _ _) : cs) + subClauses (c@(FunClause (LHS p0 _ _ _) _ _ _) : cs) | isEllipsis p0 || numberOfWithPatterns p0 >= numWith = mapFst (c:) (subClauses cs) | otherwise = ([], c:cs) @@ -1293,7 +1425,7 @@ -- for finding clauses for a type sig in mutual blocks couldBeFunClauseOf :: Maybe Fixity' -> Name -> Declaration -> Bool couldBeFunClauseOf mFixity x (Pragma (CatchallPragma{})) = True - couldBeFunClauseOf mFixity x (FunClause (LHS p _ _) _ _ _) = hasEllipsis p || + couldBeFunClauseOf mFixity x (FunClause (LHS p _ _ _) _ _ _) = hasEllipsis p || let pns = patternNames p xStrings = nameStringParts x @@ -1304,7 +1436,7 @@ -- trace ("xStrings = " ++ show xStrings) $ -- trace ("patStrings = " ++ show patStrings) $ -- trace ("mFixity = " ++ show mFixity) $ - case (headMaybe pns, mFixity) of + case (listToMaybe pns, mFixity) of -- first identifier in the patterns is the fun.symbol? (Just y, _) | x == y -> True -- trace ("couldBe since y = " ++ prettyShow y) $ True -- are the parts of x contained in p @@ -1327,7 +1459,7 @@ -> Nice NiceDeclaration -- ^ Returns a 'NiceMutual'. mkOldMutual r ds' = do -- Postulate the missing definitions - let ps = Map.fromList loneNames + let ps = loneSigsFromLoneNames loneNames checkLoneSigs ps let ds = replaceSigs ps ds' @@ -1358,8 +1490,9 @@ Axiom{} -> top NiceField{} -> top PrimitiveFunction{} -> top - -- Nested mutual blocks should have been flattened by now. - NiceMutual{} -> __IMPOSSIBLE__ + -- Andreas, 2019-07-23 issue #3932: + -- Nested mutual blocks are not supported. + NiceMutual{} -> invalid "mutual blocks" -- Andreas, 2018-10-29, issue #3246 -- We could allow modules (top), but this is potentially confusing. NiceModule{} -> invalid "Module definitions" @@ -1375,7 +1508,7 @@ FunDef{} -> bottom NiceDataDef{} -> bottom NiceRecDef{} -> bottom - -- Andreas, 2018-05-11, issue #3052, allow pat.syn.s in mutual blocks + -- Andreas, 2018-05-11, issue #3051, allow pat.syn.s in mutual blocks -- Andreas, 2018-10-29: We shift pattern synonyms to the bottom -- since they might refer to constructors defined in a data types -- just above them. @@ -1406,6 +1539,7 @@ ImpossiblePragma{} -> top -- error thrown in scope checker EtaPragma{} -> bottom -- needs record definition WarningOnUsage{} -> top + WarningOnImport{} -> top InjectivePragma{} -> top -- only needs name, not definition DisplayPragma{} -> top -- only for printing @@ -1415,6 +1549,7 @@ NoPositivityCheckPragma{} -> __IMPOSSIBLE__ PolarityPragma{} -> __IMPOSSIBLE__ NoUniverseCheckPragma{} -> __IMPOSSIBLE__ + NoCoverageCheckPragma{} -> __IMPOSSIBLE__ -- -- Pull type signatures to the top -- let (sigs, other) = List.partition isTypeSig ds @@ -1432,14 +1567,19 @@ -- Compute termination checking flag for mutual block tc0 <- use terminationCheckPragma let tcs = map termCheck ds - tc <- combineTermChecks r (tc0:tcs) + tc <- combineTerminationChecks r (tc0:tcs) + -- Compute coverage checking flag for mutual block + cc0 <- use coverageCheckPragma + let ccs = map covCheck ds + let cc = combineCoverageChecks (cc0:ccs) + -- Compute positivity checking flag for mutual block pc0 <- use positivityCheckPragma - let pc :: PositivityCheck - pc = pc0 && all positivityCheckOldMutual ds + let pcs = map positivityCheckOldMutual ds + let pc = combinePositivityChecks (pc0:pcs) - return $ NiceMutual r tc pc $ top ++ bottom + return $ NiceMutual r tc cc pc $ top ++ bottom -- return $ NiceMutual r tc pc $ other ++ defs -- return $ NiceMutual r tc pc $ sigs ++ other where @@ -1448,54 +1588,80 @@ -- isTypeSig d | LoneSig{} <- declKind d = True -- isTypeSig _ = False - sigNames = [ (x, k) | LoneSig k x <- map declKind ds' ] + sigNames = [ (r, x, k) | LoneSigDecl r k x <- map declKind ds' ] defNames = [ (x, k) | LoneDefs k xs <- map declKind ds', x <- xs ] -- compute the set difference with equality just on names - loneNames = [ (x, k) | (x, k) <- sigNames, List.all ((x /=) . fst) defNames ] + loneNames = [ (r, x, k) | (r, x, k) <- sigNames, List.all ((x /=) . fst) defNames ] + termCheck :: NiceDeclaration -> TerminationCheck -- Andreas, 2013-02-28 (issue 804): -- do not termination check a mutual block if any of its -- inner declarations comes with a {-# NO_TERMINATION_CHECK #-} - termCheck (FunSig _ _ _ _ _ _ tc _ _) = tc - termCheck (FunDef _ _ _ _ tc _ _) = tc + termCheck (FunSig _ _ _ _ _ _ tc _ _ _) = tc + termCheck (FunDef _ _ _ _ tc _ _ _) = tc -- ASR (28 December 2015): Is this equation necessary? - termCheck (NiceMutual _ tc _ _) = __IMPOSSIBLE__ - termCheck (NiceUnquoteDecl _ _ _ _ tc _ _) = tc - termCheck (NiceUnquoteDef _ _ _ tc _ _) = tc - termCheck Axiom{} = TerminationCheck - termCheck NiceField{} = TerminationCheck - termCheck PrimitiveFunction{} = TerminationCheck - termCheck NiceModule{} = TerminationCheck - termCheck NiceModuleMacro{} = TerminationCheck - termCheck NiceOpen{} = TerminationCheck - termCheck NiceImport{} = TerminationCheck - termCheck NicePragma{} = TerminationCheck - termCheck NiceRecSig{} = TerminationCheck - termCheck NiceDataSig{} = TerminationCheck - termCheck NiceFunClause{} = TerminationCheck - termCheck NiceDataDef{} = TerminationCheck - termCheck NiceRecDef{} = TerminationCheck - termCheck NicePatternSyn{} = TerminationCheck - termCheck NiceGeneralize{} = TerminationCheck + termCheck (NiceMutual _ tc _ _ _) = tc + termCheck (NiceUnquoteDecl _ _ _ _ tc _ _ _) = tc + termCheck (NiceUnquoteDef _ _ _ tc _ _ _) = tc + termCheck Axiom{} = TerminationCheck + termCheck NiceField{} = TerminationCheck + termCheck PrimitiveFunction{} = TerminationCheck + termCheck NiceModule{} = TerminationCheck + termCheck NiceModuleMacro{} = TerminationCheck + termCheck NiceOpen{} = TerminationCheck + termCheck NiceImport{} = TerminationCheck + termCheck NicePragma{} = TerminationCheck + termCheck NiceRecSig{} = TerminationCheck + termCheck NiceDataSig{} = TerminationCheck + termCheck NiceFunClause{} = TerminationCheck + termCheck NiceDataDef{} = TerminationCheck + termCheck NiceRecDef{} = TerminationCheck + termCheck NicePatternSyn{} = TerminationCheck + termCheck NiceGeneralize{} = TerminationCheck + covCheck :: NiceDeclaration -> CoverageCheck + covCheck (FunSig _ _ _ _ _ _ _ cc _ _) = cc + covCheck (FunDef _ _ _ _ _ cc _ _) = cc + -- ASR (28 December 2015): Is this equation necessary? + covCheck (NiceMutual _ _ cc _ _) = cc + covCheck (NiceUnquoteDecl _ _ _ _ _ cc _ _) = cc + covCheck (NiceUnquoteDef _ _ _ _ cc _ _) = cc + covCheck Axiom{} = YesCoverageCheck + covCheck NiceField{} = YesCoverageCheck + covCheck PrimitiveFunction{} = YesCoverageCheck + covCheck NiceModule{} = YesCoverageCheck + covCheck NiceModuleMacro{} = YesCoverageCheck + covCheck NiceOpen{} = YesCoverageCheck + covCheck NiceImport{} = YesCoverageCheck + covCheck NicePragma{} = YesCoverageCheck + covCheck NiceRecSig{} = YesCoverageCheck + covCheck NiceDataSig{} = YesCoverageCheck + covCheck NiceFunClause{} = YesCoverageCheck + covCheck NiceDataDef{} = YesCoverageCheck + covCheck NiceRecDef{} = YesCoverageCheck + covCheck NicePatternSyn{} = YesCoverageCheck + covCheck NiceGeneralize{} = YesCoverageCheck + + + -- ASR (26 December 2015): Do not positivity check a mutual -- block if any of its inner declarations comes with a -- NO_POSITIVITY_CHECK pragma. See Issue 1614. positivityCheckOldMutual :: NiceDeclaration -> PositivityCheck positivityCheckOldMutual (NiceDataDef _ _ _ pc _ _ _ _) = pc positivityCheckOldMutual (NiceDataSig _ _ _ pc _ _ _ _) = pc - positivityCheckOldMutual (NiceMutual _ _ pc _) = __IMPOSSIBLE__ + positivityCheckOldMutual (NiceMutual _ _ _ pc _) = pc positivityCheckOldMutual (NiceRecSig _ _ _ pc _ _ _ _) = pc - positivityCheckOldMutual (NiceRecDef _ _ _ pc _ _ _ _ _ _ _)= pc - positivityCheckOldMutual _ = True + positivityCheckOldMutual (NiceRecDef _ _ _ pc _ _ _ _ _ _ _) = pc + positivityCheckOldMutual _ = YesPositivityCheck -- A mutual block cannot have a measure, -- but it can skip termination check. abstractBlock _ [] = return [] abstractBlock r ds = do - let (ds', anyChange) = runChange $ mkAbstract ds - inherited = r == noRange + (ds', anyChange) <- runChangeT $ mkAbstract ds + let inherited = r == noRange if anyChange then return ds' else do -- hack to avoid failing on inherited abstract blocks in where clauses unless inherited $ niceWarning $ UselessAbstract r @@ -1503,56 +1669,62 @@ privateBlock _ _ [] = return [] privateBlock r o ds = do - let (ds', anyChange) = runChange $ mkPrivate o ds + (ds', anyChange) <- runChangeT $ mkPrivate o ds if anyChange then return ds' else do when (o == UserWritten) $ niceWarning $ UselessPrivate r return ds -- no change! + instanceBlock + :: Range -- ^ Range of @instance@ keyword. + -> [NiceDeclaration] + -> Nice [NiceDeclaration] instanceBlock _ [] = return [] instanceBlock r ds = do - let (ds', anyChange) = runChange $ mapM mkInstance ds + let (ds', anyChange) = runChange $ mapM (mkInstance r) ds if anyChange then return ds' else do niceWarning $ UselessInstance r return ds -- no change! -- Make a declaration eligible for instance search. - mkInstance :: Updater NiceDeclaration - mkInstance d = - case d of - Axiom r p a i rel x e -> (\ i -> Axiom r p a i rel x e) <$> setInstance i - FunSig r p a i m rel tc x e -> (\ i -> FunSig r p a i m rel tc x e) <$> setInstance i - NiceUnquoteDecl r p a i tc x e -> (\ i -> NiceUnquoteDecl r p a i tc x e) <$> setInstance i - NiceMutual r termCheck pc ds -> NiceMutual r termCheck pc <$> mapM mkInstance ds - NiceFunClause{} -> return d - FunDef r ds a i tc x cs -> (\ i -> FunDef r ds a i tc x cs) <$> setInstance i - NiceField{} -> return d -- Field instance are handled by the parser - PrimitiveFunction{} -> return d - NiceUnquoteDef{} -> return d - NiceRecSig{} -> return d - NiceDataSig{} -> return d - NiceModuleMacro{} -> return d - NiceModule{} -> return d - NicePragma{} -> return d - NiceOpen{} -> return d - NiceImport{} -> return d - NiceDataDef{} -> return d - NiceRecDef{} -> return d - NicePatternSyn{} -> return d - NiceGeneralize{} -> return d + mkInstance + :: Range -- ^ Range of @instance@ keyword. + -> Updater NiceDeclaration + mkInstance r0 = \case + Axiom r p a i rel x e -> (\ i -> Axiom r p a i rel x e) <$> setInstance r0 i + FunSig r p a i m rel tc cc x e -> (\ i -> FunSig r p a i m rel tc cc x e) <$> setInstance r0 i + NiceUnquoteDecl r p a i tc cc x e -> (\ i -> NiceUnquoteDecl r p a i tc cc x e) <$> setInstance r0 i + NiceMutual r tc cc pc ds -> NiceMutual r tc cc pc <$> mapM (mkInstance r0) ds + d@NiceFunClause{} -> return d + FunDef r ds a i tc cc x cs -> (\ i -> FunDef r ds a i tc cc x cs) <$> setInstance r0 i + d@NiceField{} -> return d -- Field instance are handled by the parser + d@PrimitiveFunction{} -> return d + d@NiceUnquoteDef{} -> return d + d@NiceRecSig{} -> return d + d@NiceDataSig{} -> return d + d@NiceModuleMacro{} -> return d + d@NiceModule{} -> return d + d@NicePragma{} -> return d + d@NiceOpen{} -> return d + d@NiceImport{} -> return d + d@NiceDataDef{} -> return d + d@NiceRecDef{} -> return d + d@NicePatternSyn{} -> return d + d@NiceGeneralize{} -> return d - setInstance :: Updater IsInstance - setInstance i = case i of - InstanceDef -> return i - _ -> dirty $ InstanceDef + setInstance + :: Range -- ^ Range of @instance@ keyword. + -> Updater IsInstance + setInstance r0 = \case + i@InstanceDef{} -> return i + _ -> dirty $ InstanceDef r0 macroBlock r ds = mapM mkMacro ds mkMacro :: NiceDeclaration -> Nice NiceDeclaration - mkMacro d = - case d of - FunSig r p a i _ rel tc x e -> return $ FunSig r p a i MacroDef rel tc x e - FunDef{} -> return d - _ -> throwError (BadMacroDef d) + mkMacro = \case + FunSig r p a i _ rel tc cc x e -> return $ FunSig r p a i MacroDef rel tc cc x e + d@FunDef{} -> return d + d -> throwError (BadMacroDef d) -- | Make a declaration abstract. -- @@ -1563,8 +1735,8 @@ -- Then, nested @abstract@s would sometimes also be complained about. class MakeAbstract a where - mkAbstract :: Updater a - default mkAbstract :: (Traversable f, MakeAbstract a', a ~ f a') => Updater a + mkAbstract :: UpdaterT Nice a + default mkAbstract :: (Traversable f, MakeAbstract a', a ~ f a') => UpdaterT Nice a mkAbstract = traverse mkAbstract instance MakeAbstract a => MakeAbstract [a] where @@ -1576,39 +1748,40 @@ -- mkAbstract = traverse mkAbstract instance MakeAbstract IsAbstract where - mkAbstract a = case a of - AbstractDef -> return a + mkAbstract = \case + a@AbstractDef -> return a ConcreteDef -> dirty $ AbstractDef instance MakeAbstract NiceDeclaration where - mkAbstract d = - case d of - NiceMutual r termCheck pc ds -> NiceMutual r termCheck pc <$> mkAbstract ds - FunDef r ds a i tc x cs -> (\ a -> FunDef r ds a i tc x) <$> mkAbstract a <*> mkAbstract cs + mkAbstract = \case + NiceMutual r termCheck cc pc ds -> NiceMutual r termCheck cc pc <$> mkAbstract ds + FunDef r ds a i tc cc x cs -> (\ a -> FunDef r ds a i tc cc x) <$> mkAbstract a <*> mkAbstract cs NiceDataDef r o a pc uc x ps cs -> (\ a -> NiceDataDef r o a pc uc x ps) <$> mkAbstract a <*> mkAbstract cs NiceRecDef r o a pc uc x i e c ps cs -> (\ a -> NiceRecDef r o a pc uc x i e c ps) <$> mkAbstract a <*> return cs - NiceFunClause r p a termCheck catchall d -> (\ a -> NiceFunClause r p a termCheck catchall d) <$> mkAbstract a + NiceFunClause r p a tc cc catchall d -> (\ a -> NiceFunClause r p a tc cc catchall d) <$> mkAbstract a -- The following declarations have an @InAbstract@ field -- but are not really definitions, so we do count them into -- the declarations which can be made abstract -- (thus, do not notify progress with @dirty@). Axiom r p a i rel x e -> return $ Axiom r p AbstractDef i rel x e - FunSig r p a i m rel tc x e -> return $ FunSig r p AbstractDef i m rel tc x e + FunSig r p a i m rel tc cc x e -> return $ FunSig r p AbstractDef i m rel tc cc x e NiceRecSig r p a pc uc x ls t -> return $ NiceRecSig r p AbstractDef pc uc x ls t NiceDataSig r p a pc uc x ls t -> return $ NiceDataSig r p AbstractDef pc uc x ls t - NiceField r p _ i x e -> return $ NiceField r p AbstractDef i x e + NiceField r p _ i tac x e -> return $ NiceField r p AbstractDef i tac x e PrimitiveFunction r p _ x e -> return $ PrimitiveFunction r p AbstractDef x e -- Andreas, 2016-07-17 it does have effect on unquoted defs. -- Need to set updater state to dirty! - NiceUnquoteDecl r p _ i t x e -> dirty $ NiceUnquoteDecl r p AbstractDef i t x e - NiceUnquoteDef r p _ t x e -> dirty $ NiceUnquoteDef r p AbstractDef t x e - NiceModule{} -> return d - NiceModuleMacro{} -> return d - NicePragma{} -> return d - NiceOpen{} -> return d - NiceImport{} -> return d - NicePatternSyn{} -> return d - NiceGeneralize{} -> return d + NiceUnquoteDecl r p _ i tc cc x e -> tellDirty $> NiceUnquoteDecl r p AbstractDef i tc cc x e + NiceUnquoteDef r p _ tc cc x e -> tellDirty $> NiceUnquoteDef r p AbstractDef tc cc x e + d@NiceModule{} -> return d + d@NiceModuleMacro{} -> return d + d@NicePragma{} -> return d + d@(NiceOpen _ _ directives) -> do + whenJust (publicOpen directives) $ lift . niceWarning . OpenPublicAbstract + return d + d@NiceImport{} -> return d + d@NicePatternSyn{} -> return d + d@NiceGeneralize{} -> return d instance MakeAbstract Clause where mkAbstract (Clause x catchall lhs rhs wh with) = do @@ -1630,8 +1803,8 @@ -- Then, nested @private@s would sometimes also be complained about. class MakePrivate a where - mkPrivate :: Origin -> Updater a - default mkPrivate :: (Traversable f, MakePrivate a', a ~ f a') => Origin -> Updater a + mkPrivate :: Origin -> UpdaterT Nice a + default mkPrivate :: (Traversable f, MakePrivate a', a ~ f a') => Origin -> UpdaterT Nice a mkPrivate o = traverse $ mkPrivate o instance MakePrivate a => MakePrivate [a] where @@ -1643,35 +1816,36 @@ -- mkPrivate = traverse mkPrivate instance MakePrivate Access where - mkPrivate o p = case p of - PrivateAccess{} -> return p -- OR? return $ PrivateAccess o - _ -> dirty $ PrivateAccess o + mkPrivate o = \case + p@PrivateAccess{} -> return p -- OR? return $ PrivateAccess o + _ -> dirty $ PrivateAccess o instance MakePrivate NiceDeclaration where - mkPrivate o d = - case d of - Axiom r p a i rel x e -> (\ p -> Axiom r p a i rel x e) <$> mkPrivate o p - NiceField r p a i x e -> (\ p -> NiceField r p a i x e) <$> mkPrivate o p - PrimitiveFunction r p a x e -> (\ p -> PrimitiveFunction r p a x e) <$> mkPrivate o p - NiceMutual r termCheck pc ds -> (\ p -> NiceMutual r termCheck pc p) <$> mkPrivate o ds - NiceModule r p a x tel ds -> (\ p -> NiceModule r p a x tel ds) <$> mkPrivate o p - NiceModuleMacro r p x ma op is -> (\ p -> NiceModuleMacro r p x ma op is) <$> mkPrivate o p - FunSig r p a i m rel tc x e -> (\ p -> FunSig r p a i m rel tc x e) <$> mkPrivate o p - NiceRecSig r p a pc uc x ls t -> (\ p -> NiceRecSig r p a pc uc x ls t) <$> mkPrivate o p - NiceDataSig r p a pc uc x ls t -> (\ p -> NiceDataSig r p a pc uc x ls t) <$> mkPrivate o p - NiceFunClause r p a termCheck catchall d -> (\ p -> NiceFunClause r p a termCheck catchall d) <$> mkPrivate o p - NiceUnquoteDecl r p a i t x e -> (\ p -> NiceUnquoteDecl r p a i t x e) <$> mkPrivate o p - NiceUnquoteDef r p a t x e -> (\ p -> NiceUnquoteDef r p a t x e) <$> mkPrivate o p - NiceGeneralize r p i x t -> (\ p -> NiceGeneralize r p i x t) <$> mkPrivate o p - NicePragma _ _ -> return $ d - NiceOpen _ _ _ -> return $ d - NiceImport _ _ _ _ _ -> return $ d + mkPrivate o = \case + Axiom r p a i rel x e -> (\ p -> Axiom r p a i rel x e) <$> mkPrivate o p + NiceField r p a i tac x e -> (\ p -> NiceField r p a i tac x e) <$> mkPrivate o p + PrimitiveFunction r p a x e -> (\ p -> PrimitiveFunction r p a x e) <$> mkPrivate o p + NiceMutual r tc cc pc ds -> (\ ds-> NiceMutual r tc cc pc ds) <$> mkPrivate o ds + NiceModule r p a x tel ds -> (\ p -> NiceModule r p a x tel ds) <$> mkPrivate o p + NiceModuleMacro r p x ma op is -> (\ p -> NiceModuleMacro r p x ma op is) <$> mkPrivate o p + FunSig r p a i m rel tc cc x e -> (\ p -> FunSig r p a i m rel tc cc x e) <$> mkPrivate o p + NiceRecSig r p a pc uc x ls t -> (\ p -> NiceRecSig r p a pc uc x ls t) <$> mkPrivate o p + NiceDataSig r p a pc uc x ls t -> (\ p -> NiceDataSig r p a pc uc x ls t) <$> mkPrivate o p + NiceFunClause r p a tc cc catchall d -> (\ p -> NiceFunClause r p a tc cc catchall d) <$> mkPrivate o p + NiceUnquoteDecl r p a i tc cc x e -> (\ p -> NiceUnquoteDecl r p a i tc cc x e) <$> mkPrivate o p + NiceUnquoteDef r p a tc cc x e -> (\ p -> NiceUnquoteDef r p a tc cc x e) <$> mkPrivate o p + NicePatternSyn r p x xs p' -> (\ p -> NicePatternSyn r p x xs p') <$> mkPrivate o p + NiceGeneralize r p i tac x t -> (\ p -> NiceGeneralize r p i tac x t) <$> mkPrivate o p + d@NicePragma{} -> return d + d@(NiceOpen _ _ directives) -> do + whenJust (publicOpen directives) $ lift . niceWarning . OpenPublicPrivate + return d + d@NiceImport{} -> return d -- Andreas, 2016-07-08, issue #2089 -- we need to propagate 'private' to the named where modules - FunDef r ds a i tc x cls -> FunDef r ds a i tc x <$> mkPrivate o cls - NiceDataDef{} -> return $ d - NiceRecDef{} -> return $ d - NicePatternSyn _ _ _ _ -> return $ d + FunDef r ds a i tc cc x cls -> FunDef r ds a i tc cc x <$> mkPrivate o cls + d@NiceDataDef{} -> return d + d@NiceRecDef{} -> return d instance MakePrivate Clause where mkPrivate o (Clause x catchall lhs rhs wh with) = do @@ -1694,38 +1868,36 @@ -- | (Approximately) convert a 'NiceDeclaration' back to a list of -- 'Declaration's. notSoNiceDeclarations :: NiceDeclaration -> [Declaration] -notSoNiceDeclarations d = - case d of - Axiom _ _ _ i rel x e -> inst i [TypeSig rel x e] - NiceField _ _ _ i x argt -> [Field i x argt] - PrimitiveFunction r _ _ x e -> [Primitive r [TypeSig defaultArgInfo x e]] - NiceMutual r _ _ ds -> [Mutual r $ concatMap notSoNiceDeclarations ds] +notSoNiceDeclarations = \case + Axiom _ _ _ i rel x e -> inst i [TypeSig rel Nothing x e] + NiceField _ _ _ i tac x argt -> [FieldSig i tac x argt] + PrimitiveFunction r _ _ x e -> [Primitive r [TypeSig defaultArgInfo Nothing x e]] + NiceMutual r _ _ _ ds -> [Mutual r $ concatMap notSoNiceDeclarations ds] NiceModule r _ _ x tel ds -> [Module r x tel ds] NiceModuleMacro r _ x ma o dir -> [ModuleMacro r x ma o dir] NiceOpen r x dir -> [Open r x dir] NiceImport r x as o dir -> [Import r x as o dir] NicePragma _ p -> [Pragma p] NiceRecSig r _ _ _ _ x bs e -> [RecordSig r x bs e] - NiceDataSig r _ _ _ _ x bs e -> [DataSig r Inductive x bs e] - NiceFunClause _ _ _ _ _ d -> [d] - FunSig _ _ _ i _ rel tc x e -> inst i [TypeSig rel x e] - FunDef _r ds _ _ _ _ _ -> ds - NiceDataDef r _ _ _ _ x bs cs -> [DataDef r Inductive x bs $ concatMap notSoNiceDeclarations cs] + NiceDataSig r _ _ _ _ x bs e -> [DataSig r x bs e] + NiceFunClause _ _ _ _ _ _ d -> [d] + FunSig _ _ _ i _ rel _ _ x e -> inst i [TypeSig rel Nothing x e] + FunDef _ ds _ _ _ _ _ _ -> ds + NiceDataDef r _ _ _ _ x bs cs -> [DataDef r x bs $ concatMap notSoNiceDeclarations cs] NiceRecDef r _ _ _ _ x i e c bs ds -> [RecordDef r x i e c bs ds] - NicePatternSyn r n as p -> [PatternSyn r n as p] - NiceGeneralize r _ i n e -> [Generalize r [TypeSig i n e]] - NiceUnquoteDecl r _ _ i _ x e -> inst i [UnquoteDecl r x e] - NiceUnquoteDef r _ _ _ x e -> [UnquoteDef r x e] + NicePatternSyn r _ n as p -> [PatternSyn r n as p] + NiceGeneralize r _ i tac n e -> [Generalize r [TypeSig i tac n e]] + NiceUnquoteDecl r _ _ i _ _ x e -> inst i [UnquoteDecl r x e] + NiceUnquoteDef r _ _ _ _ x e -> [UnquoteDef r x e] where - inst InstanceDef ds = [InstanceB (getRange ds) ds] - inst NotInstanceDef ds = ds + inst (InstanceDef r) ds = [InstanceB r ds] + inst NotInstanceDef ds = ds -- | Has the 'NiceDeclaration' a field of type 'IsAbstract'? niceHasAbstract :: NiceDeclaration -> Maybe IsAbstract -niceHasAbstract d = - case d of +niceHasAbstract = \case Axiom{} -> Nothing - NiceField _ _ a _ _ _ -> Just a + NiceField _ _ a _ _ _ _ -> Just a PrimitiveFunction _ _ a _ _ -> Just a NiceMutual{} -> Nothing NiceModule _ _ a _ _ _ -> Just a @@ -1735,12 +1907,12 @@ NicePragma{} -> Nothing NiceRecSig{} -> Nothing NiceDataSig{} -> Nothing - NiceFunClause _ _ a _ _ _ -> Just a + NiceFunClause _ _ a _ _ _ _ -> Just a FunSig{} -> Nothing - FunDef _ _ a _ _ _ _ -> Just a + FunDef _ _ a _ _ _ _ _ -> Just a NiceDataDef _ _ a _ _ _ _ _ -> Just a NiceRecDef _ _ a _ _ _ _ _ _ _ _ -> Just a NicePatternSyn{} -> Nothing NiceGeneralize{} -> Nothing - NiceUnquoteDecl _ _ a _ _ _ _ -> Just a - NiceUnquoteDef _ _ a _ _ _ -> Just a + NiceUnquoteDecl _ _ a _ _ _ _ _ -> Just a + NiceUnquoteDef _ _ a _ _ _ _ -> Just a diff --git a/src/full/Agda/Syntax/Concrete/Fixity.hs b/src/full/Agda/Syntax/Concrete/Fixity.hs --- a/src/full/Agda/Syntax/Concrete/Fixity.hs +++ b/src/full/Agda/Syntax/Concrete/Fixity.hs @@ -1,4 +1,4 @@ -{-# LANGUAGE CPP #-} +{-# LANGUAGE CPP #-} -- | Collecting fixity declarations (and polarity pragmas) for concrete -- declarations. module Agda.Syntax.Concrete.Fixity @@ -13,21 +13,22 @@ import qualified Data.Map as Map import Data.Set (Set) import qualified Data.Set as Set +#if __GLASGOW_HASKELL__ < 804 import Data.Semigroup +#endif +import Agda.Syntax.Builtin (builtinsNoDef) import Agda.Syntax.Common -import Agda.Syntax.Position +import Agda.Syntax.Concrete import Agda.Syntax.Fixity import Agda.Syntax.Notation -import Agda.Syntax.Concrete -import Agda.Syntax.Builtin (builtinsNoDef) +import Agda.Syntax.Position import Agda.TypeChecking.Positivity.Occurrence (Occurrence) import Agda.Utils.Functor import Agda.Utils.Null import Agda.Utils.Impossible -#include "undefined.h" type Fixities = Map Name Fixity' type Polarities = Map Name [Occurrence] @@ -52,11 +53,11 @@ where -- Merge two fixities, assuming there is no conflict mergeFixites name (Fixity' f1 s1 r1) (Fixity' f2 s2 r2) = Fixity' f s $ fuseRange r1 r2 - where f | f1 == noFixity = f2 - | f2 == noFixity = f1 + where f | null f1 = f2 + | null f2 = f1 | otherwise = __IMPOSSIBLE__ - s | s1 == noNotation = s2 - | s2 == noNotation = s1 + s | null s1 = s2 + | null s2 = s1 | otherwise = __IMPOSSIBLE__ -- Compute a list of conflicts in a format suitable for error reporting. @@ -65,8 +66,8 @@ -- Check for no conflict. compatible (Fixity' f1 s1 _) (Fixity' f2 s2 _) = - (f1 == noFixity || f2 == noFixity ) && - (s1 == noNotation || s2 == noNotation) + (null f1 || null f2) && + (null s1 || null s2) -- | While 'Fixities' and Polarities are not semigroups under disjoint -- union (which might fail), we get a semigroup instance for the @@ -156,6 +157,7 @@ -- We expand these boring cases to trigger a revisit -- in case the @Declaration@ type is extended in the future. TypeSig {} -> mempty + FieldSig {} -> mempty Generalize {} -> mempty Field {} -> mempty FunClause {} -> mempty @@ -176,7 +178,7 @@ UnquoteDef {} -> mempty Pragma {} -> mempty -data DeclaredNames = DeclaredNames { allNames, postulates, privateNames :: Set Name } +data DeclaredNames = DeclaredNames { _allNames, _postulates, _privateNames :: Set Name } instance Semigroup DeclaredNames where DeclaredNames xs ps as <> DeclaredNames ys qs bs = @@ -202,15 +204,16 @@ -- i.e., do not go into modules. declaredNames :: Declaration -> DeclaredNames declaredNames d = case d of - TypeSig _ x _ -> declaresName x - Field _ x _ -> declaresName x - FunClause (LHS p [] []) _ _ _ + TypeSig _ _ x _ -> declaresName x + FieldSig _ _ x _ -> declaresName x + Field _ fs -> foldMap declaredNames fs + FunClause (LHS p [] [] _) _ _ _ | IdentP (QName x) <- removeSingletonRawAppP p -> declaresName x FunClause{} -> mempty - DataSig _ _ x _ _ -> declaresName x - DataDef _ _ _ _ cs -> foldMap declaredNames cs - Data _ _ x _ _ cs -> declaresName x <> foldMap declaredNames cs + DataSig _ x _ _ -> declaresName x + DataDef _ _ _ cs -> foldMap declaredNames cs + Data _ x _ _ cs -> declaresName x <> foldMap declaredNames cs RecordSig _ x _ _ -> declaresName x RecordDef _ x _ _ c _ _ -> declaresNames $ foldMap (:[]) (fst <$> c) Record _ x _ _ c _ _ _ -> declaresNames $ x : foldMap (:[]) (fst <$> c) @@ -234,6 +237,5 @@ -- BUILTIN pragmas which do not require an accompanying definition declare -- the (unqualified) name they mention. Pragma (BuiltinPragma _ b (QName x)) - | b `elem` builtinsNoDef -> declaresName x + | rangedThing b `elem` builtinsNoDef -> declaresName x Pragma{} -> mempty - diff --git a/src/full/Agda/Syntax/Concrete/Generic.hs b/src/full/Agda/Syntax/Concrete/Generic.hs --- a/src/full/Agda/Syntax/Concrete/Generic.hs +++ b/src/full/Agda/Syntax/Concrete/Generic.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} -- | Generic traversal and reduce for concrete syntax, -- in the style of "Agda.Syntax.Internal.Generic". @@ -7,16 +6,13 @@ module Agda.Syntax.Concrete.Generic where -import Data.Traversable -import Data.Monoid -import Data.Foldable +import Data.Bifunctor import Agda.Syntax.Common import Agda.Syntax.Concrete import Agda.Utils.Either -#include "undefined.h" import Agda.Utils.Impossible -- | Generic traversals for concrete expressions. @@ -37,6 +33,9 @@ -- * Instances for things that do not contain expressions. +instance ExprLike () where + mapExpr f = id + instance ExprLike Name where mapExpr f = id @@ -48,6 +47,11 @@ -- * Instances for functors. +instance ExprLike a => ExprLike (WithHiding a) where + mapExpr = fmap . mapExpr + traverseExpr = traverse . traverseExpr + foldExpr = foldMap . foldExpr + instance ExprLike a => ExprLike (Named name a) where mapExpr = fmap . mapExpr traverseExpr = traverse . traverseExpr @@ -74,7 +78,7 @@ foldExpr = foldMap . foldExpr instance (ExprLike a, ExprLike b) => ExprLike (Either a b) where - mapExpr f = mapEither (mapExpr f) (mapExpr f) + mapExpr f = bimap (mapExpr f) (mapExpr f) traverseExpr f = traverseEither (traverseExpr f) (traverseExpr f) foldExpr f = either (foldExpr f) (foldExpr f) @@ -135,15 +139,14 @@ RecUpdate r e es -> f $ RecUpdate r (mapE e) $ mapE es Let r ds e -> f $ Let r (mapE ds) $ mapE e Paren r e -> f $ Paren r $ mapE e - IdiomBrackets r e -> f $ IdiomBrackets r $ mapE e + IdiomBrackets r es -> f $ IdiomBrackets r $ mapE es DoBlock r ss -> f $ DoBlock r $ mapE ss Absurd{} -> f $ e0 As r x e -> f $ As r x $ mapE e Dot r e -> f $ Dot r $ mapE e + DoubleDot r e -> f $ DoubleDot r $ mapE e ETel tel -> f $ ETel $ mapE tel - QuoteGoal r x e -> f $ QuoteGoal r x $ mapE e - QuoteContext r -> f $ e0 - Tactic r e es -> f $ Tactic r (mapE e) $ mapE es + Tactic r e -> f $ Tactic r (mapE e) Quote{} -> f $ e0 QuoteTerm{} -> f $ e0 Unquote{} -> f $ e0 @@ -177,9 +180,14 @@ instance ExprLike LHS where mapExpr f e0 = case e0 of - LHS ps res wes -> LHS ps (mapE res) $ mapE wes + LHS ps res wes ell -> LHS ps (mapE res) (mapE wes) ell where mapE e = mapExpr f e +instance (ExprLike qn, ExprLike e) => ExprLike (RewriteEqn' qn p e) where + mapExpr f = \case + Rewrite es -> Rewrite (mapExpr f es) + Invert qn pes -> Invert qn (map (mapExpr f <$>) pes) + instance ExprLike LamClause where mapExpr f (LamClause lhs rhs wh ca) = LamClause (mapExpr f lhs) (mapExpr f rhs) (mapExpr f wh) (mapExpr f ca) @@ -196,19 +204,20 @@ where mapE e = mapExpr f e instance ExprLike Declaration where - mapExpr f e0 = case e0 of - TypeSig ai x e -> TypeSig ai x $ mapE e - Field i x e -> Field i x $ mapE e + mapExpr f = \case + TypeSig ai t x e -> TypeSig ai (mapE t) x (mapE e) + FieldSig i t n e -> FieldSig i (mapE t) n (mapE e) + Field r fs -> Field r $ map (mapExpr f) fs FunClause lhs rhs wh ca -> FunClause (mapE lhs) (mapE rhs) (mapE wh) (mapE ca) - DataSig r ind x bs e -> DataSig r ind x (mapE bs) $ mapE e - DataDef r ind n bs cs -> DataDef r ind n (mapE bs) $ mapE cs - Data r ind n bs e cs -> Data r ind n (mapE bs) (mapE e) $ mapE cs + DataSig r x bs e -> DataSig r x (mapE bs) $ mapE e + DataDef r n bs cs -> DataDef r n (mapE bs) $ mapE cs + Data r n bs e cs -> Data r n (mapE bs) (mapE e) $ mapE cs RecordSig r ind bs e -> RecordSig r ind (mapE bs) $ mapE e RecordDef r n ind eta c tel ds -> RecordDef r n ind eta c (mapE tel) $ mapE ds Record r n ind eta c tel e ds -> Record r n ind eta c (mapE tel) (mapE e) $ mapE ds - Infix{} -> e0 - Syntax{} -> e0 - PatternSyn{} -> e0 + e@Infix{} -> e + e@Syntax{} -> e + e@PatternSyn{} -> e Mutual r ds -> Mutual r $ mapE ds Abstract r ds -> Abstract r $ mapE ds Private r o ds -> Private r o $ mapE ds @@ -217,13 +226,13 @@ Postulate r ds -> Postulate r $ mapE ds Primitive r ds -> Primitive r $ mapE ds Generalize r ds -> Generalize r $ mapE ds - Open{} -> e0 - Import{} -> e0 + e@Open{} -> e + e@Import{} -> e ModuleMacro r n es op dir -> ModuleMacro r n (mapE es) op dir Module r n tel ds -> Module r n (mapE tel) $ mapE ds UnquoteDecl r x e -> UnquoteDecl r x (mapE e) UnquoteDef r x e -> UnquoteDef r x (mapE e) - Pragma{} -> e0 + e@Pragma{} -> e where mapE e = mapExpr f e {- Template diff --git a/src/full/Agda/Syntax/Concrete/Name.hs b/src/full/Agda/Syntax/Concrete/Name.hs --- a/src/full/Agda/Syntax/Concrete/Name.hs +++ b/src/full/Agda/Syntax/Concrete/Name.hs @@ -1,24 +1,19 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE DeriveGeneric #-} -{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE TypeFamilies #-} -- for type equality ~ {-| Names in the concrete syntax are just strings (or lists of strings for qualified names). -} module Agda.Syntax.Concrete.Name where -#if MIN_VERSION_base(4,11,0) -import Prelude hiding ((<>)) -#endif - import Control.DeepSeq import Data.ByteString.Char8 (ByteString) import Data.Function +import qualified Data.Foldable as Fold import qualified Data.List as List import Data.Data (Data) -import Data.Maybe import GHC.Generics (Generic) @@ -29,12 +24,10 @@ import Agda.Utils.FileName import Agda.Utils.Lens -import Agda.Utils.List import Agda.Utils.Pretty import Agda.Utils.Size import Agda.Utils.Suffix -#include "undefined.h" import Agda.Utils.Impossible {-| A name is a non-empty list of alternating 'Id's and 'Hole's. A normal name @@ -299,12 +292,16 @@ qnameParts (Qual x q) = x : qnameParts q qnameParts (QName x) = [x] --- | Is the name qualified? +-- | Is the name (un)qualified? isQualified :: QName -> Bool isQualified Qual{} = True isQualified QName{} = False +isUnqualified :: QName -> Maybe Name +isUnqualified Qual{} = Nothing +isUnqualified (QName n) = Just n + ------------------------------------------------------------------------ -- * Operations on 'TopLevelModuleName' ------------------------------------------------------------------------ @@ -365,6 +362,9 @@ class IsNoName a where isNoName :: a -> Bool + default isNoName :: (Foldable t, IsNoName b, t b ~ a) => a -> Bool + isNoName = Fold.all isNoName + instance IsNoName String where isNoName = isUnderscore @@ -381,6 +381,9 @@ instance IsNoName QName where isNoName (QName x) = isNoName x isNoName Qual{} = False -- M.A._ does not qualify as empty name + +instance IsNoName a => IsNoName (Ranged a) where +instance IsNoName a => IsNoName (WithOrigin a) where -- no instance for TopLevelModuleName diff --git a/src/full/Agda/Syntax/Concrete/Operators.hs b/src/full/Agda/Syntax/Concrete/Operators.hs --- a/src/full/Agda/Syntax/Concrete/Operators.hs +++ b/src/full/Agda/Syntax/Concrete/Operators.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE GADTs #-} {-| The parser doesn't know about operators and parses everything as normal @@ -9,6 +8,7 @@ It also contains the function that puts parenthesis back given the precedence of the context. -} + module Agda.Syntax.Concrete.Operators ( parseApplication , parseModuleApplication @@ -17,9 +17,8 @@ , parsePatternSyn ) where -import Control.Applicative ( Alternative((<|>)), liftA2 ) -import Control.Arrow ((***), (&&&), first, second) -import Control.DeepSeq +import Control.Applicative ( Alternative((<|>))) +import Control.Arrow (second) import Control.Monad import Data.Either (partitionEithers) @@ -34,10 +33,8 @@ import Data.Traversable (traverse) import qualified Data.Traversable as Trav -import Agda.Syntax.Concrete.Pretty () import Agda.Syntax.Common import Agda.Syntax.Concrete hiding (appView) -import qualified Agda.Syntax.Concrete as C import Agda.Syntax.Concrete.Operators.Parser import Agda.Syntax.Concrete.Operators.Parser.Monad hiding (parse) import Agda.Syntax.Concrete.Pattern @@ -52,7 +49,6 @@ import qualified Agda.TypeChecking.Monad.Benchmark as Bench import Agda.TypeChecking.Monad.Debug import Agda.TypeChecking.Monad.State (getScope) -import Agda.TypeChecking.Monad.Options import Agda.Utils.Either import Agda.Utils.Pretty @@ -60,7 +56,6 @@ import Agda.Utils.Trie (Trie) import qualified Agda.Utils.Trie as Trie -#include "undefined.h" import Agda.Utils.Impossible --------------------------------------------------------------------------- @@ -86,18 +81,17 @@ -- | Compute all defined names in scope and their fixities/notations. -- Note that overloaded names (constructors) can have several -- fixities/notations. Then we 'mergeNotations'. (See issue 1194.) -getDefinedNames :: [KindOfName] -> FlatScope -> [[NewNotation]] +getDefinedNames :: KindsOfNames -> FlatScope -> [[NewNotation]] getDefinedNames kinds names = - [ mergeNotations $ - map (\d -> namesToNotation x (A.qnameName $ anameName d)) ds + [ mergeNotations $ map (namesToNotation x . A.qnameName . anameName) ds | (x, ds) <- Map.toList names - , any ((`elem` kinds) . anameKind) ds + , any ((`elemKindsOfNames` kinds) . anameKind) ds , not (null ds) + ] -- Andreas, 2013-03-21 see Issue 822 -- Names can have different kinds, i.e., 'defined' and 'constructor'. -- We need to consider all names that have *any* matching kind, -- not only those whose first appearing kind is matching. - ] -- | Compute all names (first component) and operators/notations -- (second component) in scope. @@ -106,7 +100,7 @@ let defs = getDefinedNames allKindsOfNames flat locals <- nubOn fst . notShadowedLocals <$> getLocalVars -- Note: Debug printout aligned with the one in buildParsers. - reportSLn "scope.operators" 50 $ unlines + reportS "scope.operators" 50 [ "flat = " ++ show flat , "defs = " ++ show defs , "locals= " ++ show locals @@ -122,11 +116,8 @@ opOrNot n = Left (notaName n) : if null (notation n) then [] else [Right n] --- | Data structure filled in by @buildParsers@. --- The top-level parser @pTop@ is of primary interest, --- but @pArgs@ is used to convert module application --- from concrete to abstract syntax. -data Parsers e = Parsers +-- | A data structure used internally by 'buildParsers'. +data InternalParsers e = InternalParsers { pTop :: Parser e e , pApp :: Parser e e , pArgs :: Parser e [NamedArg e] @@ -134,10 +125,28 @@ , pAtom :: Parser e e } -data ExprKind = IsPattern | IsExpr +-- | Expression kinds: Expressions or patterns. +data ExprKind = IsExpr | IsPattern deriving (Eq, Show) --- | Builds a parser for operator applications from all the operators +-- | The data returned by 'buildParsers'. + +data Parsers e = Parsers + { parser :: [e] -> [e] + -- ^ A parser for expressions or patterns (depending on the + -- 'ExprKind' argument given to 'buildParsers'). + , argsParser :: [e] -> [[NamedArg e]] + -- ^ A parser for sequences of arguments. + , operators :: [NotationSection] + -- ^ All operators/notations/sections that were used to generate + -- the grammar. + , flattenedScope :: FlatScope + -- ^ A flattened scope that only contains those names that are + -- unqualified or qualified by qualifiers that occur in the list + -- of names given to 'buildParser'. + } + +-- | Builds parsers for operator applications from all the operators -- and function symbols in scope. -- -- When parsing a pattern we do not use bound names. The effect is @@ -151,22 +160,23 @@ -- (@_+_@ is replaced by @_@, @+@ and @_@), and if we were to support -- sections in patterns, then we would have to accept certain such -- sequences of tokens as single pattern variables. --- --- The list of names must include every name part in the --- expression/pattern to be parsed (excluding name parts inside things --- like parenthesised subexpressions that are treated as atoms). The --- list is used to optimise the parser. For instance, a given notation --- is only included in the generated grammar if all of the notation's --- name parts are present in the list of names. --- --- The returned list contains all operators/notations/sections that --- were used to generate the grammar. -buildParsers :: - forall e. IsExpr e => - Range -> FlatScope -> ExprKind -> [QName] -> - ScopeM (ParseSections, [NotationSection], Parsers e) -buildParsers r flat kind exprNames = do +buildParsers + :: forall e. IsExpr e + => ExprKind + -- ^ Should expressions or patterns be parsed? + -> [QName] + -- ^ This list must include every name part in the + -- expression/pattern to be parsed (excluding name parts inside + -- things like parenthesised subexpressions that are treated as + -- atoms). The list is used to optimise the parser. For + -- instance, a given notation is only included in the generated + -- grammar if all of the notation's name parts are present in + -- the list of names. + -> ScopeM (Parsers e) +buildParsers kind exprNames = do + flat <- flattenScope (qualifierModules exprNames) <$> + getScope (names, ops) <- localNames flat let -- All names. @@ -264,7 +274,7 @@ (non, fix) = List.partition nonfix (filter (and . partsPresent) ops) cons = getDefinedNames - [ConName, FldName, PatternSynName] flat + (someKindsOfNames [ConName, FldName, PatternSynName]) flat conNames = Set.fromList $ filter (flip Set.member namesInExpr) $ map (notaName . head) cons @@ -327,7 +337,7 @@ -- The triples have the form (level, operators). The lowest -- level comes first. - relatedOperators :: [(Integer, [NotationSection])] + relatedOperators :: [(PrecedenceLevel, [NotationSection])] relatedOperators = map (\((l, ns) : rest) -> (l, ns ++ concat (map snd rest))) . List.groupBy ((==) `on` fst) . @@ -345,13 +355,13 @@ unrelatedOperators ++ nonWithSections - reportSLn "scope.operators" 50 $ unlines + reportS "scope.operators" 50 [ "unrelatedOperators = " ++ show unrelatedOperators , "nonWithSections = " ++ show nonWithSections , "relatedOperators = " ++ show relatedOperators ] - let g = Data.Function.fix $ \p -> Parsers + let g = Data.Function.fix $ \p -> InternalParsers { pTop = memoise TopK $ Fold.asum $ foldr ($) (pApp p) @@ -393,9 +403,14 @@ reportSDoc "scope.grammar" 10 $ return $ "Operator grammar:" $$ nest 2 (grammar (pTop g)) - return (parseSections, everything, g) + return $ Parsers + { parser = parse (parseSections, pTop g) + , argsParser = parse (parseSections, pArgs g) + , operators = everything + , flattenedScope = flat + } where - level :: NewNotation -> PrecedenceLevel + level :: NewNotation -> FixityLevel level = fixityLevel . notaFixity nonfix, isinfix, isprefix, ispostfix :: NewNotation -> Bool @@ -414,7 +429,7 @@ && fixityAssoc (notaFixity (sectNotation s)) == ass - mkP :: Either Integer Integer + mkP :: PrecedenceKey -- ^ Memoisation key. -> ParseSections -> Parser e e @@ -503,47 +518,30 @@ flip ($) <$> (noPlaceholder <$> (postLefts <|> higher)) <*> postLeft ---------------------------------------------------------------------------- --- * Helpers for pattern and lhs parsing ---------------------------------------------------------------------------- --- | View a pattern @p@ as a list @p0 .. pn@ where @p0@ is the identifier --- (in most cases a constructor). --- --- Pattern needs to be parsed already (operators resolved). -patternAppView :: Pattern -> [NamedArg Pattern] -patternAppView p = case p of - AppP p arg -> patternAppView p ++ [arg] - OpAppP _ x _ ps -> defaultNamedArg (IdentP x) : ps - ParenP _ p -> patternAppView p - RawAppP _ _ -> __IMPOSSIBLE__ - _ -> [ defaultNamedArg p ] - - --------------------------------------------------------------------------- -- * Parse functions --------------------------------------------------------------------------- -- | Returns the list of possible parses. -parsePat :: - (ParseSections, Parser Pattern Pattern) -> Pattern -> [Pattern] -parsePat prs p = case p of +parsePat :: ([Pattern] -> [Pattern]) -> Pattern -> [Pattern] +parsePat prs = \case AppP p (Arg info q) -> fullParen' <$> (AppP <$> parsePat prs p <*> (Arg info <$> traverse (parsePat prs) q)) - RawAppP _ ps -> fullParen' <$> (parsePat prs =<< parse prs ps) + RawAppP _ ps -> fullParen' <$> (parsePat prs =<< prs ps) OpAppP r d ns ps -> fullParen' . OpAppP r d ns <$> (mapM . traverse . traverse) (parsePat prs) ps HiddenP _ _ -> fail "bad hidden argument" InstanceP _ _ -> fail "bad instance argument" AsP r x p -> AsP r x <$> parsePat prs p - DotP r e -> return $ DotP r e + p@DotP{} -> return p ParenP r p -> fullParen' <$> parsePat prs p - WildP _ -> return p - AbsurdP _ -> return p - LitP _ -> return p - QuoteP _ -> return p - IdentP _ -> return p + p@WildP{} -> return p + p@AbsurdP{} -> return p + p@LitP{} -> return p + p@QuoteP{} -> return p + p@IdentP{} -> return p RecP r fs -> RecP r <$> mapM (traverse (parsePat prs)) fs - EqualP{} -> return p -- Andrea: cargo culted from DotP + p@EqualP{} -> return p -- Andrea: cargo culted from DotP EllipsisP _ -> fail "bad ellipsis" WithP r p -> WithP r <$> parsePat prs p @@ -584,52 +582,70 @@ - the applied patterns -} +-- | The result of 'parseLHS' is either a pattern ('Left') or a lhs ('Right'). type ParseLHS = Either Pattern (QName, LHSCore) --- | The returned list contains all operators/notations/sections that --- were used to generate the grammar. +-- | Parses a left-hand side, workhorse for 'parseLHS'. +-- +parseLHS' + :: LHSOrPatSyn + -- ^ Are we trying to parse a lhs or a pattern synonym? + -- For error reporting only! + -> Maybe QName + -- ^ Name of the function/patSyn definition if we parse a lhs. + -- 'Nothing' if we parse a pattern. + -> Pattern + -- ^ Thing to parse. + -> ScopeM (ParseLHS, [NotationSection]) + -- ^ The returned list contains all operators/notations/sections that + -- were used to generate the grammar. -parseLHS' :: - LHSOrPatSyn -> Maybe QName -> Pattern -> - ScopeM (ParseLHS, [NotationSection]) parseLHS' IsLHS (Just qn) (RawAppP _ [WildP{}]) = return (Right (qn, LHSHead qn []), []) + parseLHS' lhsOrPatSyn top p = do - let names = patternQNames p - ms = qualifierModules names - flat <- flattenScope ms <$> getScope - (parseSections, ops, parsers) <- - buildParsers (getRange p) flat IsPattern names - let patP = (parseSections, pTop parsers) - let cons = getNames [ConName, PatternSynName] flat - let flds = getNames [FldName] flat - case [ res | let result = parsePat patP p - , p' <- foldr seq () result `seq` result - , res <- validPattern (PatternCheckConfig top cons flds) p' ] of - [(p,lhs)] -> do reportSDoc "scope.operators" 50 $ return $ - "Parsed lhs:" <+> pretty lhs - return (lhs, ops) - [] -> typeError $ OperatorInformation ops + + -- Build parser. + patP <- buildParsers IsPattern (patternQNames p) + + -- Run parser, forcing result. + let ps = let result = parsePat (parser patP) p + in foldr seq () result `seq` result + + -- Classify parse results. + let cons = getNames (someKindsOfNames [ConName, PatternSynName]) + (flattenedScope patP) + let flds = getNames (someKindsOfNames [FldName]) + (flattenedScope patP) + let conf = PatternCheckConfig top cons flds + case mapMaybe (validPattern conf) ps of + -- Unique result. + [(_,lhs)] -> do reportS "scope.operators" 50 $ "Parsed lhs:" <+> pretty lhs + return (lhs, operators patP) + -- No result. + [] -> typeError $ OperatorInformation (operators patP) $ NoParseForLHS lhsOrPatSyn p - rs -> typeError $ OperatorInformation ops + -- Ambiguous result. + rs -> typeError $ OperatorInformation (operators patP) $ AmbiguousParseForLHS lhsOrPatSyn p $ map (fullParen . fst) rs where getNames kinds flat = map (notaName . head) $ getDefinedNames kinds flat - -- validPattern returns an empty or singleton list (morally a Maybe) - validPattern :: PatternCheckConfig -> Pattern -> [(Pattern, ParseLHS)] - validPattern conf p = case (classifyPattern conf p, top) of - (Just r@(Left _), Nothing) -> [(p, r)] -- expect pattern - (Just r@(Right _), Just{}) -> [(p, r)] -- expect lhs - _ -> [] + -- The pattern is retained for error reporting in case of ambiguous parses. + validPattern :: PatternCheckConfig -> Pattern -> Maybe (Pattern, ParseLHS) + validPattern conf p = + case (classifyPattern conf p, top) of + (Just res@Left{}, Nothing) -> Just (p, res) -- expect pattern + (Just res@Right{}, Just{}) -> Just (p, res) -- expect lhs + _ -> Nothing -- | Name sets for classifying a pattern. data PatternCheckConfig = PatternCheckConfig - { topName :: Maybe QName -- ^ name of defined symbol - , conNames :: [QName] -- ^ valid constructor names - , fldNames :: [QName] -- ^ valid field names + { topName :: Maybe QName -- ^ Name of defined symbol. + , conNames :: [QName] -- ^ Valid constructor names. + , fldNames :: [QName] -- ^ Valid field names. } -- | Returns zero or one classified patterns. @@ -722,28 +738,25 @@ -- for @Data.Nat._+_@ we return the list @[Data,Nat]@. qualifierModules :: [QName] -> [[Name]] qualifierModules qs = - List.nub $ filter (not . null) $ map (init . qnameParts) qs + nubOn id $ filter (not . null) $ map (init . qnameParts) qs -- | Parse a list of expressions into an application. parseApplication :: [Expr] -> ScopeM Expr parseApplication [e] = return e parseApplication es = billToParser IsExpr $ do -- Build the parser - let names = [ q | Ident q <- es ] - ms = qualifierModules names - flat <- flattenScope ms <$> getScope - (parseSections, ops, p) <- buildParsers (getRange es) flat IsExpr names + p <- buildParsers IsExpr [ q | Ident q <- es ] -- Parse - let result = parse (parseSections, pTop p) es + let result = parser p es case foldr seq () result `seq` result of [e] -> do reportSDoc "scope.operators" 50 $ return $ "Parsed an operator application:" <+> pretty e return e - [] -> typeError $ OperatorInformation ops + [] -> typeError $ OperatorInformation (operators p) $ NoParseForApplication es - es' -> typeError $ OperatorInformation ops + es' -> typeError $ OperatorInformation (operators p) $ AmbiguousParseForApplication es $ map fullParen es' @@ -757,21 +770,17 @@ m <- parseModuleIdentifier e -- Build the arguments parser - let names = [ q | Ident q <- es_args ] - ms = qualifierModules names - flat <- flattenScope ms <$> getScope - (parseSections, ops, p) <- - buildParsers (getRange es_args) flat IsExpr names + p <- buildParsers IsExpr [ q | Ident q <- es_args ] -- Parse -- TODO: not sure about forcing - case {-force $-} parse (parseSections, pArgs p) es_args of + case {-force $-} argsParser p es_args of [as] -> return (m, as) - [] -> typeError $ OperatorInformation ops + [] -> typeError $ OperatorInformation (operators p) $ NoParseForApplication es ass -> do let f = fullParen . foldl (App noRange) (Ident m) - typeError $ OperatorInformation ops + typeError $ OperatorInformation (operators p) $ AmbiguousParseForApplication es $ map f ass diff --git a/src/full/Agda/Syntax/Concrete/Operators/Parser.hs b/src/full/Agda/Syntax/Concrete/Operators/Parser.hs --- a/src/full/Agda/Syntax/Concrete/Operators/Parser.hs +++ b/src/full/Agda/Syntax/Concrete/Operators/Parser.hs @@ -1,13 +1,13 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE DataKinds #-} module Agda.Syntax.Concrete.Operators.Parser where import Control.Applicative ( Alternative((<|>), many) ) import Data.Either -import Data.Hashable +import Data.Kind ( Type ) import Data.Maybe import qualified Data.Strict.Maybe as Strict import Data.Set (Set) @@ -24,7 +24,6 @@ import Agda.Utils.Pretty import Agda.Utils.List ( spanEnd ) -#include "undefined.h" import Agda.Utils.Impossible placeholder :: PositionInName -> Parser e (MaybePlaceholder e) @@ -64,8 +63,9 @@ -- deriving (Show) class HasRange e => IsExpr e where - exprView :: e -> ExprView e - unExprView :: ExprView e -> e + exprView :: e -> ExprView e + unExprView :: ExprView e -> e + patternView :: e -> Maybe Pattern instance IsExpr e => HasRange (ExprView e) where getRange = getRange . unExprView @@ -92,6 +92,8 @@ WildV e -> e OtherV e -> e + patternView = isPattern + instance IsExpr Pattern where exprView e = case e of IdentP x -> LocalV x @@ -120,6 +122,8 @@ WildV e -> e OtherV e -> e + patternView = pure + -- | Should sections be parsed? data ParseSections = ParseSections | DoNotParseSections deriving (Eq, Show) @@ -210,24 +214,15 @@ _ -> Nothing _ -> Nothing --- | Either a wildcard (@_@), or an unqualified name (possibly --- containing multiple name parts). +-- | Parses a potentially pattern-matching binder -wildOrUnqualifiedName :: IsExpr e => Parser e (Maybe Name) -wildOrUnqualifiedName = - (Nothing <$ partP [] "_") - <|> - (satNoPlaceholder $ \e -> - case exprView e of - LocalV (QName n) -> Just (Just n) - WildV _ -> Just Nothing - _ -> Nothing) - <|> - Just <$> atLeastTwoParts +patternBinder :: IsExpr e => Parser e Binder +patternBinder = inOnePart <|> mkBinder_ <$> atLeastTwoParts + where inOnePart = satNoPlaceholder $ \ e -> isBinderP =<< patternView e -- | Used to define the return type of 'opP'. -type family OperatorType (k :: NotationKind) (e :: *) :: * +type family OperatorType (k :: NotationKind) (e :: Type) :: Type type instance OperatorType 'InfixNotation e = MaybePlaceholder e -> MaybePlaceholder e -> e type instance OperatorType 'PrefixNotation e = MaybePlaceholder e -> e type instance OperatorType 'PostfixNotation e = MaybePlaceholder e -> e @@ -236,7 +231,7 @@ -- | A singleton type for 'NotationKind' (except for the constructor -- 'NoNotation'). -data NK (k :: NotationKind) :: * where +data NK (k :: NotationKind) :: Type where In :: NK 'InfixNotation Pre :: NK 'PrefixNotation Post :: NK 'PostfixNotation @@ -313,20 +308,17 @@ p <*> worker ms xs worker ms (WildHole h : xs) = - (\(r, es) -> (r, Right (mkBinding h $ Name noRange InScope [Hole]) : es)) + (\(r, es) -> let anon = mkBinder_ (Name noRange InScope [Hole]) + in (r, Right (mkBinding h anon) : es)) <$> worker ms xs worker ms (BindHole _ h : xs) = do - (\e (r, es) -> - let x = case e of - Just name -> name - Nothing -> Name noRange InScope [Hole] - in (r, Right (mkBinding h x) : es)) + (\ b (r, es) -> (r, Right (mkBinding h b) : es)) -- Andreas, 2011-04-07 put just 'Relevant' here, is this -- correct? - <$> wildOrUnqualifiedName + <$> patternBinder <*> worker ms xs - mkBinding h x = (DomainFree $ defaultNamedArg $ mkBoundName_ x, h) + mkBinding h b = (DomainFree $ defaultNamedArg b, h) set x arg = fmap (fmap (const x)) arg diff --git a/src/full/Agda/Syntax/Concrete/Operators/Parser/Monad.hs b/src/full/Agda/Syntax/Concrete/Operators/Parser/Monad.hs --- a/src/full/Agda/Syntax/Concrete/Operators/Parser/Monad.hs +++ b/src/full/Agda/Syntax/Concrete/Operators/Parser/Monad.hs @@ -4,10 +4,9 @@ {-# LANGUAGE CPP #-} {-# LANGUAGE DeriveGeneric #-} -{-# LANGUAGE Rank2Types #-} module Agda.Syntax.Concrete.Operators.Parser.Monad - ( MemoKey(..) + ( MemoKey(..), PrecedenceKey , Parser , parse , sat' @@ -27,13 +26,15 @@ -- | Memoisation keys. -data MemoKey = NodeK (Either Integer Integer) - | PostLeftsK (Either Integer Integer) - | PreRightsK (Either Integer Integer) +data MemoKey = NodeK PrecedenceKey + | PostLeftsK PrecedenceKey + | PreRightsK PrecedenceKey | TopK | AppK | NonfixK deriving (Eq, Show, Generic) + +type PrecedenceKey = Either PrecedenceLevel PrecedenceLevel instance Hashable MemoKey diff --git a/src/full/Agda/Syntax/Concrete/Pattern.hs b/src/full/Agda/Syntax/Concrete/Pattern.hs --- a/src/full/Agda/Syntax/Concrete/Pattern.hs +++ b/src/full/Agda/Syntax/Concrete/Pattern.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE TypeFamilies #-} -- For type equality. -- | Tools for patterns in concrete syntax. @@ -6,7 +5,9 @@ module Agda.Syntax.Concrete.Pattern where import Control.Applicative ( liftA2 ) +import Control.Arrow ( first ) import Control.Monad.Identity +import Control.Monad.Writer import Data.Foldable (Foldable, foldMap) import Data.Traversable (Traversable, traverse) @@ -14,9 +15,11 @@ import Agda.Syntax.Common import Agda.Syntax.Concrete +import Agda.Syntax.Position import Agda.Utils.AffineHole import Agda.Utils.Functor +import Agda.Utils.Impossible import Agda.Utils.List import Agda.Utils.Maybe @@ -43,13 +46,13 @@ hasEllipsis p = case hasEllipsis' p of ZeroHoles _ -> False - OneHole _ -> True + OneHole _ _ -> True ManyHoles -> True -- | Does the lhs contain an ellipsis? instance HasEllipsis LHS where - hasEllipsis (LHS p _ _) = hasEllipsis p - + hasEllipsis (LHS p _ _ _) = hasEllipsis p + -- clauses that are already expanded don't have an ellipsis -- | Check for with-pattern @| p@. @@ -345,5 +348,36 @@ hasEllipsis' :: CPatternLike p => p -> AffineHole Pattern p hasEllipsis' = traverseCPatternA $ \ p mp -> case p of - EllipsisP _ -> OneHole id + EllipsisP{} -> OneHole id p _ -> mp + +reintroduceEllipsis :: ExpandedEllipsis -> Pattern -> Pattern +reintroduceEllipsis NoEllipsis p = p +reintroduceEllipsis (ExpandedEllipsis r k) p = + let core = EllipsisP r + wargs = snd $ splitEllipsis k $ patternAppView p + in foldl AppP core wargs + +splitEllipsis :: (IsWithP p) => Int -> [p] -> ([p],[p]) +splitEllipsis k [] = ([] , []) +splitEllipsis k (p:ps) + | isJust (isWithP p) = if + | k == 0 -> ([] , p:ps) + | otherwise -> first (p:) $ splitEllipsis (k-1) ps + | otherwise = first (p:) $ splitEllipsis k ps + +--------------------------------------------------------------------------- +-- * Helpers for pattern and lhs parsing +--------------------------------------------------------------------------- + +-- | View a pattern @p@ as a list @p0 .. pn@ where @p0@ is the identifier +-- (in most cases a constructor). +-- +-- Pattern needs to be parsed already (operators resolved). +patternAppView :: Pattern -> [NamedArg Pattern] +patternAppView p = case p of + AppP p arg -> patternAppView p ++ [arg] + OpAppP _ x _ ps -> defaultNamedArg (IdentP x) : ps + ParenP _ p -> patternAppView p + RawAppP _ _ -> __IMPOSSIBLE__ + _ -> [ defaultNamedArg p ] diff --git a/src/full/Agda/Syntax/Concrete/Pretty.hs b/src/full/Agda/Syntax/Concrete/Pretty.hs --- a/src/full/Agda/Syntax/Concrete/Pretty.hs +++ b/src/full/Agda/Syntax/Concrete/Pretty.hs @@ -1,19 +1,13 @@ {-# OPTIONS_GHC -fno-warn-orphans #-} -{-# LANGUAGE CPP #-} {-| Pretty printer for the concrete syntax. -} module Agda.Syntax.Concrete.Pretty where -#if MIN_VERSION_base(4,11,0) -import Prelude hiding ( (<>), null ) -#else import Prelude hiding ( null ) -#endif import Data.IORef -import Data.Functor import Data.Maybe import qualified Data.Strict.Maybe as Strict @@ -23,17 +17,16 @@ import Agda.Syntax.Notation import Agda.Syntax.Position -import Agda.TypeChecking.Positivity.Occurrence - import Agda.Interaction.Options.IORefs (UnicodeOrAscii(..), unicodeOrAscii) +import Agda.Utils.Float (toStringWithoutDotZero) import Agda.Utils.Function import Agda.Utils.Functor +import Agda.Utils.Maybe import Agda.Utils.Null import Agda.Utils.Pretty import Agda.Utils.String -#include "undefined.h" import Agda.Utils.Impossible import qualified System.IO.Unsafe as UNSAFE (unsafePerformIO) @@ -44,8 +37,10 @@ deriving instance (Show a) => Show (OpApp a) deriving instance Show Declaration deriving instance Show Pattern +deriving instance Show a => Show (Binder' a) deriving instance Show TypedBinding deriving instance Show LamBinding +deriving instance Show BoundName deriving instance Show ModuleAssignment deriving instance (Show a, Show b) => Show (ImportDirective' a b) deriving instance (Show a, Show b) => Show (Using' a b) @@ -83,6 +78,9 @@ , _lambda :: Doc , _arrow :: Doc , _forallQ :: Doc + , _leftIdiomBrkt :: Doc + , _rightIdiomBrkt :: Doc + , _emptyIdiomBrkt :: Doc } {-# NOINLINE specialCharacters #-} @@ -94,11 +92,17 @@ , _lambda = "\x03bb" , _arrow = "\x2192" , _forallQ = "\x2200" + , _leftIdiomBrkt = "\x2987" + , _rightIdiomBrkt = "\x2988" + , _emptyIdiomBrkt = "\x2987\x2988" } AsciiOnly -> SpecialCharacters { _dbraces = braces . braces' , _lambda = "\\" , _arrow = "->" , _forallQ = "forall" + , _leftIdiomBrkt = "(|" + , _rightIdiomBrkt = "|)" + , _emptyIdiomBrkt = "(|)" } braces' :: Doc -> Doc @@ -118,6 +122,12 @@ forallQ :: Doc forallQ = _forallQ specialCharacters +-- left, right, and empty idiom bracket +leftIdiomBrkt, rightIdiomBrkt, emptyIdiomBrkt :: Doc +leftIdiomBrkt = _leftIdiomBrkt specialCharacters +rightIdiomBrkt = _rightIdiomBrkt specialCharacters +emptyIdiomBrkt = _emptyIdiomBrkt specialCharacters + -- Lays out a list of documents [d₁, d₂, …] in the following way: -- @ -- { d₁ @@ -150,8 +160,23 @@ prettyRelevance a d = if render d == "_" then d else pretty (getRelevance a) <> d +prettyQuantity :: LensQuantity a => a -> Doc -> Doc +prettyQuantity a d = + if render d == "_" then d else pretty (getQuantity a) <+> d + +prettyCohesion :: LensCohesion a => a -> Doc -> Doc +prettyCohesion a d = + if render d == "_" then d else pretty (getCohesion a) <+> d + +prettyTactic :: BoundName -> Doc -> Doc +prettyTactic = prettyTactic' . bnameTactic + +prettyTactic' :: TacticAttribute -> Doc -> Doc +prettyTactic' Nothing d = d +prettyTactic' (Just t) d = "@" <> (parens ("tactic" <+> pretty t) <+> d) + instance (Pretty a, Pretty b) => Pretty (a, b) where - pretty (a, b) = parens $ pretty a <> comma <+> pretty b + pretty (a, b) = parens $ (pretty a <> comma) <+> pretty b instance Pretty (ThingWithFixity Name) where pretty (ThingWithFixity n _) = pretty n @@ -164,6 +189,35 @@ pretty Irrelevant = "." pretty NonStrict = ".." +instance Pretty Q0Origin where + pretty = \case + Q0Inferred -> empty + Q0{} -> "@0" + Q0Erased{} -> "@erased" + +instance Pretty Q1Origin where + pretty = \case + Q1Inferred -> empty + Q1{} -> "@1" + Q1Linear{} -> "@linear" + +instance Pretty QωOrigin where + pretty = \case + QωInferred -> empty + Qω{} -> "@ω" + QωPlenty{} -> "@plenty" + +instance Pretty Quantity where + pretty = \case + Quantity0 o -> ifNull (pretty o) "@0" id + Quantity1 o -> ifNull (pretty o) "@1" id + Quantityω o -> pretty o + +instance Pretty Cohesion where + pretty Flat = "@♭" + pretty Continuous = mempty + pretty Squash = "@⊤" + instance Pretty (OpApp Expr) where pretty (Ordinary e) = pretty e pretty (SyntaxBindingLambda r bs e) = pretty (Lam r bs e) @@ -179,7 +233,6 @@ Lit l -> pretty l QuestionMark _ n -> "?" <> maybe empty (text . show) n Underscore _ n -> maybe underscore text n --- Underscore _ n -> underscore <> maybe empty (text . show) n App _ _ _ -> case appView e of AppView e1 args -> @@ -203,7 +256,7 @@ AbsurdLam _ h -> lambda <+> absurd h ExtendedLam _ pes -> lambda <+> bracesAndSemicolons (map pretty pes) Fun _ e1 e2 -> - sep [ pretty e1 <+> arrow + sep [ prettyCohesion e1 (prettyQuantity e1 (pretty e1)) <+> arrow , pretty e2 ] Pi tel e -> @@ -219,26 +272,25 @@ , maybe empty (\ e -> "in" <+> pretty e) me ] Paren _ e -> parens $ pretty e - IdiomBrackets _ e -> "(|" <+> pretty e <+> "|)" + IdiomBrackets _ es -> + case es of + [] -> emptyIdiomBrkt + [e] -> leftIdiomBrkt <+> pretty e <+> rightIdiomBrkt + e:es -> leftIdiomBrkt <+> pretty e <+> fsep (map (("|" <+>) . pretty) es) <+> rightIdiomBrkt DoBlock _ ss -> "do" <+> vcat (map pretty ss) As _ x e -> pretty x <> "@" <> pretty e Dot _ e -> "." <> pretty e + DoubleDot _ e -> ".." <> pretty e Absurd _ -> "()" Rec _ xs -> sep ["record", bracesAndSemicolons (map pretty xs)] RecUpdate _ e xs -> sep ["record" <+> pretty e, bracesAndSemicolons (map pretty xs)] ETel [] -> "()" ETel tel -> fsep $ map pretty tel - QuoteGoal _ x e -> sep ["quoteGoal" <+> pretty x <+> "in", - nest 2 $ pretty e] - QuoteContext _ -> "quoteContext" Quote _ -> "quote" QuoteTerm _ -> "quoteTerm" - Unquote _ -> "unquote" - Tactic _ t es -> - sep [ "tactic" <+> pretty t - , fsep [ "|" <+> pretty e | e <- es ] - ] + Unquote _ -> "unquote" + Tactic _ t -> "tactic" <+> pretty t -- Andreas, 2011-10-03 print irrelevant things as .(e) DontCare e -> "." <> parens (pretty e) Equal _ a b -> pretty a <+> "=" <+> pretty b @@ -270,26 +322,42 @@ instance Pretty BoundName where pretty BName{ boundName = x } = pretty x -data NamedBinding = NamedBinding { withHiding :: Bool - , namedBinding :: NamedArg BoundName } - -getLabel :: NamedArg a -> Maybe String -getLabel = fmap rangedThing . nameOf . unArg +data NamedBinding = NamedBinding + { withHiding :: Bool + , namedBinding :: NamedArg Binder + } -isLabeled :: NamedArg BoundName -> Bool +isLabeled :: NamedArg Binder -> Maybe ArgName isLabeled x - | visible x = False -- Ignore labels on visible arguments - | Just l <- getLabel x = l /= nameToRawName (boundName $ namedArg x) - | otherwise = False + | visible x = Nothing -- Ignore labels on visible arguments + | Just l <- bareNameOf x = boolToMaybe (l /= nameToRawName (boundName $ binderName $ namedArg x)) l + | otherwise = Nothing +instance Pretty a => Pretty (Binder' a) where + pretty (Binder mpat n) = let d = pretty n in case mpat of + Nothing -> d + Just pat -> d <+> "@" <+> parens (pretty pat) + instance Pretty NamedBinding where - pretty (NamedBinding withH x) = - prH $ if | isLabeled x -> text (fromMaybe __IMPOSSIBLE__ $ getLabel x) <+> "=" <+> pretty (namedArg x) - | otherwise -> pretty (namedArg x) + pretty (NamedBinding withH x) = prH $ + if | Just l <- isLabeled x -> text l <+> "=" <+> pretty xb + | otherwise -> pretty xb + where - prH | withH = prettyRelevance x . prettyHiding x id - | otherwise = id + xb = namedArg x + bn = binderName xb + prH | withH = prettyRelevance x + . prettyHiding x mparens + . prettyCohesion x + . prettyQuantity x + . prettyTactic bn + | otherwise = id + -- Parentheses are needed when an attribute @... is present + mparens + | noUserQuantity x, Nothing <- bnameTactic bn = id + | otherwise = parens + instance Pretty LamBinding where pretty (DomainFree x) = pretty (NamedBinding True x) pretty (DomainFull b) = pretty b @@ -299,17 +367,21 @@ pretty (TBind _ xs (Underscore _ Nothing)) = fsep (map (pretty . NamedBinding True) xs) pretty (TBind _ xs e) = fsep - [ prettyRelevance y $ prettyHiding y parens $ + [ prettyRelevance y + $ prettyHiding y parens + $ prettyCohesion y + $ prettyQuantity y + $ prettyTactic (binderName $ namedArg y) $ sep [ fsep (map (pretty . NamedBinding False) ys) , ":" <+> pretty e ] | ys@(y : _) <- groupBinds xs ] where groupBinds [] = [] groupBinds (x : xs) - | isLabeled x = [x] : groupBinds xs + | Just{} <- isLabeled x = [x] : groupBinds xs | otherwise = (x : ys) : groupBinds zs where (ys, zs) = span (same x) xs - same x y = getArgInfo x == getArgInfo y && not (isLabeled y) + same x y = getArgInfo x == getArgInfo y && isNothing (isLabeled y) newtype Tel = Tel Telescope @@ -345,17 +417,11 @@ ] instance Pretty LHS where - pretty lhs = case lhs of - LHS p eqs es -> pr (pretty p) eqs es - where - pr d eqs es = - sep [ d - , nest 2 $ pThing "rewrite" eqs - , nest 2 $ pThing "with" es - ] - pThing thing [] = empty - pThing thing (e : es) = fsep $ (text thing <+> pretty e) - : map (("|" <+>) . pretty) es + pretty (LHS p eqs es ell) = sep + [ pretty p + , nest 2 $ if null eqs then empty else fsep $ map pretty eqs + , nest 2 $ prefixedThings "with" (map pretty es) + ] instance Pretty LHSCore where pretty (LHSHead f ps) = sep $ pretty f : map (parens . pretty) ps @@ -384,27 +450,33 @@ prettyList = vcat . map pretty pretty d = case d of - TypeSig i x e -> - sep [ prettyRelevance i $ pretty x <+> ":" + TypeSig i tac x e -> + sep [ prettyTactic' tac $ prettyRelevance i $ prettyCohesion i $ prettyQuantity i $ pretty x <+> ":" , nest 2 $ pretty e ] - Field inst x (Arg i e) -> - sep [ "field" - , nest 2 $ mkInst inst $ mkOverlap i $ - prettyRelevance i $ prettyHiding i id $ - pretty $ TypeSig (setRelevance Relevant i) x e - ] + + FieldSig inst tac x (Arg i e) -> + mkInst inst $ mkOverlap i $ + prettyRelevance i $ prettyHiding i id $ prettyCohesion i $ prettyQuantity i $ + pretty $ TypeSig (setRelevance Relevant i) tac x e + where - mkInst InstanceDef d = sep [ "instance", nest 2 d ] - mkInst NotInstanceDef d = d + mkInst (InstanceDef _) d = sep [ "instance", nest 2 d ] + mkInst NotInstanceDef d = d + mkOverlap i d | isOverlappable i = "overlap" <+> d | otherwise = d + + Field _ fs -> + sep [ "field" + , nest 2 $ vcat (map pretty fs) + ] FunClause lhs rhs wh _ -> sep [ pretty lhs , nest 2 $ pretty rhs ] $$ nest 2 (pretty wh) - DataSig _ ind x tel e -> + DataSig _ x tel e -> sep [ hsep [ "data" , pretty x , fcat (map pretty tel) @@ -414,7 +486,7 @@ , pretty e ] ] - Data _ ind x tel e cs -> + Data _ x tel e cs -> sep [ hsep [ "data" , pretty x , fcat (map pretty tel) @@ -425,7 +497,7 @@ , "where" ] ] $$ nest 2 (vcat $ map pretty cs) - DataDef _ ind x tel cs -> + DataDef _ x tel cs -> sep [ hsep [ "data" , pretty x , fcat (map pretty tel) @@ -517,7 +589,7 @@ pEta = maybeToList $ eta <&> \case YesEta -> "eta-equality" NoEta -> "no-eta-equality" - pCon = maybeToList $ ("constructor" <+>) . pretty <$> fst <$> con + pCon = maybeToList $ (("constructor" <+>) . pretty) . fst <$> con instance Pretty OpenShortHand where pretty DoOpen = "open" @@ -525,13 +597,13 @@ instance Pretty Pragma where pretty (OptionsPragma _ opts) = fsep $ map text $ "OPTIONS" : opts - pretty (BuiltinPragma _ b x) = hsep [ "BUILTIN", text b, pretty x ] - pretty (RewritePragma _ xs) = + pretty (BuiltinPragma _ b x) = hsep [ "BUILTIN", text (rangedThing b), pretty x ] + pretty (RewritePragma _ _ xs) = hsep [ "REWRITE", hsep $ map pretty xs ] pretty (CompilePragma _ b x e) = - hsep [ "COMPILE", text b, pretty x, text e ] + hsep [ "COMPILE", text (rangedThing b), pretty x, text e ] pretty (ForeignPragma _ b s) = - vcat $ text ("FOREIGN " ++ b) : map text (lines s) + vcat $ text ("FOREIGN " ++ rangedThing b) : map text (lines s) pretty (StaticPragma _ i) = hsep $ ["STATIC", pretty i] pretty (InjectivePragma _ i) = @@ -551,7 +623,9 @@ NonTerminating -> "NON_TERMINATING" Terminating -> "TERMINATING" TerminationMeasure _ x -> hsep $ ["MEASURE", pretty x] + pretty (NoCoverageCheckPragma _) = "NON_COVERING" pretty (WarningOnUsage _ nm str) = hsep [ "WARNING_ON_USAGE", pretty nm, text str ] + pretty (WarningOnImport _ str) = hsep [ "WARNING_ON_IMPORT", text str ] pretty (CatchallPragma _) = "CATCHALL" pretty (DisplayPragma _ lhs rhs) = "DISPLAY" <+> sep [ pretty lhs <+> "=", nest 2 $ pretty rhs ] pretty (NoPositivityCheckPragma _) = "NO_POSITIVITY_CHECK" @@ -561,7 +635,7 @@ instance Pretty Fixity where pretty (Fixity _ Unrelated _) = __IMPOSSIBLE__ - pretty (Fixity _ (Related n) ass) = s <+> text (show n) + pretty (Fixity _ (Related d) ass) = s <+> text (toStringWithoutDotZero d) where s = case ass of LeftAssoc -> "infixl" @@ -590,12 +664,10 @@ localParens | getOrigin ai == Substitution = parens | otherwise = id -instance Pretty a => Pretty (Dom a) where - pretty = pretty . argFromDom - instance Pretty e => Pretty (Named_ e) where - prettyPrec p (Named Nothing e) = prettyPrec p e - prettyPrec p (Named (Just s) e) = mparens (p > 0) $ sep [ text (rawNameToString $ rangedThing s) <+> "=", pretty e ] + prettyPrec p (Named nm e) + | Just s <- bareNameOf nm = mparens (p > 0) $ sep [ text s <+> "=", pretty e ] + | otherwise = prettyPrec p e instance Pretty Pattern where prettyList = fsep . map pretty @@ -675,24 +747,32 @@ , rename $ impRenaming i ] where - public True = "public" - public False = empty + public Just{} = "public" + public Nothing = empty prettyHiding [] = empty prettyHiding xs = "hiding" <+> parens (fsep $ punctuate ";" $ map pretty xs) rename [] = empty rename xs = hsep [ "renaming" - , parens $ fsep $ punctuate ";" $ map pr xs + , parens $ fsep $ punctuate ";" $ map pretty xs ] - pr r = hsep [ pretty (renFrom r), "to", pretty (renTo r) ] - instance (Pretty a, Pretty b) => Pretty (Using' a b) where pretty UseEverything = empty pretty (Using xs) = "using" <+> parens (fsep $ punctuate ";" $ map pretty xs) +instance (Pretty a, Pretty b) => Pretty (Renaming' a b) where + pretty (Renaming from to mfx _r) = hsep + [ pretty from + , "to" + , maybe empty pretty mfx + , case to of + ImportedName a -> pretty a + ImportedModule b -> pretty b -- don't print "module" here + ] + instance (Pretty a, Pretty b) => Pretty (ImportedName' a b) where - pretty (ImportedName x) = pretty x - pretty (ImportedModule x) = "module" <+> pretty x + pretty (ImportedName a) = pretty a + pretty (ImportedModule b) = "module" <+> pretty b diff --git a/src/full/Agda/Syntax/DoNotation.hs b/src/full/Agda/Syntax/DoNotation.hs --- a/src/full/Agda/Syntax/DoNotation.hs +++ b/src/full/Agda/Syntax/DoNotation.hs @@ -25,13 +25,11 @@ -} module Agda.Syntax.DoNotation (desugarDoNotation) where -import Control.Monad import Data.Maybe import Agda.Syntax.Common import Agda.Syntax.Position import Agda.Syntax.Concrete -import Agda.Syntax.Concrete.Operators import Agda.Syntax.Scope.Base import Agda.Syntax.Scope.Monad @@ -64,8 +62,12 @@ -- The last statement must be a DoThen desugarDo qBind qThen [s] - | DoThen e <- s = return e - | otherwise = genericError "The last statement in a 'do' block must be an expression" + | DoThen e <- s = return e + | DoBind r p e [] <- s + , Just (r' , NotHidden) <- isAbsurdP p = + return $ appOp (setRange r qBind) e $ AbsurdLam r' NotHidden + | otherwise = + genericError "The last statement in a 'do' block must be an expression or an absurd match." -- `DoThen` and `DoLet` are easy desugarDo qBind qThen (DoThen e : ss) = appOp qThen e <$> desugarDo qBind qThen ss @@ -103,19 +105,19 @@ $ ExtendedLam (getRange cs) -- where-clauses to make highlighting of overlapping $ map addParens (mainClause : cs) -- patterns not highlight the rest of the do-block. where - mainClause = LamClause { lamLHS = LHS p [] [] + mainClause = LamClause { lamLHS = LHS p [] [] NoEllipsis , lamRHS = RHS body , lamWhere = NoWhere , lamCatchAll = False } -- Add parens to left-hand sides: there can only be one pattern in these clauses. addParens c = c { lamLHS = addP (lamLHS c) } - where addP (LHS p rw we) = LHS (RawAppP noRange [ParenP noRange p]) rw we + where addP (LHS p rw we ell) = LHS (RawAppP noRange [ParenP noRange p]) rw we ell nonMatchingBind :: QName -> Range -> Name -> Expr -> Expr -> Expr nonMatchingBind qBind r x e body = appOp (setRange r qBind) e $ Lam (getRange (x, body)) [bx] body - where bx = DomainFree $ defaultNamedArg $ mkBoundName_ x + where bx = DomainFree $ defaultNamedArg $ mkBinder_ x appOp :: QName -> Expr -> Expr -> Expr appOp q e1 e2 = app (Ident q) [par e1, par e2] diff --git a/src/full/Agda/Syntax/Fixity.hs b/src/full/Agda/Syntax/Fixity.hs --- a/src/full/Agda/Syntax/Fixity.hs +++ b/src/full/Agda/Syntax/Fixity.hs @@ -1,252 +1,37 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE DeriveDataTypeable #-} {-| Definitions for fixity, precedence levels, and declared syntax. -} module Agda.Syntax.Fixity where -import Prelude hiding (concatMap) - import Control.DeepSeq -import Data.Foldable -import Data.Function import qualified Data.List as List import Data.Maybe -import Data.Set (Set) -import qualified Data.Set as Set -import Data.Traversable import Data.Data (Data) import Agda.Syntax.Position import Agda.Syntax.Common -import qualified Agda.Syntax.Abstract.Name as A -import Agda.Syntax.Concrete.Name import Agda.Syntax.Notation -import Agda.Utils.Lens import Agda.Utils.List import Agda.Utils.Pretty -#include "undefined.h" import Agda.Utils.Impossible --- * Notation coupled with 'Fixity' - --- | The notation is handled as the fixity in the renamer. --- Hence, they are grouped together in this type. -data Fixity' = Fixity' - { theFixity :: !Fixity - , theNotation :: Notation - , theNameRange :: Range - -- ^ Range of the name in the fixity declaration - -- (used for correct highlighting, see issue #2140). - } - deriving (Data, Show) - -instance Eq Fixity' where - Fixity' f n _ == Fixity' f' n' _ = f == f' && n == n' +-- The Fixity data type is now defined in Agda.Syntax.Common. +-- Andreas, 2019-08-16, issue #1346 -- | Decorating something with @Fixity'@. data ThingWithFixity x = ThingWithFixity x Fixity' deriving (Functor, Foldable, Traversable, Data, Show) --- | All the notation information related to a name. -data NewNotation = NewNotation - { notaName :: QName - , notaNames :: Set A.Name - -- ^ The names the syntax and/or fixity belong to. - -- - -- Invariant: The set is non-empty. Every name in the list matches - -- 'notaName'. - , notaFixity :: Fixity - -- ^ Associativity and precedence (fixity) of the names. - , notation :: Notation - -- ^ Syntax associated with the names. - , notaIsOperator :: Bool - -- ^ True if the notation comes from an operator (rather than a - -- syntax declaration). - } deriving Show - --- | If an operator has no specific notation, then it is computed from --- its name. -namesToNotation :: QName -> A.Name -> NewNotation -namesToNotation q n = NewNotation - { notaName = q - , notaNames = Set.singleton n - , notaFixity = f - , notation = if null syn then syntaxOf (unqualify q) else syn - , notaIsOperator = null syn - } - where Fixity' f syn _ = A.nameFixity n - --- | Replace 'noFixity' by 'defaultFixity'. -useDefaultFixity :: NewNotation -> NewNotation -useDefaultFixity n - | notaFixity n == noFixity = n { notaFixity = defaultFixity } - | otherwise = n - --- | Return the 'IdPart's of a notation, the first part qualified, --- the other parts unqualified. --- This allows for qualified use of operators, e.g., --- @M.for x ∈ xs return e@, or @x ℕ.+ y@. -notationNames :: NewNotation -> [QName] -notationNames (NewNotation q _ _ parts _) = - zipWith ($) (reQualify : repeat QName) [Name noRange InScope [Id $ rangedThing x] | IdPart x <- parts ] - where - -- The qualification of @q@. - modules = init (qnameParts q) - -- Putting the qualification onto @x@. - reQualify x = List.foldr Qual (QName x) modules - --- | Create a 'Notation' (without binders) from a concrete 'Name'. --- Does the obvious thing: --- 'Hole's become 'NormalHole's, 'Id's become 'IdParts'. --- If 'Name' has no 'Hole's, it returns 'noNotation'. -syntaxOf :: Name -> Notation -syntaxOf (NoName _ _) = noNotation -syntaxOf (Name _ _ [_]) = noNotation -syntaxOf (Name _ _ xs) = mkSyn 0 xs - where - -- Turn a concrete name into a Notation, - -- numbering the holes from left to right. - -- Result will have no 'BindingHole's. - mkSyn :: Int -> [NamePart] -> Notation - mkSyn n [] = [] - mkSyn n (Hole : xs) = NormalHole noRange (defaultNamedArg $ unranged n) : mkSyn (1 + n) xs - mkSyn n (Id x : xs) = IdPart (unranged x) : mkSyn n xs - -noFixity' :: Fixity' -noFixity' = Fixity' noFixity noNotation noRange - --- | Merges 'NewNotation's that have the same precedence level and --- notation, with two exceptions: --- --- * Operators and notations coming from syntax declarations are kept --- separate. --- --- * If /all/ instances of a given 'NewNotation' have the same --- precedence level or are \"unrelated\", then they are merged. They --- get the given precedence level, if any, and otherwise they become --- unrelated (but related to each other). --- --- If 'NewNotation's that are merged have distinct associativities, --- then they get 'NonAssoc' as their associativity. --- --- Precondition: No 'A.Name' may occur in more than one list element. --- Every 'NewNotation' must have the same 'notaName'. --- --- Postcondition: No 'A.Name' occurs in more than one list element. -mergeNotations :: [NewNotation] -> [NewNotation] -mergeNotations = - map merge . - concatMap groupIfLevelsMatch . - groupOn (\n -> ( notation n - , notaIsOperator n - )) - where - groupIfLevelsMatch :: [NewNotation] -> [[NewNotation]] - groupIfLevelsMatch [] = __IMPOSSIBLE__ - groupIfLevelsMatch ns@(n : _) = - if allEqual (map fixityLevel related) - then [sameAssoc (sameLevel ns)] - else map (: []) ns - where - -- Fixities of operators whose precedence level is not Unrelated. - related = mapMaybe (\f -> case fixityLevel f of - Unrelated -> Nothing - Related {} -> Just f) - (map notaFixity ns) - - -- Precondition: All related operators have the same precedence - -- level. - -- - -- Gives all unrelated operators the same level. - sameLevel = map (set (_notaFixity . _fixityLevel) level) - where - level = case related of - f : _ -> fixityLevel f - [] -> Unrelated - - -- If all related operators have the same associativity, then the - -- unrelated operators get the same associativity, and otherwise - -- all operators get the associativity NonAssoc. - sameAssoc = map (set (_notaFixity . _fixityAssoc) assoc) - where - assoc = case related of - f : _ | allEqual (map fixityAssoc related) -> fixityAssoc f - _ -> NonAssoc - - merge :: [NewNotation] -> NewNotation - merge [] = __IMPOSSIBLE__ - merge ns@(n : _) = n { notaNames = Set.unions $ map notaNames ns } - --- * Sections - --- | Sections, as well as non-sectioned operators. - -data NotationSection = NotationSection - { sectNotation :: NewNotation - , sectKind :: NotationKind - -- ^ For non-sectioned operators this should match the notation's - -- 'notationKind'. - , sectLevel :: Maybe PrecedenceLevel - -- ^ Effective precedence level. 'Nothing' for closed notations. - , sectIsSection :: Bool - -- ^ 'False' for non-sectioned operators. - } - deriving Show - --- | Converts a notation to a (non-)section. - -noSection :: NewNotation -> NotationSection -noSection n = NotationSection - { sectNotation = n - , sectKind = notationKind (notation n) - , sectLevel = Just (fixityLevel (notaFixity n)) - , sectIsSection = False - } - --- * Fixity - --- | Precedence levels for operators. - -data PrecedenceLevel - = Unrelated - -- ^ No fixity declared. - | Related !Integer - -- ^ Fixity level declared as the @Integer@. - deriving (Eq, Ord, Show, Data) - --- | Associativity. - -data Associativity = NonAssoc | LeftAssoc | RightAssoc - deriving (Eq, Ord, Show, Data) - --- | Fixity of operators. - -data Fixity = Fixity - { fixityRange :: Range - -- ^ Range of the whole fixity declaration. - , fixityLevel :: !PrecedenceLevel - , fixityAssoc :: !Associativity - } - deriving (Data, Show) - -instance Eq Fixity where - f1 == f2 = compare f1 f2 == EQ - -instance Ord Fixity where - compare = compare `on` (\f -> (fixityLevel f, fixityAssoc f)) - --- For @instance Pretty Fixity@, see Agda.Syntax.Concrete.Pretty - -noFixity :: Fixity -noFixity = Fixity noRange Unrelated NonAssoc +instance LensFixity' (ThingWithFixity a) where + lensFixity' f (ThingWithFixity a fix') = ThingWithFixity a <$> f fix' -defaultFixity :: Fixity -defaultFixity = Fixity noRange (Related 20) NonAssoc +instance LensFixity (ThingWithFixity a) where + lensFixity = lensFixity' . lensFixity -- | Do we prefer parens around arguments like @λ x → x@ or not? -- See 'lamBrackets'. @@ -366,43 +151,5 @@ roundFixBrackets :: PrecedenceStack -> Bool roundFixBrackets ps = DotPatternCtx == headPrecedence ps -instance HasRange Fixity where - getRange = fixityRange - -instance KillRange Fixity where - killRange f = f { fixityRange = noRange } - -instance KillRange Fixity' where - killRange (Fixity' f n r) = killRange3 Fixity' f n r - instance KillRange x => KillRange (ThingWithFixity x) where killRange (ThingWithFixity c f) = ThingWithFixity (killRange c) f - --- * Some lenses - -_notaFixity :: Lens' Fixity NewNotation -_notaFixity f r = f (notaFixity r) <&> \x -> r { notaFixity = x } - -_fixityAssoc :: Lens' Associativity Fixity -_fixityAssoc f r = f (fixityAssoc r) <&> \x -> r { fixityAssoc = x } - -_fixityLevel :: Lens' PrecedenceLevel Fixity -_fixityLevel f r = f (fixityLevel r) <&> \x -> r { fixityLevel = x } - ------------------------------------------------------------------------- --- * Printing ------------------------------------------------------------------------- - --- deriving instance Show Fixity' - ------------------------------------------------------------------------- --- * NFData instances ------------------------------------------------------------------------- - -instance NFData Fixity' where - rnf (Fixity' _ a _) = rnf a - --- | Ranges are not forced. - -instance NFData Fixity where - rnf (Fixity _ _ _) = () diff --git a/src/full/Agda/Syntax/Fixity.hs-boot b/src/full/Agda/Syntax/Fixity.hs-boot deleted file mode 100644 --- a/src/full/Agda/Syntax/Fixity.hs-boot +++ /dev/null @@ -1,15 +0,0 @@ -module Agda.Syntax.Fixity where - -import Control.DeepSeq (NFData) -import Data.Data (Data) - -import Agda.Syntax.Position ( KillRange ) - -data Fixity' - -instance KillRange Fixity' -instance Data Fixity' -instance NFData Fixity' -instance Show Fixity' - -noFixity' :: Fixity' diff --git a/src/full/Agda/Syntax/IdiomBrackets.hs b/src/full/Agda/Syntax/IdiomBrackets.hs --- a/src/full/Agda/Syntax/IdiomBrackets.hs +++ b/src/full/Agda/Syntax/IdiomBrackets.hs @@ -1,4 +1,4 @@ -module Agda.Syntax.IdiomBrackets (parseIdiomBrackets) where +module Agda.Syntax.IdiomBrackets (parseIdiomBracketsSeq) where import Control.Monad @@ -6,6 +6,7 @@ import Agda.Syntax.Position import Agda.Syntax.Concrete import Agda.Syntax.Concrete.Operators +import Agda.Syntax.Concrete.Pretty ( leftIdiomBrkt, rightIdiomBrkt ) import Agda.Syntax.Scope.Base import Agda.Syntax.Scope.Monad @@ -13,11 +14,24 @@ import Agda.Utils.Pretty ( prettyShow ) +parseIdiomBracketsSeq :: Range -> [Expr] -> ScopeM Expr +parseIdiomBracketsSeq r es = do + let qEmpty = QName $ Name noRange InScope [Id "empty"] + qPlus = QName $ Name noRange InScope [Hole, Id "<|>", Hole] + ePlus a b = App r (App r (Ident qPlus) (defaultNamedArg a)) (defaultNamedArg b) + case es of + [] -> ensureInScope qEmpty >> return (Ident qEmpty) + [e] -> parseIdiomBrackets r e + es@(_:_) -> do + ensureInScope qPlus + es' <- mapM (parseIdiomBrackets r) es + return $ foldr1 ePlus es' + parseIdiomBrackets :: Range -> Expr -> ScopeM Expr parseIdiomBrackets r e = do let qPure = QName $ Name noRange InScope [Id "pure"] qAp = QName $ Name noRange InScope [Hole, Id "<*>", Hole] - ePure = App r (Ident qPure) . defaultNamedArg + ePure = App r (Ident qPure) . defaultNamedArg eAp a b = App r (App r (Ident qAp) (defaultNamedArg a)) (defaultNamedArg b) mapM_ ensureInScope [qPure, qAp] case e of @@ -34,8 +48,8 @@ _ -> return [e] where onlyVisible a - | defaultNamedArg () == (fmap (() <$) a) = return $ namedArg a - | otherwise = genericError $ "Only regular arguments are allowed in idiom brackets (no implicit or instance arguments)" + | defaultNamedArg () == fmap (() <$) a = return $ namedArg a + | otherwise = genericError "Only regular arguments are allowed in idiom brackets (no implicit or instance arguments)" noPlaceholder Placeholder{} = genericError "Naked sections are not allowed in idiom brackets" noPlaceholder (NoPlaceholder _ x) = return x @@ -47,5 +61,5 @@ r <- resolveName q case r of UnknownName -> genericError $ - prettyShow q ++ " needs to be in scope to use idiom brackets (| ... |)" + prettyShow q ++ " needs to be in scope to use idiom brackets " ++ prettyShow leftIdiomBrkt ++ " ... " ++ prettyShow rightIdiomBrkt _ -> return () diff --git a/src/full/Agda/Syntax/Info.hs b/src/full/Agda/Syntax/Info.hs --- a/src/full/Agda/Syntax/Info.hs +++ b/src/full/Agda/Syntax/Info.hs @@ -21,6 +21,7 @@ import Agda.Syntax.Scope.Base (ScopeInfo, emptyScopeInfo) import Agda.Utils.Function +import Agda.Utils.Functor import Agda.Utils.Null {-------------------------------------------------------------------------- @@ -70,10 +71,11 @@ --------------------------------------------------------------------------} -- | Information about application -data AppInfo = AppInfo { appRange :: Range - , appOrigin :: Origin - , appParens :: ParenPreference -- ^ Do we prefer a appbda argument with or without parens? - } +data AppInfo = AppInfo + { appRange :: Range + , appOrigin :: Origin + , appParens :: ParenPreference -- ^ Do we prefer a appbda argument with or without parens? + } deriving (Data, Show, Eq, Ord) -- | Default is system inserted and prefer parens. @@ -92,7 +94,7 @@ instance LensOrigin AppInfo where getOrigin = appOrigin - setOrigin o i = i { appOrigin = o } + mapOrigin f i = i { appOrigin = f (appOrigin i) } {-------------------------------------------------------------------------- Module information @@ -109,9 +111,7 @@ , minfoDirective :: Maybe ImportDirective -- ^ Retained for @abstractToConcrete@ of 'ModuleMacro'. } - deriving (Data, Eq) - -deriving instance Show ModuleInfo + deriving (Data, Eq, Show) instance HasRange ModuleInfo where getRange = minfoRange @@ -139,32 +139,41 @@ Definition information (declarations that actually define something) --------------------------------------------------------------------------} -data DefInfo = DefInfo +data DefInfo' t = DefInfo { defFixity :: Fixity' , defAccess :: Access , defAbstract :: IsAbstract , defInstance :: IsInstance , defMacro :: IsMacro , defInfo :: DeclInfo + , defTactic :: Maybe t } deriving (Data, Show, Eq) -mkDefInfo :: Name -> Fixity' -> Access -> IsAbstract -> Range -> DefInfo -mkDefInfo x f a ab r = DefInfo f a ab NotInstanceDef NotMacroDef (DeclInfo x r) +mkDefInfo :: Name -> Fixity' -> Access -> IsAbstract -> Range -> DefInfo' t +mkDefInfo x f a ab r = mkDefInfoInstance x f a ab NotInstanceDef NotMacroDef r -- | Same as @mkDefInfo@ but where we can also give the @IsInstance@ -mkDefInfoInstance :: Name -> Fixity' -> Access -> IsAbstract -> IsInstance -> IsMacro -> Range -> DefInfo -mkDefInfoInstance x f a ab i m r = DefInfo f a ab i m (DeclInfo x r) +mkDefInfoInstance :: Name -> Fixity' -> Access -> IsAbstract -> IsInstance -> IsMacro -> Range -> DefInfo' t +mkDefInfoInstance x f a ab i m r = DefInfo f a ab i m (DeclInfo x r) Nothing -instance HasRange DefInfo where +instance HasRange (DefInfo' t) where getRange = getRange . defInfo -instance SetRange DefInfo where +instance SetRange (DefInfo' t) where setRange r i = i { defInfo = setRange r (defInfo i) } -instance KillRange DefInfo where - killRange i = i { defInfo = killRange $ defInfo i } +instance KillRange t => KillRange (DefInfo' t) where + killRange i = i { defInfo = killRange $ defInfo i, + defTactic = killRange $ defTactic i } +instance LensIsAbstract (DefInfo' t) where + lensIsAbstract f i = (f $! defAbstract i) <&> \ a -> i { defAbstract = a } + +instance AnyIsAbstract (DefInfo' t) where + anyIsAbstract = defAbstract + + {-------------------------------------------------------------------------- General declaration information --------------------------------------------------------------------------} @@ -189,15 +198,16 @@ --------------------------------------------------------------------------} data MutualInfo = MutualInfo - { mutualTermCheck :: TerminationCheck Name - , mutualPositivityCheck :: PositivityCheck - , mutualRange :: Range + { mutualTerminationCheck :: TerminationCheck Name + , mutualCoverageCheck :: CoverageCheck + , mutualPositivityCheck :: PositivityCheck + , mutualRange :: Range } deriving (Data, Show, Eq) -- | Default value for 'MutualInfo'. instance Null MutualInfo where - empty = MutualInfo TerminationCheck True noRange + empty = MutualInfo TerminationCheck YesCoverageCheck YesPositivityCheck noRange instance HasRange MutualInfo where getRange = mutualRange @@ -209,15 +219,21 @@ Left hand side information --------------------------------------------------------------------------} -newtype LHSInfo = LHSRange Range - deriving (Data, Show, Eq, Null) +data LHSInfo = LHSInfo + { lhsRange :: Range + , lhsEllipsis :: ExpandedEllipsis + } deriving (Data, Show, Eq) instance HasRange LHSInfo where - getRange (LHSRange r) = r + getRange (LHSInfo r _) = r instance KillRange LHSInfo where - killRange (LHSRange r) = LHSRange noRange + killRange (LHSInfo r ell) = LHSInfo noRange ell +instance Null LHSInfo where + null i = null (lhsRange i) && null (lhsEllipsis i) + empty = LHSInfo empty empty + {-------------------------------------------------------------------------- Pattern information --------------------------------------------------------------------------} @@ -233,21 +249,16 @@ -- | Constructor pattern info. data ConPatInfo = ConPatInfo - { patOrigin :: ConOrigin + { conPatOrigin :: ConOrigin -- ^ Does this pattern come form the eta-expansion of an implicit pattern? --- Or from a user written constructor or record pattern? - , patInfo :: PatInfo - , patLazy :: ConPatLazy + , conPatInfo :: PatInfo + , conPatLazy :: ConPatLazy } - deriving (Data, Eq) - -instance Show ConPatInfo where - show (ConPatInfo po i l) = - applyWhen (l == ConPatLazy) ("lazy " ++) $ - applyWhen (po == ConOSystem) ("implicit " ++) $ show i + deriving (Data, Eq, Show) instance HasRange ConPatInfo where - getRange = getRange . patInfo + getRange = getRange . conPatInfo instance KillRange ConPatInfo where killRange (ConPatInfo b i l) = ConPatInfo b (killRange i) l diff --git a/src/full/Agda/Syntax/Internal.hs b/src/full/Agda/Syntax/Internal.hs --- a/src/full/Agda/Syntax/Internal.hs +++ b/src/full/Agda/Syntax/Internal.hs @@ -1,7 +1,7 @@ {-# LANGUAGE BangPatterns #-} -{-# LANGUAGE CPP #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE PatternSynonyms #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE UndecidableInstances #-} -- because of shortcomings of FunctionalDependencies @@ -12,8 +12,8 @@ ) where import Prelude hiding (foldr, mapM, null) +import GHC.Stack (HasCallStack, freezeCallStack, callStack) -import Control.Applicative hiding (empty) import Control.Monad.Identity hiding (mapM) import Control.DeepSeq @@ -36,21 +36,103 @@ import Agda.Utils.Empty import Agda.Utils.Functor -import Agda.Utils.Geniplate import Agda.Utils.Lens -import Agda.Utils.List -import Agda.Utils.Maybe -import Agda.Utils.NonemptyList import Agda.Utils.Null -import Agda.Utils.Permutation import Agda.Utils.Size -import qualified Agda.Utils.Pretty as P -import Agda.Utils.Pretty hiding ((<>)) +import Agda.Utils.Pretty import Agda.Utils.Tuple -#include "undefined.h" import Agda.Utils.Impossible +--------------------------------------------------------------------------- +-- * Function type domain +--------------------------------------------------------------------------- + +-- | Similar to 'Arg', but we need to distinguish +-- an irrelevance annotation in a function domain +-- (the domain itself is not irrelevant!) +-- from an irrelevant argument. +-- +-- @Dom@ is used in 'Pi' of internal syntax, in 'Context' and 'Telescope'. +-- 'Arg' is used for actual arguments ('Var', 'Con', 'Def' etc.) +-- and in 'Abstract' syntax and other situations. +-- +-- [ cubical ] When @domFinite = True@ for the domain of a 'Pi' +-- type, the elements should be compared by tabulating the domain type. +-- Only supported in case the domain type is primIsOne, to obtain +-- the correct equality for partial elements. +-- +data Dom' t e = Dom + { domInfo :: ArgInfo + , domFinite :: !Bool + , domName :: Maybe NamedName -- ^ e.g. @x@ in @{x = y : A} -> B@. + , domTactic :: Maybe t -- ^ "@tactic e". + , unDom :: e + } deriving (Data, Show, Functor, Foldable, Traversable) + +type Dom = Dom' Term + +instance Decoration (Dom' t) where + traverseF f (Dom ai b x t a) = Dom ai b x t <$> f a + +instance HasRange a => HasRange (Dom' t a) where + getRange = getRange . unDom + +instance (KillRange t, KillRange a) => KillRange (Dom' t a) where + killRange (Dom info b x t a) = killRange5 Dom info b x t a + +-- | Ignores 'Origin' and 'FreeVariables' and tactic. +instance Eq a => Eq (Dom' t a) where + Dom (ArgInfo h1 m1 _ _) b1 s1 _ x1 == Dom (ArgInfo h2 m2 _ _) b2 s2 _ x2 = + (h1, m1, b1, s1, x1) == (h2, m2, b2, s2, x2) + +instance LensNamed NamedName (Dom' t e) where + lensNamed f dom = f (domName dom) <&> \ nm -> dom { domName = nm } + +instance LensArgInfo (Dom' t e) where + getArgInfo = domInfo + setArgInfo ai dom = dom { domInfo = ai } + mapArgInfo f dom = dom { domInfo = f $ domInfo dom } + +-- The other lenses are defined through LensArgInfo + +instance LensHiding (Dom' t e) where +instance LensModality (Dom' t e) where +instance LensOrigin (Dom' t e) where +instance LensFreeVariables (Dom' t e) where + +-- Since we have LensModality, we get relevance and quantity by default + +instance LensRelevance (Dom' t e) where +instance LensQuantity (Dom' t e) where +instance LensCohesion (Dom' t e) where + +argFromDom :: Dom' t a -> Arg a +argFromDom Dom{domInfo = i, unDom = a} = Arg i a + +namedArgFromDom :: Dom' t a -> NamedArg a +namedArgFromDom Dom{domInfo = i, domName = s, unDom = a} = Arg i $ Named s a + +-- The following functions are less general than they could be: +-- @Dom@ could be replaced by @Dom' t@. +-- However, this causes problems with instance resolution in several places. +-- often for class AddContext. + +domFromArg :: Arg a -> Dom a +domFromArg (Arg i a) = Dom i False Nothing Nothing a + +domFromNamedArg :: NamedArg a -> Dom a +domFromNamedArg (Arg i a) = Dom i False (nameOf a) Nothing (namedThing a) + +defaultDom :: a -> Dom a +defaultDom = defaultArgDom defaultArgInfo + +defaultArgDom :: ArgInfo -> a -> Dom a +defaultArgDom info x = domFromArg (Arg info x) + +defaultNamedArgDom :: ArgInfo -> String -> a -> Dom a +defaultNamedArgDom info s x = (defaultArgDom info x) { domName = Just $ WithOrigin Inserted $ unranged s } + -- | Type of argument lists. -- type Args = [Arg Term] @@ -118,11 +200,13 @@ -- ^ Irrelevant stuff in relevant position, but created -- in an irrelevant context. Basically, an internal -- version of the irrelevance axiom @.irrAx : .A -> A@. - | Dummy String + | Dummy String Elims -- ^ A (part of a) term or type which is only used for internal purposes. -- Replaces the @Sort Prop@ hack. -- The @String@ typically describes the location where we create this dummy, -- but can contain other information as well. + -- The second field accumulates eliminations in case we + -- apply a dummy term to more of them. deriving (Data, Show) type ConInfo = ConOrigin @@ -149,28 +233,12 @@ mapOrigin f e@Proj{} = e mapOrigin f e@IApply{} = e --- | Names in binders and arguments. -type ArgName = String - -argNameToString :: ArgName -> String -argNameToString = id - -stringToArgName :: String -> ArgName -stringToArgName = id - -appendArgNames :: ArgName -> ArgName -> ArgName -appendArgNames = (++) - -nameToArgName :: Name -> ArgName -nameToArgName = stringToArgName . prettyShow - -namedArgName :: NamedArg Name -> ArgName -namedArgName x = maybe (nameToArgName $ namedArg x) rangedThing $ nameOf $ unArg x - -- | Binder. +-- -- 'Abs': The bound variable might appear in the body. -- 'NoAbs' is pseudo-binder, it does not introduce a fresh variable, -- similar to the @const@ of Haskell. +-- data Abs a = Abs { absName :: ArgName, unAbs :: a } -- ^ The body has (at least) one free variable. -- Danger: 'unAbs' doesn't shift variables properly @@ -183,12 +251,14 @@ -- | Types are terms with a sort annotation. -- -data Type' a = El { _getSort :: Sort, unEl :: a } +data Type'' t a = El { _getSort :: Sort' t, unEl :: a } deriving (Data, Show, Functor, Foldable, Traversable) +type Type' a = Type'' Term a + type Type = Type' Term -instance Decoration Type' where +instance Decoration (Type'' t) where traverseF f (El s a) = El s <$> f a class LensSort a where @@ -207,8 +277,6 @@ instance LensSort a => LensSort (Arg a) where lensSort = traverseF . lensSort -instance LensSort a => LensSort (Abs a) where - lensSort = traverseF . lensSort -- | Sequence of types. An argument of the first type is bound in later types -- and so on. @@ -220,15 +288,16 @@ -- | Sorts. -- -data Sort - = Type Level -- ^ @Set ℓ@. - | Prop Level -- ^ @Prop ℓ@. +data Sort' t + = Type (Level' t) -- ^ @Set ℓ@. + | Prop (Level' t) -- ^ @Prop ℓ@. | Inf -- ^ @Setω@. | SizeUniv -- ^ @SizeUniv@, a sort inhabited by type @Size@. - | PiSort Sort (Abs Sort) -- ^ Sort of the pi type. - | UnivSort Sort -- ^ Sort of another sort. - | MetaS {-# UNPACK #-} !MetaId Elims - | DefS QName Elims -- ^ A postulated sort. + | PiSort (Dom' t (Type'' t t)) (Abs (Sort' t)) -- ^ Sort of the pi type. + | FunSort (Sort' t) (Sort' t) -- ^ Sort of a (non-dependent) function type. + | UnivSort (Sort' t) -- ^ Sort of another sort. + | MetaS {-# UNPACK #-} !MetaId [Elim' t] + | DefS QName [Elim' t] -- ^ A postulated sort. | DummyS String -- ^ A (part of a) term or type which is only used for internal purposes. -- Replaces the abuse of @Prop@ for a dummy sort. @@ -236,31 +305,43 @@ -- but can contain other information as well. deriving (Data, Show) --- | A level is a maximum expression of 0..n 'PlusLevel' expressions --- each of which is a number or an atom plus a number. --- --- The empty maximum is the canonical representation for level 0. -newtype Level = Max [PlusLevel] +type Sort = Sort' Term + +-- | A level is a maximum expression of a closed level and 0..n +-- 'PlusLevel' expressions each of which is an atom plus a number. +data Level' t = Max Integer [PlusLevel' t] deriving (Show, Data) -data PlusLevel - = ClosedLevel Integer -- ^ @n@, to represent @Setₙ@. - | Plus Integer LevelAtom -- ^ @n + ℓ@. +type Level = Level' Term + +data PlusLevel' t = Plus Integer (LevelAtom' t) -- ^ @n + ℓ@. deriving (Show, Data) +type PlusLevel = PlusLevel' Term + -- | An atomic term of type @Level@. -data LevelAtom - = MetaLevel MetaId Elims +data LevelAtom' t + = MetaLevel MetaId [Elim' t] -- ^ A meta variable targeting @Level@ under some eliminations. - | BlockedLevel MetaId Term + | BlockedLevel MetaId t -- ^ A term of type @Level@ whose reduction is blocked by a meta. - | NeutralLevel NotBlocked Term + | NeutralLevel NotBlocked t -- ^ A neutral term of type @Level@. - | UnreducedLevel Term + | UnreducedLevel t -- ^ Introduced by 'instantiate', removed by 'reduce'. deriving (Show, Data) +type LevelAtom = LevelAtom' Term + --------------------------------------------------------------------------- +-- * Brave Terms +--------------------------------------------------------------------------- + +-- | Newtypes for terms that produce a dummy, rather than crash, when +-- applied to incompatible eliminations. +newtype BraveTerm = BraveTerm { unBrave :: Term } deriving (Data, Show) + +--------------------------------------------------------------------------- -- * Blocked Terms --------------------------------------------------------------------------- @@ -307,7 +388,7 @@ data Blocked t = Blocked { theBlockingMeta :: MetaId , ignoreBlocking :: t } | NotBlocked { blockingStatus :: NotBlocked, ignoreBlocking :: t } - deriving (Show, Functor, Foldable, Traversable) + deriving (Data, Show, Functor, Foldable, Traversable) -- deriving (Eq, Ord, Functor, Foldable, Traversable) -- | Blocking by a meta is dominant. @@ -405,11 +486,20 @@ -- pattern on the lhs. , clauseCatchall :: Bool -- ^ Clause has been labelled as CATCHALL. + , clauseRecursive :: Maybe Bool + -- ^ @clauseBody@ contains recursive calls; computed by termination checker. + -- @Nothing@ means that termination checker has not run yet, + -- or that @clauseBody@ contains meta-variables; + -- these could be filled with recursive calls later! + -- @Just False@ means definitely no recursive call. + -- @Just True@ means definitely a recursive call. , clauseUnreachable :: Maybe Bool -- ^ Clause has been labelled as unreachable by the coverage checker. -- @Nothing@ means coverage checker has not run yet (clause may be unreachable). -- @Just False@ means clause is not unreachable. -- @Just True@ means clause is unreachable. + , clauseEllipsis :: ExpandedEllipsis + -- ^ Was this clause created by expansion of an ellipsis? } deriving (Data, Show) @@ -428,6 +518,14 @@ nameToPatVarName :: Name -> PatVarName nameToPatVarName = nameToArgName +data PatternInfo = PatternInfo + { patOrigin :: PatOrigin + , patAsNames :: [Name] + } deriving (Data, Show, Eq) + +defaultPatternInfo :: PatternInfo +defaultPatternInfo = PatternInfo PatOSystem [] + -- | Origin of the pattern: what did the user write in this position? data PatOrigin = PatOSystem -- ^ Pattern inserted by the system @@ -448,20 +546,20 @@ -- the arguments we are matching with) use @QName@. -- data Pattern' x - = VarP PatOrigin x + = VarP PatternInfo x -- ^ @x@ - | DotP PatOrigin Term + | DotP PatternInfo Term -- ^ @.t@ | ConP ConHead ConPatternInfo [NamedArg (Pattern' x)] -- ^ @c ps@ -- The subpatterns do not contain any projection copatterns. - | LitP Literal + | LitP PatternInfo Literal -- ^ E.g. @5@, @"hello"@. | ProjP ProjOrigin QName -- ^ Projection copattern. Can only appear by itself. - | IApplyP PatOrigin Term Term x + | IApplyP PatternInfo Term Term x -- ^ Path elimination pattern, like @VarP@ but keeps track of endpoints. - | DefP PatOrigin QName [NamedArg (Pattern' x)] + | DefP PatternInfo QName [NamedArg (Pattern' x)] -- ^ Used for HITs, the QName should be the one from primHComp. deriving (Data, Show, Functor, Foldable, Traversable) @@ -469,11 +567,14 @@ -- ^ The @PatVarName@ is a name suggestion. varP :: a -> Pattern' a -varP = VarP PatOSystem +varP = VarP defaultPatternInfo dotP :: Term -> Pattern' a -dotP = DotP PatOSystem +dotP = DotP defaultPatternInfo +litP :: Literal -> Pattern' a +litP = LitP defaultPatternInfo + -- | Type used when numbering pattern variables. data DBPatVar = DBPatVar { dbPatVarName :: PatVarName @@ -484,26 +585,29 @@ namedVarP :: PatVarName -> Named_ Pattern namedVarP x = Named named $ varP x - where named = if isUnderscore x then Nothing else Just $ unranged x + where named = if isUnderscore x then Nothing else Just $ WithOrigin Inserted $ unranged x namedDBVarP :: Int -> PatVarName -> Named_ DeBruijnPattern namedDBVarP m = (fmap . fmap) (\x -> DBPatVar x m) . namedVarP -- | Make an absurd pattern with the given de Bruijn index. absurdP :: Int -> DeBruijnPattern -absurdP = VarP PatOAbsurd . DBPatVar absurdPatternName +absurdP = VarP (PatternInfo PatOAbsurd []) . DBPatVar absurdPatternName -- | The @ConPatternInfo@ states whether the constructor belongs to --- a record type (@Just@) or data type (@Nothing@). --- In the former case, the @PatOrigin@ says whether the record pattern --- orginates from the expansion of an implicit pattern. +-- a record type (@True@) or data type (@False@). +-- In the former case, the @PatOrigin@ of the @conPInfo@ says +-- whether the record pattern orginates from the expansion of an +-- implicit pattern. -- The @Type@ is the type of the whole record pattern. -- The scope used for the type is given by any outer scope -- plus the clause's telescope ('clauseTel'). data ConPatternInfo = ConPatternInfo - { conPRecord :: Maybe PatOrigin - -- ^ @Nothing@ if data constructor. - -- @Just@ if record constructor. + { conPInfo :: PatternInfo + -- ^ Information on the origin of the pattern. + , conPRecord :: Bool + -- ^ @False@ if data constructor. + -- @True@ if record constructor. , conPFallThrough :: Bool -- ^ Should the match block on non-canonical terms or can it -- proceed to the catch-all clause? @@ -515,8 +619,8 @@ -- plugin (like Agsy). -- Needed e.g. for with-clause stripping. , conPLazy :: Bool - -- ^ Lazy patterns are generated by the forcing translation - -- ('Agda.TypeChecking.Forcing.forcingTranslation') and are dropped by + -- ^ Lazy patterns are generated by the forcing translation in the unifier + -- ('Agda.TypeChecking.Rules.LHS.Unify.unifyStep') and are dropped by -- the clause compiler (TODO: not yet) -- ('Agda.TypeChecking.CompiledClause.Compile.compileClauses') when the -- variables they bind are unused. The GHC backend compiles lazy matches @@ -525,16 +629,18 @@ deriving (Data, Show) noConPatternInfo :: ConPatternInfo -noConPatternInfo = ConPatternInfo Nothing False Nothing False +noConPatternInfo = ConPatternInfo defaultPatternInfo False False Nothing False -- | Build partial 'ConPatternInfo' from 'ConInfo' toConPatternInfo :: ConInfo -> ConPatternInfo -toConPatternInfo ConORec = noConPatternInfo{ conPRecord = Just PatORec } +toConPatternInfo ConORec = noConPatternInfo{ conPInfo = PatternInfo PatORec [] , conPRecord = True } toConPatternInfo _ = noConPatternInfo -- | Build 'ConInfo' from 'ConPatternInfo'. fromConPatternInfo :: ConPatternInfo -> ConInfo -fromConPatternInfo = fromMaybe ConOCon . fmap patToConO . conPRecord +fromConPatternInfo i + | conPRecord i = patToConO $ patOrigin $ conPInfo i + | otherwise = ConOCon where patToConO :: PatOrigin -> ConOrigin patToConO = \case @@ -559,7 +665,7 @@ patternVars (Arg i (DotP _ t) ) = [Arg i $ Right t] patternVars (Arg _ (ConP _ _ ps)) = patternVars ps patternVars (Arg _ (DefP _ _ ps)) = patternVars ps - patternVars (Arg _ (LitP _) ) = [] + patternVars (Arg _ (LitP _ _) ) = [] patternVars (Arg _ ProjP{} ) = [] patternVars (Arg i (IApplyP _ _ _ x)) = [Arg i $ Left x] @@ -570,33 +676,45 @@ instance PatternVars a b => PatternVars a [b] where patternVars = concatMap patternVars +-- | Retrieve the PatternInfo from a pattern +patternInfo :: Pattern' x -> Maybe PatternInfo +patternInfo (VarP i _) = Just i +patternInfo (DotP i _) = Just i +patternInfo (LitP i _) = Just i +patternInfo (ConP _ ci _) = Just $ conPInfo ci +patternInfo ProjP{} = Nothing +patternInfo (IApplyP i _ _ _) = Just i +patternInfo (DefP i _ _) = Just i -- | Retrieve the origin of a pattern patternOrigin :: Pattern' x -> Maybe PatOrigin -patternOrigin (VarP o _) = Just o -patternOrigin (DotP o _) = Just o -patternOrigin LitP{} = Nothing -patternOrigin (ConP _ ci _) = conPRecord ci -patternOrigin ProjP{} = Nothing -patternOrigin (IApplyP o _ _ _) = Just o -patternOrigin (DefP o _ _) = Just o +patternOrigin = fmap patOrigin . patternInfo -- | Does the pattern perform a match that could fail? -properlyMatching :: DeBruijnPattern -> Bool -properlyMatching p - | patternOrigin p == Just PatOAbsurd = True -properlyMatching VarP{} = False -properlyMatching DotP{} = False -properlyMatching LitP{} = True -properlyMatching (ConP _ ci ps) = isNothing (conPRecord ci) || -- not a record cons - List.any (properlyMatching . namedArg) ps -- or one of subpatterns is a proper m -properlyMatching ProjP{} = True -properlyMatching IApplyP{} = False -properlyMatching DefP{} = True +properlyMatching :: Pattern' a -> Bool +properlyMatching = properlyMatching' True True +properlyMatching' + :: Bool -- ^ Should absurd patterns count as proper match? + -> Bool -- ^ Should projection patterns count as proper match? + -> Pattern' a -- ^ The pattern. + -> Bool +properlyMatching' absP projP = \case + p | absP && patternOrigin p == Just PatOAbsurd -> True + ConP _ ci ps -- record constructors do not count as proper matches themselves + | conPRecord ci -> List.any (properlyMatching . namedArg) ps + | otherwise -> True + LitP{} -> True + DefP{} -> True + ProjP{} -> projP + VarP{} -> False + DotP{} -> False + IApplyP{} -> False + instance IsProjP (Pattern' a) where - isProjP (ProjP o d) = Just (o, unambiguous d) - isProjP _ = Nothing + isProjP = \case + ProjP o d -> Just (o, unambiguous d) + _ -> Nothing ----------------------------------------------------------------------------- -- * Explicit substitutions @@ -634,7 +752,7 @@ -- @ | Wk !Int (Substitution' a) - -- ^ Weakning substitution, lifts to an extended context. + -- ^ Weakening substitution, lifts to an extended context. -- @ -- Γ ⊢ ρ : Δ -- ------------------- @@ -716,6 +834,10 @@ | OTerm Term deriving Show +isIOne :: IntervalView -> Bool +isIOne IOne = True +isIOne _ = False + --------------------------------------------------------------------------- -- * Absurd Lambda --------------------------------------------------------------------------- @@ -753,7 +875,7 @@ -- | Aux: A dummy term to constitute a dummy term/level/sort/type. dummyTerm' :: String -> Int -> Term -dummyTerm' file line = Dummy $ file ++ ":" ++ show line +dummyTerm' file line = flip Dummy [] $ file ++ ":" ++ show line -- | Aux: A dummy level to constitute a level/sort. dummyLevel' :: String -> Int -> Level @@ -762,30 +884,52 @@ -- | A dummy term created at location. -- Note: use macro __DUMMY_TERM__ ! dummyTerm :: String -> Int -> Term -dummyTerm file line = dummyTerm' ("dummyTerm: " ++ file) line +dummyTerm file = dummyTerm' ("dummyTerm: " ++ file) +__DUMMY_TERM__ :: HasCallStack => Term +__DUMMY_TERM__ = withFileAndLine' (freezeCallStack callStack) dummyTerm + -- | A dummy level created at location. -- Note: use macro __DUMMY_LEVEL__ ! dummyLevel :: String -> Int -> Level -dummyLevel file line = dummyLevel' ("dummyLevel: " ++ file) line +dummyLevel file = dummyLevel' ("dummyLevel: " ++ file) +__DUMMY_LEVEL__ :: HasCallStack => Level +__DUMMY_LEVEL__ = withFileAndLine' (freezeCallStack callStack) dummyLevel + -- | A dummy sort created at location. -- Note: use macro __DUMMY_SORT__ ! dummySort :: String -> Int -> Sort dummySort file line = DummyS $ file ++ ":" ++ show line +__DUMMY_SORT__ :: HasCallStack => Sort +__DUMMY_SORT__ = withFileAndLine' (freezeCallStack callStack) dummySort + -- | A dummy type created at location. -- Note: use macro __DUMMY_TYPE__ ! dummyType :: String -> Int -> Type -dummyType file line = El (DummyS "") $ dummyTerm' ("dummyType: " ++ file) line +dummyType file line = El (dummySort file line) $ dummyTerm' ("dummyType: " ++ file) line +__DUMMY_TYPE__ :: HasCallStack => Type +__DUMMY_TYPE__ = withFileAndLine' (freezeCallStack callStack) dummyType + -- | Context entries without a type have this dummy type. -- Note: use macro __DUMMY_DOM__ ! dummyDom :: String -> Int -> Dom Type dummyDom file line = defaultDom $ dummyType file line +__DUMMY_DOM__ :: HasCallStack => Dom Type +__DUMMY_DOM__ = withFileAndLine' (freezeCallStack callStack) dummyDom + +-- | Constant level @n@ +pattern ClosedLevel :: Integer -> Level +pattern ClosedLevel n = Max n [] + +atomicLevel :: LevelAtom -> Level +atomicLevel a = Max 0 [ Plus 0 a ] + unreducedLevel :: Term -> Level -unreducedLevel v = Max [ Plus 0 $ UnreducedLevel v ] +unreducedLevel v = atomicLevel $ UnreducedLevel v -- | Top sort (Set\omega). topSort :: Type @@ -795,22 +939,24 @@ sort s = El (UnivSort s) $ Sort s varSort :: Int -> Sort -varSort n = Type $ Max [Plus 0 $ NeutralLevel mempty $ var n] +varSort n = Type $ atomicLevel $ NeutralLevel mempty $ var n tmSort :: Term -> Sort -tmSort t = Type $ Max [Plus 0 $ UnreducedLevel t] +tmSort t = Type $ unreducedLevel t +-- | Given a constant @m@ and level @l@, compute @m + l@ +levelPlus :: Integer -> Level -> Level +levelPlus m (Max n as) = Max (m + n) $ map pplus as + where pplus (Plus n l) = Plus (m + n) l + levelSuc :: Level -> Level -levelSuc (Max []) = Max [ClosedLevel 1] -levelSuc (Max as) = Max $ map inc as - where inc (ClosedLevel n) = ClosedLevel (n + 1) - inc (Plus n l) = Plus (n + 1) l +levelSuc = levelPlus 1 mkType :: Integer -> Sort -mkType n = Type $ Max [ClosedLevel n | n > 0] +mkType n = Type $ ClosedLevel n mkProp :: Integer -> Sort -mkProp n = Prop $ Max [ClosedLevel n | n > 0] +mkProp n = Prop $ ClosedLevel n isSort :: Term -> Maybe Sort isSort v = case v of @@ -818,7 +964,7 @@ _ -> Nothing impossibleTerm :: String -> Int -> Term -impossibleTerm file line = Dummy $ unlines +impossibleTerm file line = flip Dummy [] $ unlines [ "An internal error has occurred. Please report this as a bug." , "Location of the error: " ++ file ++ ":" ++ show line ] @@ -856,7 +1002,7 @@ telFromList' :: (a -> ArgName) -> ListTel' a -> Telescope telFromList' f = List.foldr extTel EmptyTel where - extTel dom@(Dom{unDom = (x, a)}) = ExtendTel (dom{unDom = a}) . Abs (f x) + extTel dom@Dom{unDom = (x, a)} = ExtendTel (dom{unDom = a}) . Abs (f x) -- | Convert a list telescope to a telescope. telFromList :: ListTel -> Telescope @@ -904,11 +1050,17 @@ blockingMeta NotBlocked{} = Nothing blocked :: MetaId -> a -> Blocked a -blocked x = Blocked x +blocked = Blocked notBlocked :: a -> Blocked a notBlocked = NotBlocked ReallyNotBlocked +blocked_ :: MetaId -> Blocked_ +blocked_ x = blocked x () + +notBlocked_ :: Blocked_ +notBlocked_ = notBlocked () + --------------------------------------------------------------------------- -- * Simple operations on terms and types. --------------------------------------------------------------------------- @@ -925,23 +1077,32 @@ Pi _ b -> 1 + arity (unAbs b) _ -> 0 --- | Pick the better name suggestion, i.e., the one that is not just underscore. -class Suggest a b where - suggest :: a -> b -> String +-- | Suggest a name if available (i.e. name is not "_") +class Suggest a where + suggestName :: a -> Maybe String -instance Suggest String String where - suggest "_" y = y - suggest x _ = x +instance Suggest String where + suggestName "_" = Nothing + suggestName x = Just x -instance Suggest (Abs a) (Abs b) where - suggest b1 b2 = suggest (absName b1) (absName b2) +instance Suggest (Abs b) where + suggestName = suggestName . absName -instance Suggest String (Abs b) where - suggest x b = suggest x (absName b) +instance Suggest Name where + suggestName = suggestName . nameToArgName -instance Suggest Name (Abs b) where - suggest n b = suggest (nameToArgName n) (absName b) +instance Suggest Term where + suggestName (Lam _ v) = suggestName v + suggestName _ = Nothing +-- Wrapping @forall a. (Suggest a) => a@ into a datatype because +-- GHC doesn't support impredicative polymorphism +data Suggestion = forall a. Suggest a => Suggestion a + +suggests :: [Suggestion] -> String +suggests [] = "x" +suggests (Suggestion x : xs) = fromMaybe (suggests xs) $ suggestName x + --------------------------------------------------------------------------- -- * Eliminations. --------------------------------------------------------------------------- @@ -1009,7 +1170,7 @@ class IsProjElim e where isProjElim :: e -> Maybe (ProjOrigin, QName) -instance IsProjElim Elim where +instance IsProjElim (Elim' a) where isProjElim (Proj o d) = Just (o, d) isProjElim Apply{} = Nothing isProjElim IApply{} = Nothing @@ -1034,8 +1195,8 @@ -- | A 'null' clause is one with no patterns and no rhs. -- Should not exist in practice. instance Null Clause where - empty = Clause empty empty empty empty empty empty False Nothing - null (Clause _ _ tel pats body _ _ _) + empty = Clause empty empty empty empty empty empty False Nothing Nothing empty + null (Clause _ _ tel pats body _ _ _ _ _) = null tel && null pats && null body @@ -1107,17 +1268,17 @@ Prop l -> 1 + tsize l Inf -> 1 SizeUniv -> 1 - PiSort s s' -> 1 + tsize s + tsize s' + PiSort a s -> 1 + tsize a + tsize s + FunSort s1 s2 -> 1 + tsize s1 + tsize s2 UnivSort s -> 1 + tsize s MetaS _ es -> 1 + tsize es DefS _ es -> 1 + tsize es DummyS{} -> 1 instance TermSize Level where - tsize (Max as) = 1 + tsize as + tsize (Max _ as) = 1 + tsize as instance TermSize PlusLevel where - tsize (ClosedLevel _) = 1 tsize (Plus _ a) = tsize a instance TermSize LevelAtom where @@ -1156,10 +1317,9 @@ Dummy{} -> v instance KillRange Level where - killRange (Max as) = killRange1 Max as + killRange (Max n as) = killRange1 (Max n) as instance KillRange PlusLevel where - killRange l@ClosedLevel{} = l killRange (Plus n l) = killRange1 (Plus n) l instance KillRange LevelAtom where @@ -1177,7 +1337,8 @@ SizeUniv -> SizeUniv Type a -> killRange1 Type a Prop a -> killRange1 Prop a - PiSort s1 s2 -> killRange2 PiSort s1 s2 + PiSort a s -> killRange2 PiSort a s + FunSort s1 s2 -> killRange2 FunSort s1 s2 UnivSort s -> killRange1 UnivSort s MetaS x es -> killRange1 (MetaS x) es DefS d es -> killRange2 DefS d es @@ -1194,8 +1355,11 @@ instance KillRange PatOrigin where killRange = id +instance KillRange PatternInfo where + killRange (PatternInfo o xs) = killRange2 PatternInfo o xs + instance KillRange ConPatternInfo where - killRange (ConPatternInfo mr b mt lz) = killRange1 (ConPatternInfo mr b) mt lz + killRange (ConPatternInfo i mr b mt lz) = killRange1 (ConPatternInfo i mr b) mt lz instance KillRange DBPatVar where killRange (DBPatVar x i) = killRange2 DBPatVar x i @@ -1206,14 +1370,14 @@ VarP o x -> killRange2 VarP o x DotP o v -> killRange2 DotP o v ConP con info ps -> killRange3 ConP con info ps - LitP l -> killRange1 LitP l + LitP o l -> killRange2 LitP o l ProjP o q -> killRange1 (ProjP o) q IApplyP o u t x -> killRange3 (IApplyP o) u t x DefP o q ps -> killRange2 (DefP o) q ps instance KillRange Clause where - killRange (Clause rl rf tel ps body t catchall unreachable) = - killRange8 Clause rl rf tel ps body t catchall unreachable + killRange (Clause rl rf tel ps body t catchall recursive unreachable ell) = + killRange10 Clause rl rf tel ps body t catchall recursive unreachable ell instance KillRange a => KillRange (Tele a) where killRange = fmap killRange @@ -1227,29 +1391,17 @@ instance KillRange a => KillRange (Elim' a) where killRange = fmap killRange ---------------------------------------------------------------------------- --- * UniverseBi instances. ---------------------------------------------------------------------------- - -instanceUniverseBiT' [] [t| (([Type], [Clause]), Pattern) |] -instanceUniverseBiT' [] [t| (Args, Pattern) |] -instanceUniverseBiT' [] [t| (Elims, Pattern) |] -- ? -instanceUniverseBiT' [] [t| (([Type], [Clause]), Term) |] -instanceUniverseBiT' [] [t| (Args, Term) |] -instanceUniverseBiT' [] [t| (Elims, Term) |] -- ? -instanceUniverseBiT' [] [t| ([Term], Term) |] - ----------------------------------------------------------------------------- -- * Simple pretty printing ----------------------------------------------------------------------------- instance Pretty a => Pretty (Substitution' a) where - prettyPrec p rho = pr p rho + prettyPrec = pr where pr p rho = case rho of IdS -> "idS" EmptyS err -> "emptyS" - t :# rho -> mparens (p > 2) $ sep [ pr 2 rho P.<> ",", prettyPrec 3 t ] + t :# rho -> mparens (p > 2) $ sep [ pr 2 rho <> ",", prettyPrec 3 t ] Strengthen _ rho -> mparens (p > 9) $ "strS" <+> pr 10 rho Wk n rho -> mparens (p > 9) $ text ("wkS " ++ show n) <+> pr 10 rho Lift n rho -> mparens (p > 9) $ text ("liftS " ++ show n) <+> pr 10 rho @@ -1275,11 +1427,17 @@ Level l -> prettyPrec p l MetaV x els -> pretty x `pApp` els DontCare v -> prettyPrec p v - Dummy s -> parens $ text s + Dummy s es -> parens (text s) `pApp` es where pApp d els = mparens (not (null els) && p > 9) $ sep [d, nest 2 $ fsep (map (prettyPrec 10) els)] +instance (Pretty t, Pretty e) => Pretty (Dom' t e) where + pretty dom = pTac <+> pDom dom (pretty $ unDom dom) + where + pTac | Just t <- domTactic dom = "@" <> parens ("tactic" <+> pretty t) + | otherwise = empty + pDom :: LensHiding a => a -> Doc -> Doc pDom i = case getHiding i of @@ -1303,21 +1461,22 @@ telToList EmptyTel = [] telToList (ExtendTel a tel) = (absName tel, a) : telToList (unAbs tel) +prettyPrecLevelSucs :: Int -> Integer -> (Int -> Doc) -> Doc +prettyPrecLevelSucs p 0 d = d p +prettyPrecLevelSucs p n d = mparens (p > 9) $ "lsuc" <+> prettyPrecLevelSucs 10 (n - 1) d + instance Pretty Level where - prettyPrec p (Max as) = + prettyPrec p (Max n as) = case as of - [] -> prettyPrec p (ClosedLevel 0) - [a] -> prettyPrec p a - _ -> mparens (p > 9) $ List.foldr1 (\a b -> "lub" <+> a <+> b) $ map (prettyPrec 10) as + [] -> prettyN + [a] | n == 0 -> prettyPrec p a + _ -> mparens (p > 9) $ List.foldr1 (\a b -> "lub" <+> a <+> b) $ + [ prettyN | n > 0 ] ++ map (prettyPrec 10) as + where + prettyN = prettyPrecLevelSucs p n (const "lzero") instance Pretty PlusLevel where - prettyPrec p l = - case l of - ClosedLevel n -> sucs p n $ \_ -> "lzero" - Plus n a -> sucs p n $ \p -> prettyPrec p a - where - sucs p 0 d = d p - sucs p n d = mparens (p > 9) $ "lsuc" <+> sucs 10 (n - 1) d + prettyPrec p (Plus n a) = prettyPrecLevelSucs p n $ \p -> prettyPrec p a instance Pretty LevelAtom where prettyPrec p a = @@ -1330,18 +1489,20 @@ instance Pretty Sort where prettyPrec p s = case s of - Type (Max []) -> "Set" - Type (Max [ClosedLevel n]) -> text $ "Set" ++ show n + Type (ClosedLevel 0) -> "Set" + Type (ClosedLevel n) -> text $ "Set" ++ show n Type l -> mparens (p > 9) $ "Set" <+> prettyPrec 10 l - Prop (Max []) -> "Prop" - Prop (Max [ClosedLevel n]) -> text $ "Prop" ++ show n + Prop (ClosedLevel 0) -> "Prop" + Prop (ClosedLevel n) -> text $ "Prop" ++ show n Prop l -> mparens (p > 9) $ "Prop" <+> prettyPrec 10 l Inf -> "Setω" SizeUniv -> "SizeUniv" - PiSort s b -> mparens (p > 9) $ - "piSort" <+> prettyPrec 10 s + PiSort a b -> mparens (p > 9) $ + "piSort" <+> pDom (domInfo a) (text (absName b) <+> ":" <+> pretty (unDom a)) <+> parens (sep [ text ("λ " ++ absName b ++ " ->") , nest 2 $ pretty (unAbs b) ]) + FunSort a b -> mparens (p > 9) $ + "funSort" <+> prettyPrec 10 a <+> prettyPrec 10 b UnivSort s -> mparens (p > 9) $ "univSort" <+> prettyPrec 10 s MetaS x es -> prettyPrec p $ MetaV x es DefS d es -> prettyPrec p $ Def d es @@ -1360,10 +1521,12 @@ instance Pretty a => Pretty (Pattern' a) where prettyPrec n (VarP _o x) = prettyPrec n x - prettyPrec _ (DotP _o t) = "." P.<> prettyPrec 10 t + prettyPrec _ (DotP _o t) = "." <> prettyPrec 10 t prettyPrec n (ConP c i nps)= mparens (n > 0 && not (null nps)) $ - pretty (conName c) <+> fsep (map (prettyPrec 10) ps) + (lazy <> pretty (conName c)) <+> fsep (map (prettyPrec 10) ps) where ps = map (fmap namedThing) nps + lazy | conPLazy i = "~" + | otherwise = empty prettyPrec n (DefP o q nps)= mparens (n > 0 && not (null nps)) $ pretty q <+> fsep (map (prettyPrec 10) ps) where ps = map (fmap namedThing) nps @@ -1373,7 +1536,7 @@ -- where -- b = maybe False (== ConOSystem) $ conPRecord i -- prTy d = caseMaybe (conPType i) d $ \ t -> d <+> ":" <+> pretty t - prettyPrec _ (LitP l) = pretty l + prettyPrec _ (LitP _ l) = pretty l prettyPrec _ (ProjP _o q) = text ("." ++ prettyShow q) prettyPrec n (IApplyP _o _ _ x) = prettyPrec n x ----------------------------------------------------------------------------- @@ -1394,7 +1557,7 @@ Level l -> rnf l MetaV _ es -> rnf es DontCare v -> rnf v - Dummy _ -> () + Dummy _ es -> rnf es instance NFData Type where rnf (El s v) = rnf (s, v) @@ -1406,16 +1569,16 @@ Inf -> () SizeUniv -> () PiSort a b -> rnf (a, unAbs b) + FunSort a b -> rnf (a, b) UnivSort a -> rnf a MetaS _ es -> rnf es DefS _ es -> rnf es DummyS _ -> () instance NFData Level where - rnf (Max as) = rnf as + rnf (Max n as) = rnf (n, as) instance NFData PlusLevel where - rnf (ClosedLevel n) = rnf n rnf (Plus n l) = rnf (n, l) instance NFData LevelAtom where @@ -1428,3 +1591,6 @@ rnf (Apply x) = rnf x rnf Proj{} = () rnf (IApply x y r) = rnf x `seq` rnf y `seq` rnf r + +instance NFData e => NFData (Dom e) where + rnf (Dom a b c d e) = rnf a `seq` rnf b `seq` rnf c `seq` rnf d `seq` rnf e diff --git a/src/full/Agda/Syntax/Internal/Defs.hs b/src/full/Agda/Syntax/Internal/Defs.hs --- a/src/full/Agda/Syntax/Internal/Defs.hs +++ b/src/full/Agda/Syntax/Internal/Defs.hs @@ -81,17 +81,17 @@ Prop l -> getDefs l Inf -> return () SizeUniv -> return () - PiSort s s' -> getDefs s >> getDefs s' + PiSort a s -> getDefs a >> getDefs s + FunSort s1 s2 -> getDefs s1 >> getDefs s2 UnivSort s -> getDefs s MetaS x es -> getDefs x >> getDefs es DefS d es -> doDef d >> getDefs es DummyS{} -> return () instance GetDefs Level where - getDefs (Max ls) = getDefs ls + getDefs (Max _ ls) = getDefs ls instance GetDefs PlusLevel where - getDefs ClosedLevel{} = return () getDefs (Plus _ l) = getDefs l instance GetDefs LevelAtom where diff --git a/src/full/Agda/Syntax/Internal/Generic.hs b/src/full/Agda/Syntax/Internal/Generic.hs --- a/src/full/Agda/Syntax/Internal/Generic.hs +++ b/src/full/Agda/Syntax/Internal/Generic.hs @@ -1,13 +1,13 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE CPP #-} -- | Tree traversal for internal syntax. module Agda.Syntax.Internal.Generic where -import Data.Traversable -import Data.Monoid -import Data.Foldable +#if __GLASGOW_HASKELL__ < 804 +import Data.Monoid ((<>)) +#endif import Agda.Syntax.Common import Agda.Syntax.Internal @@ -58,14 +58,15 @@ -- Functors -instance TermLike a => TermLike (Elim' a) where -instance TermLike a => TermLike (Arg a) where -instance TermLike a => TermLike (Dom a) where -instance TermLike a => TermLike [a] where -instance TermLike a => TermLike (Maybe a) where -instance TermLike a => TermLike (Abs a) where -instance TermLike a => TermLike (Blocked a) where -instance TermLike a => TermLike (Tele a) where +instance TermLike a => TermLike (Elim' a) where +instance TermLike a => TermLike (Arg a) where +instance TermLike a => TermLike (Dom a) where +instance TermLike a => TermLike [a] where +instance TermLike a => TermLike (Maybe a) where +instance TermLike a => TermLike (Abs a) where +instance TermLike a => TermLike (Blocked a) where +instance TermLike a => TermLike (Tele a) where +instance TermLike a => TermLike (WithHiding a) where -- Tuples @@ -112,15 +113,12 @@ Dummy{} -> mempty instance TermLike Level where - traverseTermM f (Max as) = Max <$> traverseTermM f as - foldTerm f (Max as) = foldTerm f as + traverseTermM f (Max n as) = Max n <$> traverseTermM f as + foldTerm f (Max n as) = foldTerm f as instance TermLike PlusLevel where - traverseTermM f l = case l of - ClosedLevel{} -> return l - Plus n l -> Plus n <$> traverseTermM f l - foldTerm f ClosedLevel{} = mempty - foldTerm f (Plus _ l) = foldTerm f l + traverseTermM f (Plus n l) = Plus n <$> traverseTermM f l + foldTerm f (Plus _ l) = foldTerm f l instance TermLike LevelAtom where traverseTermM f l = case l of @@ -145,6 +143,7 @@ Inf -> pure s SizeUniv -> pure s PiSort a b -> PiSort <$> traverseTermM f a <*> traverseTermM f b + FunSort a b -> FunSort <$> traverseTermM f a <*> traverseTermM f b UnivSort a -> UnivSort <$> traverseTermM f a MetaS x es -> MetaS x <$> traverseTermM f es DefS q es -> DefS q <$> traverseTermM f es @@ -156,6 +155,7 @@ Inf -> mempty SizeUniv -> mempty PiSort a b -> foldTerm f a <> foldTerm f b + FunSort a b -> foldTerm f a <> foldTerm f b UnivSort a -> foldTerm f a MetaS _ es -> foldTerm f es DefS _ es -> foldTerm f es diff --git a/src/full/Agda/Syntax/Internal/MetaVars.hs b/src/full/Agda/Syntax/Internal/MetaVars.hs new file mode 100644 --- /dev/null +++ b/src/full/Agda/Syntax/Internal/MetaVars.hs @@ -0,0 +1,45 @@ + +module Agda.Syntax.Internal.MetaVars where + +import Data.Monoid + +import Agda.Syntax.Common +import Agda.Syntax.Internal +import Agda.Syntax.Internal.Generic + +import Agda.Utils.Singleton + +-- | Returns every meta-variable occurrence in the given type, except +-- for those in 'Sort's. +allMetas :: (TermLike a, Monoid m) => (MetaId -> m) -> a -> m +allMetas singl = foldTerm metas + where + metas (MetaV m _) = singl m + metas (Level l) = levelMetas l + metas _ = mempty + + levelMetas (Max _ as) = foldMap plusLevelMetas as + + plusLevelMetas (Plus _ l) = levelAtomMetas l + + levelAtomMetas (MetaLevel m _) = singl m + levelAtomMetas _ = mempty + +-- | Returns 'allMetas' in a list. +-- @allMetasList = allMetas (:[])@. +-- +-- Note: this resulting list is computed via difference lists. +-- Thus, use this function if you actually need the whole list of metas. +-- Otherwise, use 'allMetas' with a suitable monoid. +allMetasList :: TermLike a => a -> [MetaId] +allMetasList t = allMetas singleton t `appEndo` [] + +-- | 'True' if thing contains no metas. +-- @noMetas = null . allMetasList@. +noMetas :: TermLike a => a -> Bool +noMetas = getAll . allMetas (\ _m -> All False) + +-- | Returns the first meta it find in the thing, if any. +-- @firstMeta == listToMaybe . allMetasList@. +firstMeta :: TermLike a => a -> Maybe MetaId +firstMeta = getFirst . allMetas (First . Just) diff --git a/src/full/Agda/Syntax/Internal/Names.hs b/src/full/Agda/Syntax/Internal/Names.hs --- a/src/full/Agda/Syntax/Internal/Names.hs +++ b/src/full/Agda/Syntax/Internal/Names.hs @@ -1,12 +1,11 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE TypeFamilies #-} -- | Extract all names from things. module Agda.Syntax.Internal.Names where -import Data.Foldable -import Data.Map (Map) +import Data.List.NonEmpty (NonEmpty(..)) +import qualified Data.List.NonEmpty as NonEmpty import qualified Data.Map as Map import Data.Set (Set) import qualified Data.Set as Set @@ -20,11 +19,8 @@ import Agda.TypeChecking.Monad.Base import Agda.TypeChecking.CompiledClause -import Agda.Utils.Functor -import Agda.Utils.NonemptyList import Agda.Utils.Impossible -#include "undefined.h" class NamesIn a where namesIn :: a -> Set QName @@ -34,7 +30,7 @@ instance NamesIn a => NamesIn (Maybe a) where instance NamesIn a => NamesIn [a] where -instance NamesIn a => NamesIn (NonemptyList a) where +instance NamesIn a => NamesIn (NonEmpty a) where instance NamesIn a => NamesIn (Arg a) where instance NamesIn a => NamesIn (Dom a) where instance NamesIn a => NamesIn (Named n a) where @@ -49,6 +45,9 @@ instance (NamesIn a, NamesIn b, NamesIn c) => NamesIn (a, b, c) where namesIn (x, y, z) = namesIn (x, (y, z)) +instance (NamesIn a, NamesIn b, NamesIn c, NamesIn d) => NamesIn (a, b, c, d) where + namesIn (x, y, z, u) = namesIn ((x, y), (z, u)) + instance NamesIn CompKit where namesIn (CompKit a b) = namesIn (a,b) @@ -71,15 +70,15 @@ -- Andreas 2017-07-27, Q: which names can be in @cc@ which are not already in @cl@? Function { funClauses = cl, funCompiled = cc } -> namesIn (cl, cc) Datatype { dataClause = cl, dataCons = cs, dataSort = s } -> namesIn (cl, cs, s) - Record { recClause = cl, recConHead = c, recFields = fs, recComp = comp } -> namesIn (cl, c, (fs, comp)) + Record { recClause = cl, recConHead = c, recFields = fs, recComp = comp } -> namesIn (cl, c, fs, comp) -- Don't need recTel since those will be reachable from the constructor - Constructor { conSrcCon = c, conData = d, conComp = cn } -> namesIn (c, d, cn) + Constructor { conSrcCon = c, conData = d, conComp = kit, conProj = fs } -> namesIn (c, d, kit, fs) Primitive { primClauses = cl, primCompiled = cc } -> namesIn (cl, cc) AbstractDefn{} -> __IMPOSSIBLE__ instance NamesIn Clause where namesIn Clause{ clauseTel = tel, namedClausePats = ps, clauseBody = b, clauseType = t } = - namesIn ((tel, ps, b), t) + namesIn (tel, ps, b, t) instance NamesIn CompiledClauses where namesIn (Case _ c) = namesIn c @@ -95,7 +94,7 @@ instance NamesIn (Pattern' a) where namesIn p = case p of VarP{} -> Set.empty - LitP l -> namesIn l + LitP _ l -> namesIn l DotP _ v -> namesIn v ConP c _ args -> namesIn (c, args) DefP o q args -> namesIn (q, args) @@ -112,6 +111,7 @@ Inf -> Set.empty SizeUniv -> Set.empty PiSort a b -> namesIn (a, b) + FunSort a b -> namesIn (a, b) UnivSort a -> namesIn a MetaS _ es -> namesIn es DefS d es -> namesIn (d, es) @@ -132,11 +132,10 @@ Dummy{} -> Set.empty instance NamesIn Level where - namesIn (Max ls) = namesIn ls + namesIn (Max _ ls) = namesIn ls instance NamesIn PlusLevel where - namesIn ClosedLevel{} = Set.empty - namesIn (Plus _ l) = namesIn l + namesIn (Plus _ l) = namesIn l instance NamesIn LevelAtom where namesIn l = case l of diff --git a/src/full/Agda/Syntax/Internal/Pattern.hs b/src/full/Agda/Syntax/Internal/Pattern.hs --- a/src/full/Agda/Syntax/Internal/Pattern.hs +++ b/src/full/Agda/Syntax/Internal/Pattern.hs @@ -1,31 +1,23 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE TypeFamilies #-} -- because of type equality ~ {-# LANGUAGE UndecidableInstances #-} -- because of func. deps. module Agda.Syntax.Internal.Pattern where -import Control.Arrow (first, second) +import Control.Arrow (second) import Control.Monad.State import Data.Maybe import Data.Monoid import qualified Data.List as List -import Data.Foldable -import Data.Traversable import Agda.Syntax.Common import Agda.Syntax.Abstract (IsProjP(..)) import Agda.Syntax.Internal -import qualified Agda.Syntax.Internal as I -import Agda.Utils.Empty -import Agda.Utils.Functor import Agda.Utils.List import Agda.Utils.Permutation import Agda.Utils.Size (size) -import Agda.Utils.Tuple -#include "undefined.h" import Agda.Utils.Impossible -- * Tools for clauses @@ -92,7 +84,7 @@ DotP o t -> DotP o t <$ next ConP c mt ps -> ConP c mt <$> labelPatVars ps DefP o q ps -> DefP o q <$> labelPatVars ps - LitP l -> return $ LitP l + LitP o l -> return $ LitP o l ProjP o q -> return $ ProjP o q IApplyP o u t x -> do i <- next return $ IApplyP o u t (DBPatVar x i) @@ -145,7 +137,7 @@ getIndices (ConP c _ ps) = concatMap (getIndices . namedThing . unArg) ps getIndices (DefP _ _ ps) = concatMap (getIndices . namedThing . unArg) ps getIndices (DotP _ _) = [Nothing | countDots] - getIndices (LitP _) = [] + getIndices (LitP _ _) = [] getIndices ProjP{} = [] getIndices (IApplyP _ _ _ x) = [Just $ dbPatVarIndex x] @@ -168,7 +160,7 @@ patternToElim (Arg ai (DefP o q ps)) = Apply $ Arg ai $ Def q $ map (patternToElim . fmap namedThing) ps patternToElim (Arg ai (DotP o t) ) = Apply $ Arg ai t -patternToElim (Arg ai (LitP l) ) = Apply $ Arg ai $ Lit l +patternToElim (Arg ai (LitP o l) ) = Apply $ Arg ai $ Lit l patternToElim (Arg ai (ProjP o dest)) = Proj o dest patternToElim (Arg ai (IApplyP o t u x)) = IApply t u $ var $ dbPatVarIndex x @@ -204,7 +196,7 @@ case namedArg np of VarP o x -> f np DotP o t -> f np - LitP l -> f np + LitP o l -> f np ProjP o q -> f np ConP c i ps -> f $ setNamedArg np $ ConP c i $ mapNamedArgPattern f ps DefP o q ps -> f $ setNamedArg np $ DefP o q $ mapNamedArgPattern f ps @@ -274,7 +266,7 @@ ConP _ _ ps -> foldrPattern f ps DefP _ _ ps -> foldrPattern f ps VarP _ _ -> mempty - LitP _ -> mempty + LitP _ _ -> mempty DotP _ _ -> mempty ProjP _ _ -> mempty IApplyP{} -> mempty @@ -285,7 +277,7 @@ ConP c ci ps -> ConP c ci <$> traversePatternM pre post ps DefP o q ps -> DefP o q <$> traversePatternM pre post ps VarP _ _ -> return p - LitP _ -> return p + LitP _ _ -> return p DotP _ _ -> return p ProjP _ _ -> return p IApplyP{} -> return p @@ -333,10 +325,11 @@ patternVarModalities arg = map (second (m <>)) (patternVarModalities $ unArg arg) where m = getModality arg -instance PatternVarModalities a x => PatternVarModalities (Elim' a) x where - patternVarModalities (Apply x) = patternVarModalities x -- Note: x :: Arg a - patternVarModalities (IApply x y p) = patternVarModalities [x, y, p] - patternVarModalities Proj{} = [] +-- UNUSED: +-- instance PatternVarModalities a x => PatternVarModalities (Elim' a) x where +-- patternVarModalities (Apply x) = patternVarModalities x -- Note: x :: Arg a +-- patternVarModalities (IApply x y p) = patternVarModalities [x, y, p] +-- patternVarModalities Proj{} = [] instance PatternVarModalities (Pattern' x) x where patternVarModalities p = diff --git a/src/full/Agda/Syntax/Internal/SanityCheck.hs b/src/full/Agda/Syntax/Internal/SanityCheck.hs --- a/src/full/Agda/Syntax/Internal/SanityCheck.hs +++ b/src/full/Agda/Syntax/Internal/SanityCheck.hs @@ -1,27 +1,18 @@ -{-# LANGUAGE CPP #-} -- | Sanity checking for internal syntax. Mostly checking variable scoping. module Agda.Syntax.Internal.SanityCheck where -#if MIN_VERSION_base(4,11,0) -import Prelude hiding ((<>)) -#endif - import Control.Monad import qualified Data.IntSet as Set -import Text.PrettyPrint (empty) - import Agda.Syntax.Internal import Agda.TypeChecking.Free import Agda.TypeChecking.Monad -import Agda.TypeChecking.Substitute import Agda.Utils.List ( dropEnd ) import Agda.Utils.Pretty import Agda.Utils.Size import Agda.Utils.Impossible -#include "undefined.h" sanityCheckVars :: (Pretty a, Free a) => Telescope -> a -> TCM () sanityCheckVars tel v = diff --git a/src/full/Agda/Syntax/Literal.hs b/src/full/Agda/Syntax/Literal.hs --- a/src/full/Agda/Syntax/Literal.hs +++ b/src/full/Agda/Syntax/Literal.hs @@ -43,7 +43,7 @@ pretty (LitWord64 _ n) = text $ show n pretty (LitFloat _ d) = text $ show d pretty (LitString _ s) = text $ showString' s "" - pretty (LitChar _ c) = text $ "'" ++ showChar' c "" ++ "'" + pretty (LitChar _ c) = text $ "'" ++ showChar' c "'" pretty (LitQName _ x) = pretty x pretty (LitMeta _ _ x) = pretty x diff --git a/src/full/Agda/Syntax/Notation.hs b/src/full/Agda/Syntax/Notation.hs --- a/src/full/Agda/Syntax/Notation.hs +++ b/src/full/Agda/Syntax/Notation.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE DeriveDataTypeable #-} {-| As a concrete name, a notation is a non-empty list of alternating 'IdPart's and holes. @@ -14,22 +13,30 @@ module Agda.Syntax.Notation where +import Prelude hiding (null) + import Control.DeepSeq import Control.Monad import qualified Data.List as List import Data.Maybe +import Data.Set (Set) +import qualified Data.Set as Set import Data.Data (Data) +import qualified Agda.Syntax.Abstract.Name as A import Agda.Syntax.Common +import Agda.Syntax.Concrete.Name import Agda.Syntax.Position import Agda.Utils.Except ( MonadError(throwError) ) +import Agda.Utils.Functor ((<&>)) +import Agda.Utils.Lens import Agda.Utils.List +import Agda.Utils.Null import Agda.Utils.Impossible -#include "undefined.h" -- | Data type constructed in the Happy parser; converted to 'GenPart' -- before it leaves the Happy code. @@ -45,67 +52,6 @@ isLambdaHole (LambdaHole _ _) = True isLambdaHole _ = False --- | Notation as provided by the @syntax@ declaration. -type Notation = [GenPart] - --- | Part of a Notation -data GenPart - = BindHole Range (Ranged Int) - -- ^ Argument is the position of the hole (with binding) where the binding should occur. - -- First range is the rhs range and second is the binder. - | NormalHole Range (NamedArg (Ranged Int)) - -- ^ Argument is where the expression should go. - | WildHole (Ranged Int) - -- ^ An underscore in binding position. - | IdPart RString - deriving (Data, Show) - -instance Eq GenPart where - BindHole _ i == BindHole _ j = i == j - NormalHole _ x == NormalHole _ y = x == y - WildHole i == WildHole j = i == j - IdPart x == IdPart y = x == y - _ == _ = False - -instance Ord GenPart where - BindHole _ i `compare` BindHole _ j = i `compare` j - NormalHole _ x `compare` NormalHole _ y = x `compare` y - WildHole i `compare` WildHole j = i `compare` j - IdPart x `compare` IdPart y = x `compare` y - BindHole{} `compare` _ = LT - _ `compare` BindHole{} = GT - NormalHole{} `compare` _ = LT - _ `compare` NormalHole{} = GT - WildHole{} `compare` _ = LT - _ `compare` WildHole{} = GT - -instance HasRange GenPart where - getRange p = case p of - IdPart x -> getRange x - BindHole r _ -> r - WildHole i -> getRange i - NormalHole r _ -> r - -instance SetRange GenPart where - setRange r p = case p of - IdPart x -> IdPart x - BindHole _ i -> BindHole r i - WildHole i -> WildHole i - NormalHole _ i -> NormalHole r i - -instance KillRange GenPart where - killRange p = case p of - IdPart x -> IdPart $ killRange x - BindHole _ i -> BindHole noRange $ killRange i - WildHole i -> WildHole $ killRange i - NormalHole _ x -> NormalHole noRange $ killRange x - -instance NFData GenPart where - rnf (BindHole _ a) = rnf a - rnf (NormalHole _ a) = rnf a - rnf (WildHole a) = rnf a - rnf (IdPart a) = rnf a - -- | Get a flat list of identifier parts of a notation. stringParts :: Notation -> [String] stringParts gs = [ rangedThing x | IdPart x <- gs ] @@ -270,5 +216,163 @@ [ _hole ] -> True _ -> False -noNotation :: Notation -noNotation = [] +-- | All the notation information related to a name. +data NewNotation = NewNotation + { notaName :: QName + , notaNames :: Set A.Name + -- ^ The names the syntax and/or fixity belong to. + -- + -- Invariant: The set is non-empty. Every name in the list matches + -- 'notaName'. + , notaFixity :: Fixity + -- ^ Associativity and precedence (fixity) of the names. + , notation :: Notation + -- ^ Syntax associated with the names. + , notaIsOperator :: Bool + -- ^ True if the notation comes from an operator (rather than a + -- syntax declaration). + } deriving Show + +instance LensFixity NewNotation where + lensFixity f nota = f (notaFixity nota) <&> \ fx -> nota { notaFixity = fx } + +-- | If an operator has no specific notation, then it is computed from +-- its name. +namesToNotation :: QName -> A.Name -> NewNotation +namesToNotation q n = NewNotation + { notaName = q + , notaNames = Set.singleton n + , notaFixity = f + , notation = if null syn then syntaxOf (unqualify q) else syn + , notaIsOperator = null syn + } + where Fixity' f syn _ = A.nameFixity n + +-- | Replace 'noFixity' by 'defaultFixity'. +useDefaultFixity :: NewNotation -> NewNotation +useDefaultFixity n + | notaFixity n == noFixity = n { notaFixity = defaultFixity } + | otherwise = n + +-- | Return the 'IdPart's of a notation, the first part qualified, +-- the other parts unqualified. +-- This allows for qualified use of operators, e.g., +-- @M.for x ∈ xs return e@, or @x ℕ.+ y@. +notationNames :: NewNotation -> [QName] +notationNames (NewNotation q _ _ parts _) = + zipWith ($) (reQualify : repeat QName) [Name noRange InScope [Id $ rangedThing x] | IdPart x <- parts ] + where + -- The qualification of @q@. + modules = init (qnameParts q) + -- Putting the qualification onto @x@. + reQualify x = List.foldr Qual (QName x) modules + +-- | Create a 'Notation' (without binders) from a concrete 'Name'. +-- Does the obvious thing: +-- 'Hole's become 'NormalHole's, 'Id's become 'IdParts'. +-- If 'Name' has no 'Hole's, it returns 'noNotation'. +syntaxOf :: Name -> Notation +syntaxOf (NoName _ _) = noNotation +syntaxOf (Name _ _ [_]) = noNotation +syntaxOf (Name _ _ xs) = mkSyn 0 xs + where + -- Turn a concrete name into a Notation, + -- numbering the holes from left to right. + -- Result will have no 'BindingHole's. + mkSyn :: Int -> [NamePart] -> Notation + mkSyn n [] = [] + mkSyn n (Hole : xs) = NormalHole noRange (defaultNamedArg $ unranged n) : mkSyn (1 + n) xs + mkSyn n (Id x : xs) = IdPart (unranged x) : mkSyn n xs + +-- | Merges 'NewNotation's that have the same precedence level and +-- notation, with two exceptions: +-- +-- * Operators and notations coming from syntax declarations are kept +-- separate. +-- +-- * If /all/ instances of a given 'NewNotation' have the same +-- precedence level or are \"unrelated\", then they are merged. They +-- get the given precedence level, if any, and otherwise they become +-- unrelated (but related to each other). +-- +-- If 'NewNotation's that are merged have distinct associativities, +-- then they get 'NonAssoc' as their associativity. +-- +-- Precondition: No 'A.Name' may occur in more than one list element. +-- Every 'NewNotation' must have the same 'notaName'. +-- +-- Postcondition: No 'A.Name' occurs in more than one list element. +mergeNotations :: [NewNotation] -> [NewNotation] +mergeNotations = + map merge . + concatMap groupIfLevelsMatch . + groupOn (\n -> ( notation n + , notaIsOperator n + )) + where + groupIfLevelsMatch :: [NewNotation] -> [[NewNotation]] + groupIfLevelsMatch [] = __IMPOSSIBLE__ + groupIfLevelsMatch ns@(n : _) = + if allEqual (map fixityLevel related) + then [sameAssoc (sameLevel ns)] + else map (: []) ns + where + -- Fixities of operators whose precedence level is not Unrelated. + related = mapMaybe ((\f -> case fixityLevel f of + Unrelated -> Nothing + Related {} -> Just f) + . notaFixity) ns + + -- Precondition: All related operators have the same precedence + -- level. + -- + -- Gives all unrelated operators the same level. + sameLevel = map (set (_notaFixity . _fixityLevel) level) + where + level = case related of + f : _ -> fixityLevel f + [] -> Unrelated + + -- If all related operators have the same associativity, then the + -- unrelated operators get the same associativity, and otherwise + -- all operators get the associativity NonAssoc. + sameAssoc = map (set (_notaFixity . _fixityAssoc) assoc) + where + assoc = case related of + f : _ | allEqual (map fixityAssoc related) -> fixityAssoc f + _ -> NonAssoc + + merge :: [NewNotation] -> NewNotation + merge [] = __IMPOSSIBLE__ + merge ns@(n : _) = n { notaNames = Set.unions $ map notaNames ns } + +-- | Lens for 'Fixity' in 'NewNotation'. + +_notaFixity :: Lens' Fixity NewNotation +_notaFixity f r = f (notaFixity r) <&> \x -> r { notaFixity = x } + +-- * Sections + +-- | Sections, as well as non-sectioned operators. + +data NotationSection = NotationSection + { sectNotation :: NewNotation + , sectKind :: NotationKind + -- ^ For non-sectioned operators this should match the notation's + -- 'notationKind'. + , sectLevel :: Maybe FixityLevel + -- ^ Effective precedence level. 'Nothing' for closed notations. + , sectIsSection :: Bool + -- ^ 'False' for non-sectioned operators. + } + deriving Show + +-- | Converts a notation to a (non-)section. + +noSection :: NewNotation -> NotationSection +noSection n = NotationSection + { sectNotation = n + , sectKind = notationKind (notation n) + , sectLevel = Just (fixityLevel (notaFixity n)) + , sectIsSection = False + } diff --git a/src/full/Agda/Syntax/Parser.hs b/src/full/Agda/Syntax/Parser.hs --- a/src/full/Agda/Syntax/Parser.hs +++ b/src/full/Agda/Syntax/Parser.hs @@ -1,5 +1,3 @@ -{-# LANGUAGE CPP #-} -{-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} module Agda.Syntax.Parser @@ -28,14 +26,11 @@ import Control.Arrow (second) import Control.Exception -import Control.Monad ((>=>), forM_) +import Control.Monad (forM_) import Control.Monad.State -import Control.Monad.Reader -import Control.Monad.Writer hiding ((<>)) import qualified Data.List as List import Data.Text.Lazy (Text) -import qualified Data.Text.Lazy as T import Agda.Syntax.Common import Agda.Syntax.Position @@ -45,21 +40,16 @@ import Agda.Syntax.Parser.Lexer import Agda.Syntax.Parser.Literate import Agda.Syntax.Concrete -import Agda.Syntax.Concrete.Definitions import Agda.Syntax.Parser.Tokens import Agda.Utils.Except ( ExceptT - , MonadError(catchError, throwError) + , MonadError(throwError) , runExceptT ) import Agda.Utils.FileName import Agda.Utils.IO.UTF8 (readTextFile) import qualified Agda.Utils.Maybe.Strict as Strict -import Agda.Utils.Pretty - -#include "undefined.h" -import Agda.Utils.Impossible ------------------------------------------------------------------------ -- Wrapping parse results diff --git a/src/full/Agda/Syntax/Parser/Alex.hs b/src/full/Agda/Syntax/Parser/Alex.hs --- a/src/full/Agda/Syntax/Parser/Alex.hs +++ b/src/full/Agda/Syntax/Parser/Alex.hs @@ -24,7 +24,6 @@ import Agda.Syntax.Parser.Monad import Agda.Utils.Lens -import Agda.Utils.Monad import Agda.Utils.Tuple -- | This is what the lexer manipulates. diff --git a/src/full/Agda/Syntax/Parser/Comments.hs b/src/full/Agda/Syntax/Parser/Comments.hs --- a/src/full/Agda/Syntax/Parser/Comments.hs +++ b/src/full/Agda/Syntax/Parser/Comments.hs @@ -1,4 +1,3 @@ --- {-# LANGUAGE CPP #-} {-| This module defines the lex action to lex nested comments. As is well-known this cannot be done by regular expressions (which, incidently, is probably @@ -18,8 +17,6 @@ import Agda.Syntax.Parser.Alex import Agda.Syntax.Parser.LookAhead import Agda.Syntax.Position - -import Agda.Utils.Monad -- | Should comment tokens be output? diff --git a/src/full/Agda/Syntax/Parser/Layout.hs b/src/full/Agda/Syntax/Parser/Layout.hs --- a/src/full/Agda/Syntax/Parser/Layout.hs +++ b/src/full/Agda/Syntax/Parser/Layout.hs @@ -1,4 +1,3 @@ --- {-# LANGUAGE CPP #-} {-| This module contains the lex actions that handle the layout rules. The way it works is that the 'Parser' monad keeps track of a stack of diff --git a/src/full/Agda/Syntax/Parser/LexActions.hs b/src/full/Agda/Syntax/Parser/LexActions.hs --- a/src/full/Agda/Syntax/Parser/LexActions.hs +++ b/src/full/Agda/Syntax/Parser/LexActions.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-| This module contains the building blocks used to construct the lexer. -} @@ -14,12 +13,13 @@ , begin_, end_ , lexError -- ** Specialized actions - , keyword, symbol, identifier, literal + , keyword, symbol, identifier, literal, literal', integer -- * Lex predicates , followedBy, eof, inState ) where import Data.Char +import Data.Maybe import Agda.Syntax.Parser.Lexer import Agda.Syntax.Parser.Alex @@ -28,11 +28,9 @@ import Agda.Syntax.Position import Agda.Syntax.Literal -import Agda.Utils.Lens import Agda.Utils.List import Agda.Utils.Tuple -#include "undefined.h" import Agda.Utils.Impossible {-------------------------------------------------------------------------- @@ -75,7 +73,7 @@ AlexToken inp' len action -> fmap postToken $ action inp inp' len AlexError i -> parseError $ concat [ "Lexical error" - , case headMaybe $ lexInput i of + , case listToMaybe $ lexInput i of Just '\t' -> " (you may want to replace tabs with spaces)" Just c | not (isPrint c) -> " (unprintable character)" _ -> "" @@ -96,6 +94,7 @@ postToken (TokId (r, "\x2984")) = TokSymbol SymDoubleCloseBrace r postToken (TokId (r, "\x2987")) = TokSymbol SymOpenIdiomBracket r postToken (TokId (r, "\x2988")) = TokSymbol SymCloseIdiomBracket r +postToken (TokId (r, "\x2987\x2988")) = TokSymbol SymEmptyIdiomBracket r postToken (TokId (r, "\x2200")) = TokKeyword KwForall r postToken (TokId (r, s)) | set == "Set" && all isSub n = TokSetN (r, readSubscript n) @@ -187,7 +186,7 @@ keyword :: Keyword -> LexAction Token keyword k = layout $ withInterval_ (TokKeyword k) where - layout | elem k layoutKeywords = withLayout + layout | k `elem` layoutKeywords = withLayout | otherwise = id @@ -196,10 +195,25 @@ symbol s = withInterval_ (TokSymbol s) +-- | Parse a number. + +number :: String -> Integer +number str = read $ case str of + '0' : 'x' : num -> str + _ -> concat $ wordsBy ('_' ==) str + +integer :: String -> Integer +integer = \case + '-' : str -> - (number str) + str -> number str + -- | Parse a literal. -literal :: Read a => (Range -> a -> Literal) -> LexAction Token -literal lit = +literal' :: (String -> a) -> (Range -> a -> Literal) -> LexAction Token +literal' read lit = withInterval' read (TokLiteral . uncurry lit . mapFst getRange) + +literal :: Read a => (Range -> a -> Literal) -> LexAction Token +literal = literal' read -- | Parse an identifier. Identifiers can be qualified (see 'Name'). -- Example: @Foo.Bar.f@ diff --git a/src/full/Agda/Syntax/Parser/LexActions.hs-boot b/src/full/Agda/Syntax/Parser/LexActions.hs-boot --- a/src/full/Agda/Syntax/Parser/LexActions.hs-boot +++ b/src/full/Agda/Syntax/Parser/LexActions.hs-boot @@ -24,6 +24,8 @@ symbol :: Symbol -> LexAction Token identifier :: LexAction Token literal :: Read a => (Range -> a -> Literal) -> LexAction Token +literal' :: (String -> a) -> (Range -> a -> Literal) -> LexAction Token +integer :: String -> Integer followedBy :: Char -> LexPredicate eof :: LexPredicate diff --git a/src/full/Agda/Syntax/Parser/Lexer.x b/src/full/Agda/Syntax/Parser/Lexer.x --- a/src/full/Agda/Syntax/Parser/Lexer.x +++ b/src/full/Agda/Syntax/Parser/Lexer.x @@ -47,10 +47,11 @@ $white_notab = $white # \t $white_nonl = $white_notab # \n -@number = $digit+ | "0x" $hexdigit+ -@integer = [\-]? @number -@exponent = [eE] [\-\+]? @number -@float = @integer \. @number @exponent? | @number @exponent +@number = $digit+ | "0x" $hexdigit+ +@prettynumber = $digit+ ([_] $digit+)* | "0x" $hexdigit+ +@integer = [\-]? @prettynumber +@exponent = [eE] [\-\+]? @number +@float = @integer \. @number @exponent? | @number @exponent -- A name can't start with \x (to allow \x -> x). -- Bug in alex: [ _ op ]+ doesn't seem to work! @@ -87,6 +88,7 @@ "NO_POSITIVITY_CHECK" { keyword KwNO_POSITIVITY_CHECK } "NO_TERMINATION_CHECK" { keyword KwNO_TERMINATION_CHECK } "NO_UNIVERSE_CHECK" { keyword KwNO_UNIVERSE_CHECK } + "NON_COVERING" { keyword KwNON_COVERING } "NON_TERMINATING" { keyword KwNON_TERMINATING } "OPTIONS" { keyword KwOPTIONS } "POLARITY" { keyword KwPOLARITY } @@ -94,6 +96,7 @@ "STATIC" { keyword KwSTATIC } "TERMINATING" { keyword KwTERMINATING } "WARNING_ON_USAGE" { keyword KwWARNING_ON_USAGE } + "WARNING_ON_IMPORT" { keyword KwWARNING_ON_IMPORT } . # [ $white \" ] + { withInterval $ TokString } -- we recognise string literals in pragmas . # [ $white ] + { withInterval $ TokString } @@ -170,8 +173,6 @@ <0,code> forall { keyword KwForall } <0,code> Set @number { withInterval' (read . drop 3) TokSetN } <0,code> Prop @number { withInterval' (read . drop 4) TokPropN } -<0,code> quoteGoal { keyword KwQuoteGoal } -<0,code> quoteContext { keyword KwQuoteContext } <0,code> quote { keyword KwQuote } <0,code> quoteTerm { keyword KwQuoteTerm } <0,code> unquote { keyword KwUnquote } @@ -206,12 +207,16 @@ <0,code> "|" { symbol SymBar } <0,code> "(|" /[$white] { symbol SymOpenIdiomBracket } <0,code> "|)" { symbol SymCloseIdiomBracket } +<0,code> "(|)" { symbol SymEmptyIdiomBracket } <0,code> "(" { symbol SymOpenParen } <0,code> ")" { symbol SymCloseParen } <0,code> "->" { symbol SymArrow } <0,code> "\" { symbol SymLambda } -- " <0,code> "@" { symbol SymAs } -<0,code> "{{" /[^!] { symbol SymDoubleOpenBrace } +<0,code> "{{" /[^[!\-]] { symbol SymDoubleOpenBrace } +-- Andreas, 2019-08-08, issue #3962, don't lex '{{' if followed by '-' +-- since this will be confused with '{-' (start of comment) by Emacs. + -- We don't lex '}}' into a SymDoubleCloseBrace. Instead, we lex it as -- two SymCloseBrace's. When the parser is looking for a double -- closing brace, it will also accept two SymCloseBrace's, after @@ -219,13 +224,14 @@ -- This trick allows us to keep "record { a = record {}}" working -- properly. -- <0,code> "}}" { symbol SymDoubleCloseBrace } + <0,code> "{" { symbol SymOpenBrace } -- you can't use braces for layout <0,code> "}" { symbol SymCloseBrace } -- Literals <0,code> \' { litChar } <0,code,pragma_> \" { litString } -<0,code> @integer { literal LitNat } +<0,code> @integer { literal' integer LitNat } <0,code> @float { literal LitFloat } -- Identifiers diff --git a/src/full/Agda/Syntax/Parser/Literate.hs b/src/full/Agda/Syntax/Parser/Literate.hs --- a/src/full/Agda/Syntax/Parser/Literate.hs +++ b/src/full/Agda/Syntax/Parser/Literate.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE ViewPatterns #-} -- | Preprocessors for literate code formats. @@ -23,13 +22,12 @@ where import Prelude hiding (getLine) -import Data.Char (isSpace, isControl) +import Data.Char (isSpace) import Data.List (isPrefixOf) import Agda.Syntax.Common import Agda.Syntax.Position import Text.Regex.TDFA -#include "undefined.h" import Agda.Utils.Impossible -- | Role of a character in the file. diff --git a/src/full/Agda/Syntax/Parser/LookAhead.hs b/src/full/Agda/Syntax/Parser/LookAhead.hs --- a/src/full/Agda/Syntax/Parser/LookAhead.hs +++ b/src/full/Agda/Syntax/Parser/LookAhead.hs @@ -33,7 +33,7 @@ 'AlexInput', wrapped around the 'Parser' monad. -} newtype LookAhead a = - LookAhead { unLookAhead :: ReaderT ErrorFunction + LookAhead { _unLookAhead :: ReaderT ErrorFunction (StateT AlexInput Parser) a } deriving (Functor, Applicative, Monad) diff --git a/src/full/Agda/Syntax/Parser/Monad.hs b/src/full/Agda/Syntax/Parser/Monad.hs --- a/src/full/Agda/Syntax/Parser/Monad.hs +++ b/src/full/Agda/Syntax/Parser/Monad.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} @@ -32,32 +31,24 @@ ) where -#if MIN_VERSION_base(4,11,0) -import Prelude hiding ((<>)) -#endif - -import Control.Exception (catch, displayException) +import Control.Exception (displayException) import Data.Int import Data.Data (Data) -import qualified Data.Text.Lazy as T import Control.Monad.State -import Control.Monad.Except import Agda.Interaction.Options.Warnings import Agda.Syntax.Position -import Agda.Utils.Except ( MonadError(catchError, throwError) ) +import Agda.Utils.Except ( MonadError(throwError) ) import Agda.Utils.FileName import Agda.Utils.List ( tailWithDefault ) -import qualified Agda.Utils.IO.UTF8 as UTF8 import qualified Agda.Utils.Maybe.Strict as Strict import Agda.Utils.Pretty -#include "undefined.h" import Agda.Utils.Impossible {-------------------------------------------------------------------------- @@ -65,7 +56,7 @@ --------------------------------------------------------------------------} -- | The parse monad. -newtype Parser a = P { runP :: StateT ParseState (Either ParseError) a } +newtype Parser a = P { _runP :: StateT ParseState (Either ParseError) a } deriving (Functor, Applicative, Monad, MonadState ParseState, MonadError ParseError) -- | The parser state. Contains everything the parser and the lexer could ever @@ -184,17 +175,17 @@ instance Pretty ParseError where pretty ParseError{errPos,errSrcFile,errMsg,errPrevToken,errInput} = vcat - [ pretty (errPos { srcFile = errSrcFile }) <> colon <+> + [ (pretty (errPos { srcFile = errSrcFile }) <> colon) <+> text errMsg , text $ errPrevToken ++ "" , text $ take 30 errInput ++ "..." ] pretty OverlappingTokensError{errRange} = vcat - [ pretty errRange <> colon <+> + [ (pretty errRange <> colon) <+> "Multi-line comment spans one or more literate text blocks." ] pretty InvalidExtensionError{errPath,errValidExts} = vcat - [ pretty errPath <> colon <+> + [ (pretty errPath <> colon) <+> "Unsupported extension." , "Supported extensions are:" <+> prettyList_ errValidExts ] @@ -218,7 +209,7 @@ instance Pretty ParseWarning where pretty OverlappingTokensWarning{warnRange} = vcat - [ pretty warnRange <> colon <+> + [ (pretty warnRange <> colon) <+> "Multi-line comment spans one or more literate text blocks." ] instance HasRange ParseWarning where @@ -297,8 +288,9 @@ getLexState :: Parser [LexState] getLexState = parseLexState <$> get -setLexState :: [LexState] -> Parser () -setLexState ls = modify $ \ s -> s { parseLexState = ls } +-- UNUSED Liang-Ting Chen 2019-07-16 +--setLexState :: [LexState] -> Parser () +--setLexState ls = modify $ \ s -> s { parseLexState = ls } modifyLexState :: ([LexState] -> [LexState]) -> Parser () modifyLexState f = modify $ \ s -> s { parseLexState = f (parseLexState s) } diff --git a/src/full/Agda/Syntax/Parser/Parser.y b/src/full/Agda/Syntax/Parser/Parser.y --- a/src/full/Agda/Syntax/Parser/Parser.y +++ b/src/full/Agda/Syntax/Parser/Parser.y @@ -1,5 +1,4 @@ { -{-# LANGUAGE CPP #-} {-# LANGUAGE PatternGuards #-} {-| The parser is generated by Happy (). @@ -25,10 +24,11 @@ , splitOnDots -- only used by the internal test-suite ) where +import Control.Applicative ( (<|>) ) import Control.Monad +import Data.Bifunctor (first) import Data.Char -import Data.Functor import Data.List import Data.Maybe import Data.Monoid @@ -43,7 +43,6 @@ import Agda.Syntax.Concrete as C import Agda.Syntax.Concrete.Attribute import Agda.Syntax.Concrete.Pattern -import Agda.Syntax.Concrete.Pretty () import Agda.Syntax.Common import Agda.Syntax.Fixity import Agda.Syntax.Notation @@ -57,12 +56,9 @@ import Agda.Utils.List ( spanJust, chopWhen ) import Agda.Utils.Monad import Agda.Utils.Pretty -import Agda.Utils.Singleton -import Agda.Utils.Tuple import qualified Agda.Utils.Maybe.Strict as Strict import Agda.Utils.Impossible -#include "undefined.h" } @@ -132,8 +128,6 @@ 'Prop' { TokKeyword KwProp $$ } 'public' { TokKeyword KwPublic $$ } 'quote' { TokKeyword KwQuote $$ } - 'quoteContext' { TokKeyword KwQuoteContext $$ } - 'quoteGoal' { TokKeyword KwQuoteGoal $$ } 'quoteTerm' { TokKeyword KwQuoteTerm $$ } 'record' { TokKeyword KwRecord $$ } 'renaming' { TokKeyword KwRenaming $$ } @@ -165,9 +159,11 @@ 'NO_POSITIVITY_CHECK' { TokKeyword KwNO_POSITIVITY_CHECK $$ } 'NO_UNIVERSE_CHECK' { TokKeyword KwNO_UNIVERSE_CHECK $$ } 'NON_TERMINATING' { TokKeyword KwNON_TERMINATING $$ } + 'NON_COVERING' { TokKeyword KwNON_COVERING $$ } 'OPTIONS' { TokKeyword KwOPTIONS $$ } 'POLARITY' { TokKeyword KwPOLARITY $$ } 'WARNING_ON_USAGE' { TokKeyword KwWARNING_ON_USAGE $$ } + 'WARNING_ON_IMPORT' { TokKeyword KwWARNING_ON_IMPORT $$ } 'REWRITE' { TokKeyword KwREWRITE $$ } 'STATIC' { TokKeyword KwSTATIC $$ } 'TERMINATING' { TokKeyword KwTERMINATING $$ } @@ -193,6 +189,7 @@ ')' { TokSymbol SymCloseParen $$ } '(|' { TokSymbol SymOpenIdiomBracket $$ } '|)' { TokSymbol SymCloseIdiomBracket $$ } + '(|)' { TokSymbol SymEmptyIdiomBracket $$ } '{{' { TokSymbol SymDoubleOpenBrace $$ } '}}' { TokSymbol SymDoubleCloseBrace $$ } '{' { TokSymbol SymOpenBrace $$ } @@ -229,15 +226,16 @@ -- Parse single token. Token :: { Token } Token + -- Please keep these keywords in alphabetical order! : 'abstract' { TokKeyword KwAbstract $1 } | 'codata' { TokKeyword KwCoData $1 } | 'coinductive' { TokKeyword KwCoInductive $1 } | 'constructor' { TokKeyword KwConstructor $1 } | 'data' { TokKeyword KwData $1 } + | 'do' { TokKeyword KwDo $1 } | 'eta-equality' { TokKeyword KwEta $1 } | 'field' { TokKeyword KwField $1 } | 'forall' { TokKeyword KwForall $1 } - | 'variable' { TokKeyword KwVariable $1 } | 'hiding' { TokKeyword KwHiding $1 } | 'import' { TokKeyword KwImport $1 } | 'in' { TokKeyword KwIn $1 } @@ -246,13 +244,13 @@ | 'infixl' { TokKeyword KwInfixL $1 } | 'infixr' { TokKeyword KwInfixR $1 } | 'instance' { TokKeyword KwInstance $1 } - | 'overlap' { TokKeyword KwOverlap $1 } | 'let' { TokKeyword KwLet $1 } | 'macro' { TokKeyword KwMacro $1 } | 'module' { TokKeyword KwModule $1 } | 'mutual' { TokKeyword KwMutual $1 } | 'no-eta-equality' { TokKeyword KwNoEta $1 } | 'open' { TokKeyword KwOpen $1 } + | 'overlap' { TokKeyword KwOverlap $1 } | 'pattern' { TokKeyword KwPatternSyn $1 } | 'postulate' { TokKeyword KwPostulate $1 } | 'primitive' { TokKeyword KwPrimitive $1 } @@ -260,8 +258,6 @@ | 'Prop' { TokKeyword KwProp $1 } | 'public' { TokKeyword KwPublic $1 } | 'quote' { TokKeyword KwQuote $1 } - | 'quoteContext' { TokKeyword KwQuoteContext $1 } - | 'quoteGoal' { TokKeyword KwQuoteGoal $1 } | 'quoteTerm' { TokKeyword KwQuoteTerm $1 } | 'record' { TokKeyword KwRecord $1 } | 'renaming' { TokKeyword KwRenaming $1 } @@ -274,30 +270,33 @@ | 'unquoteDecl' { TokKeyword KwUnquoteDecl $1 } | 'unquoteDef' { TokKeyword KwUnquoteDef $1 } | 'using' { TokKeyword KwUsing $1 } + | 'variable' { TokKeyword KwVariable $1 } | 'where' { TokKeyword KwWhere $1 } - | 'do' { TokKeyword KwDo $1 } | 'with' { TokKeyword KwWith $1 } + -- Please keep these pragmas in alphabetical order! | 'BUILTIN' { TokKeyword KwBUILTIN $1 } | 'CATCHALL' { TokKeyword KwCATCHALL $1 } + | 'COMPILE' { TokKeyword KwCOMPILE $1 } | 'DISPLAY' { TokKeyword KwDISPLAY $1 } | 'ETA' { TokKeyword KwETA $1 } | 'FOREIGN' { TokKeyword KwFOREIGN $1 } - | 'COMPILE' { TokKeyword KwCOMPILE $1 } | 'IMPOSSIBLE' { TokKeyword KwIMPOSSIBLE $1 } | 'INJECTIVE' { TokKeyword KwINJECTIVE $1 } | 'INLINE' { TokKeyword KwINLINE $1 } - | 'NOINLINE' { TokKeyword KwNOINLINE $1 } | 'MEASURE' { TokKeyword KwMEASURE $1 } - | 'NO_TERMINATION_CHECK' { TokKeyword KwNO_TERMINATION_CHECK $1 } + | 'NOINLINE' { TokKeyword KwNOINLINE $1 } | 'NO_POSITIVITY_CHECK' { TokKeyword KwNO_POSITIVITY_CHECK $1 } + | 'NO_TERMINATION_CHECK' { TokKeyword KwNO_TERMINATION_CHECK $1 } | 'NO_UNIVERSE_CHECK' { TokKeyword KwNO_UNIVERSE_CHECK $1 } | 'NON_TERMINATING' { TokKeyword KwNON_TERMINATING $1 } + | 'NON_COVERING' { TokKeyword KwNON_COVERING $1 } | 'OPTIONS' { TokKeyword KwOPTIONS $1 } | 'POLARITY' { TokKeyword KwPOLARITY $1 } | 'REWRITE' { TokKeyword KwREWRITE $1 } | 'STATIC' { TokKeyword KwSTATIC $1 } | 'TERMINATING' { TokKeyword KwTERMINATING $1 } + | 'WARNING_ON_IMPORT' { TokKeyword KwWARNING_ON_IMPORT $1 } | 'WARNING_ON_USAGE' { TokKeyword KwWARNING_ON_USAGE $1 } | setN { TokSetN $1 } @@ -321,6 +320,7 @@ | ')' { TokSymbol SymCloseParen $1 } | '(|' { TokSymbol SymOpenIdiomBracket $1 } | '|)' { TokSymbol SymCloseIdiomBracket $1 } + | '(|)' { TokSymbol SymEmptyIdiomBracket $1 } | '{{' { TokSymbol SymDoubleOpenBrace $1 } | '}}' { TokSymbol SymDoubleCloseBrace $1 } | '{' { TokSymbol SymOpenBrace $1 } @@ -386,11 +386,12 @@ Helper rules --------------------------------------------------------------------------} --- An integer. Used in fixity declarations. -Int :: { Integer } -Int : literal {% case $1 of { - LitNat _ i -> return i; - _ -> parseError $ "Expected integer" +-- A float. Used in fixity declarations. +Float :: { Ranged Double } +Float : literal {% case $1 of + { LitNat r i -> return $ Ranged r $ fromInteger i + ; LitFloat r i -> return $ Ranged r i + ; _ -> parseError $ "Expected floating point number" } } @@ -460,8 +461,8 @@ -- Modalities preceeding identifiers -ModalArgIds :: { [Arg Name] } -ModalArgIds : Attributes ArgIds {% mapM (applyAttrs $1) $2 } +ModalArgIds :: { ([Attr], [Arg Name]) } +ModalArgIds : Attributes ArgIds {% ($1,) `fmap` mapM (applyAttrs $1) $2 } -- Attributes are parsed as '@' followed by an atomic expression. @@ -531,49 +532,33 @@ -- at point (x y it is not clear whether x y is an application or -- a variable list. We could be parsing (x y z) -> B -- with ((x y) z) being a type. -CommaBIds :: { [NamedArg BoundName] } +CommaBIds :: { [NamedArg Binder] } CommaBIds : CommaBIdAndAbsurds {% case $1 of Left ns -> return ns Right _ -> parseError $ "expected sequence of bound identifiers, not absurd pattern" } -CommaBIdAndAbsurds :: { Either [NamedArg BoundName] [Expr] } +CommaBIdAndAbsurds :: { Either [NamedArg Binder] [Expr] } CommaBIdAndAbsurds : Application {% boundNamesOrAbsurd $1 } - | QId '=' QId {% fmap (Left . (:[])) $ mkNamedArg (Just $1) (Left $3) } - | '_' '=' QId {% fmap (Left . (:[])) $ mkNamedArg Nothing (Left $3) } - | QId '=' '_' {% fmap (Left . (:[])) $ mkNamedArg (Just $1) (Right $ getRange $3) } - | '_' '=' '_' {% fmap (Left . (:[])) $ mkNamedArg Nothing (Right $ getRange $3) } + | QId '=' QId {% (Left . pure . updateNamedArg mkBinder) `fmap` mkNamedArg (Just $1) (Left $3) } + | '_' '=' QId {% (Left . pure . updateNamedArg mkBinder) `fmap` mkNamedArg Nothing (Left $3) } + | QId '=' '_' {% (Left . pure . updateNamedArg mkBinder) `fmap` mkNamedArg (Just $1) (Right $ getRange $3) } + | '_' '=' '_' {% (Left . pure . updateNamedArg mkBinder) `fmap` mkNamedArg Nothing (Right $ getRange $3) } -- Parse a sequence of identifiers, including hiding info. -- Does not include instance arguments. -- E.g. x {y z} _ {v} -- To be used in typed bindings, like (x {y z} _ {v} : Nat). -BIdsWithHiding :: { [NamedArg BoundName] } +BIdsWithHiding :: { [NamedArg Binder] } BIdsWithHiding : Application {% - let -- interpret an expression as name - getName :: Expr -> Maybe Name - getName (Ident (QName x)) = Just x - getName (Underscore r _) = Just (Name r InScope [Hole]) - getName _ = Nothing - - getNames :: Expr -> Maybe [Name] - getNames (RawApp _ es) = mapM getName es - getNames e = singleton `fmap` getName e - - -- interpret an expression as name or list of hidden names - getName1 :: Expr -> Maybe [Arg Name] - getName1 (Ident (QName x)) = Just [defaultArg x] - getName1 (Underscore r _) = Just [defaultArg $ Name r InScope [Hole]] - getName1 (HiddenArg _ (Named Nothing e)) - = map (setHiding Hidden . defaultArg) `fmap` getNames e - getName1 _ = Nothing - - in - case mapM getName1 $1 of - Just good -> return $ (map . fmap) (unnamed . mkBoundName_) $ concat good - Nothing -> parseError $ "expected sequence of possibly hidden bound identifiers" + -- interpret an expression as a name and maybe a pattern + case mapM exprAsNameOrHiddenNames $1 of + Nothing -> parseError "Expected sequence of possibly hidden bound identifiers" + Just good -> forM (concat good) $ updateNamedArgA $ \ (n, me) -> do + p <- traverse exprToPattern me + pure $ Binder p (mkBoundName_ n) } @@ -582,11 +567,11 @@ PragmaStrings : {- empty -} { [] } | string PragmaStrings { snd $1 : $2 } - +{- Unused PragmaString :: { String } PragmaString : string { snd $1 } - +-} Strings :: { [(Interval, String)] } Strings : {- empty -} { [] } | string Strings { $1 : $2 } @@ -632,9 +617,9 @@ Expr : TeleArrow Expr { Pi $1 $2 } | Application3 '->' Expr { Fun (getRange ($1,$2,$3)) - (defaultArg $ RawApp (getRange $1) $1) + (defaultArg $ rawAppUnlessSingleton (getRange $1) $1) $3 } - | Attributes1 Application3 '->' Expr {% applyAttrs $1 (defaultArg $ RawApp (getRange ($1,$2)) $2) <&> \ dom -> + | Attributes1 Application3 '->' Expr {% applyAttrs $1 (defaultArg $ rawAppUnlessSingleton (getRange ($1,$2)) $2) <&> \ dom -> Fun (getRange ($1,$2,$3,$4)) dom $4 } | Expr1 '=' Expr { Equal (getRange ($1, $2, $3)) $1 $3 } | Expr1 %prec LOWEST { $1 } @@ -667,9 +652,7 @@ | 'let' Declarations LetBody { Let (getRange ($1,$2,$3)) $2 $3 } | 'do' vopen DoStmts close { DoBlock (getRange ($1, $3)) $3 } | Expr3 { $1 } - | 'quoteGoal' Id 'in' Expr { QuoteGoal (getRange ($1,$2,$3,$4)) $2 $4 } - | 'tactic' Application3 { Tactic (getRange ($1, $2)) (RawApp (getRange $2) $2) [] } - | 'tactic' Application3 '|' WithExprs { Tactic (getRange ($1, $2, $3, $4)) (RawApp (getRange $2) $2) $4 } + | 'tactic' Application3 { Tactic (getRange ($1, $2)) (RawApp (getRange $2) $2) } LetBody :: { Maybe Expr } LetBody : 'in' Expr { Just $2 } @@ -706,7 +689,7 @@ -- Level 3: Atoms Expr3Curly :: { Expr } Expr3Curly - : '{' Expr '}' { HiddenArg (getRange ($1,$2,$3)) (maybeNamed $2) } + : '{' Expr '}' {% HiddenArg (getRange ($1,$2,$3)) `fmap` maybeNamed $2 } | '{' '}' { let r = fuseRange $1 $2 in HiddenArg r $ unnamed $ Absurd r } Expr3NoCurly :: { Expr } @@ -717,16 +700,17 @@ | 'Set' { Set (getRange $1) } | 'quote' { Quote (getRange $1) } | 'quoteTerm' { QuoteTerm (getRange $1) } - | 'quoteContext' { QuoteContext (getRange $1) } | 'unquote' { Unquote (getRange $1) } | setN { SetN (getRange (fst $1)) (snd $1) } | propN { PropN (getRange (fst $1)) (snd $1) } - | '{{' Expr DoubleCloseBrace { InstanceArg (getRange ($1,$2,$3)) (maybeNamed $2) } - | '(|' Expr '|)' { IdiomBrackets (getRange ($1,$2,$3)) $2 } + | '{{' Expr DoubleCloseBrace {% InstanceArg (getRange ($1,$2,$3)) `fmap` maybeNamed $2 } + | '(|' WithExprs '|)' { IdiomBrackets (getRange ($1,$2,$3)) $2 } + | '(|)' { IdiomBrackets (getRange $1) [] } | '(' ')' { Absurd (fuseRange $1 $2) } | '{{' DoubleCloseBrace { let r = fuseRange $1 $2 in InstanceArg r $ unnamed $ Absurd r } | Id '@' Expr3 { As (getRange ($1,$2,$3)) $1 $3 } | '.' Expr3 { Dot (fuseRange $1 $2) $2 } + | '..' Expr3 { DoubleDot (fuseRange $1 $2) $2 } | 'record' '{' RecordAssignments '}' { Rec (getRange ($1,$2,$3,$4)) $3 } | 'record' Expr3NoCurly '{' FieldAssignments '}' { RecUpdate (getRange ($1,$2,$3,$4,$5)) $2 $4 } | '...' { Ellipsis (getRange $1) } @@ -843,7 +827,7 @@ ModalTBind :: { TypedBinding } ModalTBind : Attributes1 CommaBIds ':' Expr {% do let r = getRange ($1,$2,$3,$4) -- the range is approximate only for TypedBindings - xs <- mapM (applyAttrs $1) $2 + xs <- mapM (applyAttrs $1 . setTacticAttr $1) $2 return $ TBind r xs $4 } @@ -857,7 +841,7 @@ ModalTBindWithHiding :: { TypedBinding } ModalTBindWithHiding : Attributes1 BIdsWithHiding ':' Expr {% do let r = getRange ($1,$2,$3,$4) -- the range is approximate only for TypedBindings - xs <- mapM (applyAttrs $1) $2 + xs <- mapM (applyAttrs $1 . setTacticAttr $1) $2 return $ TBind r xs $4 } @@ -992,29 +976,34 @@ Right _ -> parseError "expected sequence of bound identifiers, not absurd pattern" } +MaybeAsPattern :: { Maybe Pattern } +MaybeAsPattern + : '@' Expr3 {% fmap Just (exprToPattern $2) } + | {- empty -} { Nothing } + -- A domain free binding is either x or {x1 .. xn} DomainFreeBindingAbsurd :: { Either [LamBinding] [Expr]} DomainFreeBindingAbsurd - : BId { Left [DomainFree $ defaultNamedArg $ mkBoundName_ $1] } - | '.' BId { Left [DomainFree $ setRelevance Irrelevant $ defaultNamedArg $ mkBoundName_ $2] } - | '..' BId { Left [DomainFree $ setRelevance NonStrict $ defaultNamedArg $ mkBoundName_ $2] } - | '(' CommaBIdAndAbsurds ')' - { mapLeft (map DomainFree) $2 } + : BId MaybeAsPattern { Left [mkDomainFree_ id $2 $1] } + | '.' BId MaybeAsPattern { Left [mkDomainFree_ (setRelevance Irrelevant) $3 $2] } + | '..' BId MaybeAsPattern { Left [mkDomainFree_ (setRelevance NonStrict) $3 $2] } + | '(' Application ')' {% exprToPattern (RawApp (getRange $2) $2) >>= \ p -> + pure $ Left [mkDomainFree_ id (Just p) (Name noRange InScope [Hole])] } | '(' Attributes1 CommaBIdAndAbsurds ')' {% applyAttrs $2 defaultArgInfo <&> \ ai -> - mapLeft (map (DomainFree . setArgInfo ai)) $3 } + mapLeft (map (DomainFree . setTacticAttr $2 . setArgInfo ai)) $3 } | '{' CommaBIdAndAbsurds '}' - { mapLeft (map (DomainFree . setHiding Hidden)) $2 } + { mapLeft (map (DomainFree . hide)) $2 } | '{' Attributes1 CommaBIdAndAbsurds '}' {% applyAttrs $2 defaultArgInfo <&> \ ai -> - mapLeft (map (DomainFree . setHiding Hidden . setArgInfo ai)) $3 } + mapLeft (map (DomainFree . hide . setTacticAttr $2 . setArgInfo ai)) $3 } | '{{' CommaBIds DoubleCloseBrace { Left $ map (DomainFree . makeInstance) $2 } | '{{' Attributes1 CommaBIds DoubleCloseBrace {% applyAttrs $2 defaultArgInfo <&> \ ai -> - Left $ map (DomainFree . makeInstance . setArgInfo ai) $3 } - | '.' '{' CommaBIds '}' { Left $ map (DomainFree . setHiding Hidden . setRelevance Irrelevant) $3 } + Left $ map (DomainFree . makeInstance . setTacticAttr $2 . setArgInfo ai) $3 } + | '.' '{' CommaBIds '}' { Left $ map (DomainFree . hide . setRelevance Irrelevant) $3 } | '.' '{{' CommaBIds DoubleCloseBrace { Left $ map (DomainFree . makeInstance . setRelevance Irrelevant) $3 } - | '..' '{' CommaBIds '}' { Left $ map (DomainFree . setHiding Hidden . setRelevance NonStrict) $3 } + | '..' '{' CommaBIds '}' { Left $ map (DomainFree . hide . setRelevance NonStrict) $3 } | '..' '{{' CommaBIds DoubleCloseBrace { Left $ map (DomainFree . makeInstance . setRelevance NonStrict) $3 } @@ -1049,7 +1038,7 @@ | {- empty -} { [] } ImportDirective1 :: { ImportDirective } - : 'public' { defaultImportDir { importDirRange = getRange $1, publicOpen = True } } + : 'public' { defaultImportDir { importDirRange = getRange $1, publicOpen = Just (getRange $1) } } | Using { defaultImportDir { importDirRange = snd $1, using = fst $1 } } | Hiding { defaultImportDir { importDirRange = snd $1, hiding = fst $1 } } | RenamingDir { defaultImportDir { importDirRange = snd $1, impRenaming = fst $1 } } @@ -1077,8 +1066,15 @@ Renaming :: { Renaming } Renaming - : ImportName_ 'to' Id { Renaming $1 (setImportedName $1 $3) (getRange $2) } + : ImportName_ 'to' RenamingTarget { Renaming $1 (setImportedName $1 (snd $3)) (fst $3) (getRange $2) } +RenamingTarget :: { (Maybe Fixity, Name) } +RenamingTarget + : Id { (Nothing, $1) } + | 'infix' Float Id { (Just (Fixity (getRange ($1,$2)) (Related $ rangedThing $2) NonAssoc) , $3) } + | 'infixl' Float Id { (Just (Fixity (getRange ($1,$2)) (Related $ rangedThing $2) LeftAssoc) , $3) } + | 'infixr' Float Id { (Just (Fixity (getRange ($1,$2)) (Related $ rangedThing $2) RightAssoc), $3) } + -- We need a special imported name here, since we have to trigger -- the imp_dir state exactly one token before the 'to' ImportName_ :: { ImportedName } @@ -1108,26 +1104,29 @@ -- A left hand side of a function clause. We parse it as an expression, and -- then check that it is a valid left hand side. LHS :: { LHS } -LHS : Expr1 RewriteEquations WithExpressions - {% exprToLHS $1 >>= \p -> return (p $2 $3) } - -WithExpressions :: { [Expr] } -WithExpressions - : {- empty -} { [] } - | 'with' Expr - { case $2 of { WithApp _ e es -> e : es; e -> [e] } } +LHS : Expr1 WithRewriteExpressions + {% exprToLHS $1 >>= \p -> + buildWithBlock $2 >>= \ (rs, es) -> + return (p rs $ map observeHiding es) + } -RewriteEquations :: { [Expr] } -RewriteEquations +WithRewriteExpressions :: { [Either RewriteEqn [Expr]] } +WithRewriteExpressions : {- empty -} { [] } - | 'rewrite' Expr1 - { case $2 of { WithApp _ e es -> e : es; e -> [e] } } + | 'with' Expr1 WithRewriteExpressions + {% fmap (++ $3) (buildWithStmt $2) } + | 'rewrite' Expr1 WithRewriteExpressions + { Left (Rewrite $ fmap ((),) (fromWithApp $2)) : $3 } --- Parsing either an expression @e@ or a @rewrite e1 | ... | en@. +-- Parsing either an expression @e@ or a @(rewrite | with p <-) e1 | ... | en@. HoleContent :: { HoleContent } HoleContent - : Expr { HoleContentExpr $1 } - | RewriteEquations { HoleContentRewrite $1 } + : Expr { HoleContentExpr $1 } + | WithRewriteExpressions + {% fmap HoleContentRewrite $ forM $1 $ \case + Left r -> pure r + Right{} -> parseError "Cannot declare a 'with' abstraction from inside a hole." + } -- Where clauses are optional. WhereClause :: { WhereClause } @@ -1147,7 +1146,7 @@ -- Top-level definitions. Declaration :: { [Declaration] } Declaration - : Fields { $1 } + : Fields { [$1] } | FunClause { $1 } -- includes type signatures | Data { [$1] } | DataSig { [$1] } -- lone data type signature in mutual block @@ -1179,24 +1178,26 @@ -- Type signatures of the form "n1 n2 n3 ... : Type", with at least -- one bound name. TypeSigs :: { [Declaration] } -TypeSigs : SpaceIds ':' Expr { map (\ x -> typeSig defaultArgInfo x $3) $1 } +TypeSigs : SpaceIds ':' Expr { map (\ x -> typeSig defaultArgInfo Nothing x $3) $1 } -- A variant of TypeSigs where any sub-sequence of names can be marked -- as hidden or irrelevant using braces and dots: -- {n1 .n2} n3 .n4 {n5} .{n6 n7} ... : Type. ArgTypeSigs :: { [Arg Declaration] } ArgTypeSigs - : ModalArgIds ':' Expr { map (fmap (\ x -> typeSig defaultArgInfo x $3)) $1 } + : ModalArgIds ':' Expr { let (attrs, xs) = $1 in + map (fmap (\ x -> typeSig defaultArgInfo (getTacticAttr attrs) x $3)) xs } | 'overlap' ModalArgIds ':' Expr {% - let setOverlap x = + let (attrs, xs) = $2 + setOverlap x = case getHiding x of Instance _ -> return $ makeInstance' YesOverlap x _ -> parseErrorRange $1 "The 'overlap' keyword only applies to instance fields (fields marked with {{ }})" - in T.traverse (setOverlap . fmap (\ x -> typeSig defaultArgInfo x $4)) $2 } + in T.traverse (setOverlap . fmap (\ x -> typeSig defaultArgInfo (getTacticAttr attrs) x $4)) xs } | 'instance' ArgTypeSignatures { let - setInstance (TypeSig info x t) = TypeSig (makeInstance info) x t + setInstance (TypeSig info tac x t) = TypeSig (makeInstance info) tac x t setInstance _ = __IMPOSSIBLE__ in map (fmap setInstance) $2 } @@ -1215,20 +1216,16 @@ -- Data declaration. Can be local. Data :: { Declaration } Data : 'data' Id TypedUntypedBindings ':' Expr 'where' - Declarations0 { Data (getRange ($1,$2,$3,$4,$5,$6,$7)) Inductive $2 $3 $5 $7 } - | 'codata' Id TypedUntypedBindings ':' Expr 'where' - Declarations0 { Data (getRange ($1,$2,$3,$4,$5,$6,$7)) CoInductive $2 $3 $5 $7 } + Declarations0 { Data (getRange ($1,$2,$3,$4,$5,$6,$7)) $2 $3 $5 $7 } -- New cases when we already had a DataSig. Then one can omit the sort. | 'data' Id TypedUntypedBindings 'where' - Declarations0 { DataDef (getRange ($1,$2,$3,$4,$5)) Inductive $2 $3 $5 } - | 'codata' Id TypedUntypedBindings 'where' - Declarations0 { DataDef (getRange ($1,$2,$3,$4,$5)) CoInductive $2 $3 $5 } + Declarations0 { DataDef (getRange ($1,$2,$3,$4,$5)) $2 $3 $5 } -- Data type signature. Found in mutual blocks. DataSig :: { Declaration } DataSig : 'data' Id TypedUntypedBindings ':' Expr - { DataSig (getRange ($1,$2,$3,$4,$5)) Inductive $2 $3 $5 } + { DataSig (getRange ($1,$2,$3,$4,$5)) $2 $3 $5 } -- Andreas, 2012-03-16: The Expr3NoCurly instead of Id in everything -- following 'record' is to remove the (harmless) shift/reduce conflict @@ -1250,37 +1247,37 @@ -- Declaration of record constructor name. RecordConstructorName :: { (Name, IsInstance) } -RecordConstructorName : 'constructor' Id { ($2, NotInstanceDef) } - | 'instance' vopen 'constructor' Id vclose { ($4, InstanceDef) } +RecordConstructorName : 'constructor' Id { ($2, NotInstanceDef) } + | 'instance' vopen 'constructor' Id close { ($4, InstanceDef (getRange $1)) } -- Fixity declarations. Infix :: { Declaration } -Infix : 'infix' Int SpaceBIds { Infix (Fixity (getRange ($1,$3)) (Related $2) NonAssoc) $3 } - | 'infixl' Int SpaceBIds { Infix (Fixity (getRange ($1,$3)) (Related $2) LeftAssoc) $3 } - | 'infixr' Int SpaceBIds { Infix (Fixity (getRange ($1,$3)) (Related $2) RightAssoc) $3 } +Infix : 'infix' Float SpaceBIds { Infix (Fixity (getRange ($1,$2,$3)) (Related $ rangedThing $2) NonAssoc) $3 } + | 'infixl' Float SpaceBIds { Infix (Fixity (getRange ($1,$2,$3)) (Related $ rangedThing $2) LeftAssoc) $3 } + | 'infixr' Float SpaceBIds { Infix (Fixity (getRange ($1,$2,$3)) (Related $ rangedThing $2) RightAssoc) $3 } -- Field declarations. -Fields :: { [Declaration] } -Fields : 'field' ArgTypeSignatures +Fields :: { Declaration } +Fields : 'field' ArgTypeSignaturesOrEmpty { let inst i = case getHiding i of - Instance _ -> InstanceDef + Instance _ -> InstanceDef noRange -- no @instance@ keyword here _ -> NotInstanceDef - toField (Arg info (TypeSig info' x t)) = Field (inst info') x (Arg info t) - in map toField $2 } + toField (Arg info (TypeSig info' tac x t)) = FieldSig (inst info') tac x (Arg info t) + in Field (fuseRange $1 $2) $ map toField $2 } -- | 'field' ModalArgTypeSignatures -- { let -- inst i = case getHiding i of -- Instance _ -> InstanceDef -- _ -> NotInstanceDef - -- toField (Arg info (TypeSig info' x t)) = Field (inst info') x (Arg info t) - -- in map toField $2 } + -- toField (Arg info (TypeSig info' x t)) = FieldSig (inst info') x (Arg info t) + -- in Field (fuseRange $1 $2) $ map toField $2 } -- Variable declarations for automatic generalization Generalize :: { [Declaration] } Generalize : 'variable' ArgTypeSignaturesOrEmpty { let - toGeneralize (Arg info (TypeSig _ x t)) = TypeSig info x t + toGeneralize (Arg info (TypeSig _ tac x t)) = TypeSig info tac x t in [ Generalize (fuseRange $1 $2) (map toGeneralize $2) ] } -- Mutually recursive declarations. @@ -1300,7 +1297,7 @@ -- Instance declarations. Instance :: { Declaration } -Instance : 'instance' Declarations0 { InstanceB (fuseRange $1 $2) $2 } +Instance : 'instance' Declarations0 { InstanceB (getRange $1) $2 } -- Macro declarations. @@ -1358,8 +1355,8 @@ : SimpleTopHole { defaultNamedArg $1 } | '{' SimpleHole '}' { hide $ defaultNamedArg $2 } | '{{' SimpleHole '}}' { makeInstance $ defaultNamedArg $2 } - | '{' SimpleId '=' SimpleHole '}' { hide $ defaultArg $ named $2 $4 } - | '{{' SimpleId '=' SimpleHole '}}' { makeInstance $ defaultArg $ named $2 $4 } + | '{' SimpleId '=' SimpleHole '}' { hide $ defaultArg $ userNamed $2 $4 } + | '{{' SimpleId '=' SimpleHole '}}' { makeInstance $ defaultArg $ userNamed $2 $4 } SimpleTopHole :: { HoleName } SimpleTopHole @@ -1516,7 +1513,9 @@ | TerminatingPragma { $1 } | NonTerminatingPragma { $1 } | NoTerminationCheckPragma { $1 } + | NonCoveringPragma { $1 } | WarningOnUsagePragma { $1 } + | WarningOnImportPragma { $1 } | MeasurePragma { $1 } | CatchallPragma { $1 } | DisplayPragma { $1 } @@ -1535,24 +1534,24 @@ BuiltinPragma :: { Pragma } BuiltinPragma : '{-#' 'BUILTIN' string PragmaQName '#-}' - { BuiltinPragma (getRange ($1,$2,fst $3,$4,$5)) (snd $3) $4 } + { BuiltinPragma (getRange ($1,$2,fst $3,$4,$5)) (mkRString $3) $4 } -- Extra rule to accept keyword REWRITE also as built-in: | '{-#' 'BUILTIN' 'REWRITE' PragmaQName '#-}' - { BuiltinPragma (getRange ($1,$2,$3,$4,$5)) "REWRITE" $4 } + { BuiltinPragma (getRange ($1,$2,$3,$4,$5)) (Ranged (getRange $3) "REWRITE") $4 } RewritePragma :: { Pragma } RewritePragma : '{-#' 'REWRITE' PragmaQNames '#-}' - { RewritePragma (getRange ($1,$2,$3,$4)) $3 } + { RewritePragma (getRange ($1,$2,$3,$4)) (getRange $2) $3 } ForeignPragma :: { Pragma } ForeignPragma - : '{-#' 'FOREIGN' string ForeignCode '#-}' { ForeignPragma (getRange ($1, $2, fst $3, $5)) (snd $3) (recoverLayout $4) } + : '{-#' 'FOREIGN' string ForeignCode '#-}' { ForeignPragma (getRange ($1, $2, fst $3, $5)) (mkRString $3) (recoverLayout $4) } CompilePragma :: { Pragma } CompilePragma : '{-#' 'COMPILE' string PragmaQName PragmaStrings '#-}' - { CompilePragma (getRange ($1,$2,fst $3,$4,$6)) (snd $3) $4 (unwords $5) } + { CompilePragma (getRange ($1,$2,fst $3,$4,$6)) (mkRString $3) $4 (unwords $5) } StaticPragma :: { Pragma } StaticPragma @@ -1600,6 +1599,11 @@ : '{-#' 'TERMINATING' '#-}' { TerminationCheckPragma (getRange ($1,$2,$3)) Terminating } +NonCoveringPragma :: { Pragma } +NonCoveringPragma + : '{-#' 'NON_COVERING' '#-}' + { NoCoverageCheckPragma (getRange ($1,$2,$3)) } + MeasurePragma :: { Pragma } MeasurePragma : '{-#' 'MEASURE' PragmaName '#-}' @@ -1611,9 +1615,10 @@ : '{-#' 'CATCHALL' '#-}' { CatchallPragma (getRange ($1,$2,$3)) } - ImpossiblePragma :: { Pragma } - : '{-#' 'IMPOSSIBLE' '#-}' { ImpossiblePragma (getRange ($1,$2,$3)) } +ImpossiblePragma + : '{-#' 'IMPOSSIBLE' '#-}' + { ImpossiblePragma (getRange ($1,$2,$3)) } NoPositivityCheckPragma :: { Pragma } NoPositivityCheckPragma @@ -1640,6 +1645,15 @@ } } +WarningOnImportPragma :: { Pragma } +WarningOnImportPragma + : '{-#' 'WARNING_ON_IMPORT' literal '#-}' + {% case $3 of + { LitString r str -> return $ WarningOnImport (getRange ($1,$2,r,$4)) str + ; _ -> parseError "Expected string literal" + } + } + -- Possibly empty list of polarities. Reversed. Polarities :: { [(Range, Occurrence)] } Polarities : {- empty -} { [] } @@ -1905,6 +1919,14 @@ xs <- mapM mkName ss return $ foldr Qual (QName $ last xs) (init xs) +-- | Create a DomainFree binding from a name + +mkDomainFree_ :: (NamedArg Binder -> NamedArg Binder) -> Maybe Pattern -> Name -> LamBinding +mkDomainFree_ f p n = DomainFree $ f $ defaultNamedArg $ Binder p $ mkBoundName_ n + +mkRString :: (Interval, String) -> RString +mkRString (i, s) = Ranged (getRange i) s + -- | Create a qualified name from a string (used in pragmas). -- Range of each name component is range of whole string. -- TODO: precise ranges! @@ -1917,12 +1939,12 @@ mkNamedArg :: Maybe QName -> Either QName Range -> Parser (NamedArg BoundName) mkNamedArg x y = do lbl <- case x of - Nothing -> return $ Just $ unranged "_" - Just (QName x) -> return $ Just $ Ranged (getRange x) (prettyShow x) + Nothing -> return $ Just $ WithOrigin UserWritten $ unranged "_" + Just (QName x) -> return $ Just $ WithOrigin UserWritten $ Ranged (getRange x) $ prettyShow x _ -> parseError "expected unqualified variable name" var <- case y of - Left (QName y) -> return $ BName y noFixity' - Right r -> return $ BName (noName r) noFixity' + Left (QName y) -> return $ mkBoundName y noFixity' + Right r -> return $ mkBoundName (noName r) noFixity' _ -> parseError "expected unqualified variable name" return $ defaultArg $ Named lbl var @@ -1967,54 +1989,132 @@ forallPi :: [LamBinding] -> Expr -> Expr forallPi bs e = Pi (map addType bs) e +-- | Builds a 'RawApp' from 'Range' and 'Expr' list, unless the list +-- is a single expression. In the latter case, just the 'Expr' is +-- returned. +rawAppUnlessSingleton :: Range -> [Expr] -> Expr +rawAppUnlessSingleton r = \case + [] -> __IMPOSSIBLE__ + [e] -> e + es -> RawApp r es + -- | Converts lambda bindings to typed bindings. addType :: LamBinding -> TypedBinding addType (DomainFull b) = b addType (DomainFree x) = TBind r [x] $ Underscore r Nothing where r = getRange x -boundNamesOrAbsurd :: [Expr] -> Parser (Either [NamedArg BoundName] [Expr]) +-- | Interpret an expression as a list of names and (not parsed yet) as-patterns + +exprAsTele :: Expr -> [Expr] +exprAsTele (RawApp _ es) = es +exprAsTele e = [e] + +exprAsNamesAndPatterns :: Expr -> Maybe [(Name, Maybe Expr)] +exprAsNamesAndPatterns = mapM exprAsNameAndPattern . exprAsTele + +exprAsNameAndPattern :: Expr -> Maybe (Name, Maybe Expr) +exprAsNameAndPattern (Ident (QName x)) = Just (x, Nothing) +exprAsNameAndPattern (Underscore r _) = Just (Name r InScope [Hole], Nothing) +exprAsNameAndPattern (As _ n e) = Just (n, Just e) +exprAsNameAndPattern (Paren r e) = Just (Name r InScope [Hole], Just e) +exprAsNameAndPattern _ = Nothing + +-- interpret an expression as name or list of hidden / instance names +exprAsNameOrHiddenNames :: Expr -> Maybe [NamedArg (Name, Maybe Expr)] +exprAsNameOrHiddenNames t = case t of + HiddenArg _ (Named Nothing e) -> do + nps <- exprAsNamesAndPatterns e + pure $ map (hide . defaultNamedArg) nps + InstanceArg _ (Named Nothing e) -> do + nps <- exprAsNamesAndPatterns e + pure $ map (makeInstance . defaultNamedArg) nps + e -> (pure . defaultNamedArg) `fmap` exprAsNameAndPattern e + +boundNamesOrAbsurd :: [Expr] -> Parser (Either [NamedArg Binder] [Expr]) boundNamesOrAbsurd es | any isAbsurd es = return $ Right es | otherwise = - case mapM getBName es of - Just good -> return $ Left $ map defaultNamedArg good + case mapM exprAsNameAndPattern es of Nothing -> parseError $ "expected sequence of bound identifiers" - where - getName :: Expr -> Maybe Name - getName (Ident (QName x)) = Just x - getName (Underscore r _) = Just $ Name r NotInScope [Hole] - getName _ = Nothing + Just good -> fmap Left $ forM good $ \ (n, me) -> do + p <- traverse exprToPattern me + return (defaultNamedArg (Binder p (mkBoundName_ n))) - getBName :: Expr -> Maybe BoundName - getBName e = fmap mkBoundName_ $ getName e + where isAbsurd :: Expr -> Bool isAbsurd (Absurd _) = True isAbsurd (HiddenArg _ (Named _ e)) = isAbsurd e isAbsurd (InstanceArg _ (Named _ e)) = isAbsurd e - isAbsurd (Paren _ expr) = isAbsurd expr - isAbsurd (RawApp _ exprs) = any isAbsurd exprs + isAbsurd (Paren _ e) = isAbsurd e + isAbsurd (As _ _ e) = isAbsurd e + isAbsurd (RawApp _ es) = any isAbsurd es isAbsurd _ = False --- | Build a do-statement -buildDoStmt :: Expr -> [LamClause] -> Parser DoStmt -buildDoStmt (RawApp r [e]) cs = buildDoStmt e cs -buildDoStmt (Let r ds Nothing) [] = return $ DoLet r ds -buildDoStmt (RawApp r es) cs +-- | Match a pattern-matching "assignment" statement @p <- e@ +exprToAssignment :: Expr -> Parser (Maybe (Pattern, Range, Expr)) +exprToAssignment (RawApp r es) | (es1, arr : es2) <- break isLeftArrow es = case filter isLeftArrow es2 of arr : _ -> parseError' (rStart' $ getRange arr) $ "Unexpected " ++ prettyShow arr - [] -> DoBind (getRange arr) - <$> exprToPattern (RawApp (getRange es1) es1) - <*> pure (RawApp (getRange es2) es2) - <*> pure cs + [] -> Just <$> ((,,) <$> exprToPattern (RawApp (getRange es1) es1) + <*> pure (getRange arr) + <*> pure (RawApp (getRange es2) es2)) where - isLeftArrow (Ident (QName (Name _ _ [Id arr]))) = elem arr ["<-", "←"] + isLeftArrow (Ident (QName (Name _ _ [Id arr]))) = arr `elem` ["<-", "←"] isLeftArrow _ = False -buildDoStmt e (_ : _) = parseError' (rStart' $ getRange e) "Only pattern matching do-statements can have where clauses." -buildDoStmt e [] = return $ DoThen e +exprToAssignment _ = pure Nothing +-- | Build a with-block +buildWithBlock :: [Either RewriteEqn [Expr]] -> Parser ([RewriteEqn], [Expr]) +buildWithBlock rees = case groupByEither rees of + (Left rs : rest) -> (rs,) <$> finalWith rest + rest -> ([],) <$> finalWith rest + + where + + finalWith :: [Either [RewriteEqn] [[Expr]]] -> Parser [Expr] + finalWith [] = pure $ [] + finalWith [Right ees] = pure $ concat ees + finalWith (Right{} : tl) = parseError' (rStart' $ getRange tl) + "Cannot use rewrite / pattern-matching with after a with-abstraction." + +-- | Build a with-statement +buildWithStmt :: Expr -> Parser [Either RewriteEqn [Expr]] +buildWithStmt e = do + es <- mapM buildSingleWithStmt $ fromWithApp e + let ees = groupByEither es + pure $ map (mapLeft (Invert ())) ees + +buildSingleWithStmt :: Expr -> Parser (Either (Pattern, Expr) Expr) +buildSingleWithStmt e = do + mpatexpr <- exprToAssignment e + pure $ case mpatexpr of + Just (pat, _, expr) -> Left (pat, expr) + Nothing -> Right e + +fromWithApp :: Expr -> [Expr] +fromWithApp = \case + WithApp _ e es -> e : es + e -> [e] + +-- | Build a do-statement +defaultBuildDoStmt :: Expr -> [LamClause] -> Parser DoStmt +defaultBuildDoStmt e (_ : _) = parseError' (rStart' $ getRange e) "Only pattern matching do-statements can have where clauses." +defaultBuildDoStmt e [] = pure $ DoThen e + +buildDoStmt :: Expr -> [LamClause] -> Parser DoStmt +buildDoStmt (RawApp r [e]) cs = buildDoStmt e cs +buildDoStmt (Let r ds Nothing) [] = return $ DoLet r ds +buildDoStmt e@(RawApp r es) cs = do + mpatexpr <- exprToAssignment e + case mpatexpr of + Just (pat, r, expr) -> pure $ DoBind r pat expr cs + Nothing -> defaultBuildDoStmt e cs +buildDoStmt e cs = defaultBuildDoStmt e cs + + mergeImportDirectives :: [ImportDirective] -> Parser ImportDirective mergeImportDirectives is = do i <- foldl merge (return defaultImportDir) is @@ -2028,7 +2128,7 @@ , using = mappend (using i1) (using i2) , hiding = hiding i1 ++ hiding i2 , impRenaming = impRenaming i1 ++ impRenaming i2 - , publicOpen = publicOpen i1 || publicOpen i2 } + , publicOpen = publicOpen i1 <|> publicOpen i2 } -- | Check that an import directive doesn't contain repeated names verifyImportDirective :: ImportDirective -> Parser ImportDirective @@ -2110,40 +2210,15 @@ --------------------------------------------------------------------------} -- | Turn an expression into a left hand side. -exprToLHS :: Expr -> Parser ([Expr] -> [Expr] -> LHS) -exprToLHS e = LHS <$> exprToPattern e +exprToLHS :: Expr -> Parser ([RewriteEqn] -> [WithHiding Expr] -> LHS) +exprToLHS e = (\e rwr wth -> LHS e rwr wth NoEllipsis) <$> exprToPattern e -- | Turn an expression into a pattern. Fails if the expression is not a -- valid pattern. exprToPattern :: Expr -> Parser Pattern -exprToPattern e = do - let failure = parseErrorRange e $ "Not a valid pattern: " ++ prettyShow e - case e of - Ident x -> return $ IdentP x - App _ e1 e2 -> AppP <$> exprToPattern e1 - <*> T.mapM (T.mapM exprToPattern) e2 - Paren r e -> ParenP r - <$> exprToPattern e - Underscore r _ -> return $ WildP r - Absurd r -> return $ AbsurdP r - As r x e -> AsP r x <$> exprToPattern e - Dot r (HiddenArg _ e) -> return $ HiddenP r $ fmap (DotP r) e - Dot r e -> return $ DotP r e - Lit l -> return $ LitP l - HiddenArg r e -> HiddenP r <$> T.mapM exprToPattern e - InstanceArg r e -> InstanceP r <$> T.mapM exprToPattern e - RawApp r es -> RawAppP r <$> mapM exprToPattern es - Quote r -> return $ QuoteP r - Rec r es | Just fs <- mapM maybeLeft es -> do - RecP r <$> T.mapM (T.mapM exprToPattern) fs - Equal r e1 e2 -> return $ EqualP r [(e1, e2)] - Ellipsis r -> return $ EllipsisP r - -- WithApp has already lost the range information of the bars '|' - WithApp r e es -> do - p <- exprToPattern e - ps <- forM es $ \ e -> defaultNamedArg . WithP (getRange e) <$> exprToPattern e -- TODO #2822: Range! - return $ foldl AppP p ps - _ -> failure +exprToPattern e = case C.isPattern e of + Nothing -> parseErrorRange e $ "Not a valid pattern: " ++ prettyShow e + Just p -> pure p opAppExprToPattern :: OpApp Expr -> Parser Pattern opAppExprToPattern (SyntaxBindingLambda _ _ _) = parseError "Syntax binding lambda cannot appear in a pattern" @@ -2165,21 +2240,31 @@ Equal _ a b -> Just (stripSingletonRawApp a, stripSingletonRawApp b) _ -> Nothing -maybeNamed :: Expr -> Named_ Expr +-- | When given expression is @e1 = e2@, turn it into a named expression. +-- Call this inside an implicit argument @{e}@ or @{{e}}@, where +-- an equality must be a named argument (rather than a cubical partial match). +maybeNamed :: Expr -> Parser (Named_ Expr) maybeNamed e = case isEqual e of - Just (Ident (QName x), b) -> named (Ranged (getRange x) (nameToRawName x)) b - _ -> unnamed e + Nothing -> return $ unnamed e + Just (e1, e2) -> do + let succeed x = return $ named (WithOrigin UserWritten $ Ranged (getRange e1) x) e2 + case e1 of + Ident (QName x) -> succeed $ nameToRawName x + -- We could have the following, but names of arguments cannot be _. + -- Underscore{} -> succeed $ "_" + _ -> parseErrorRange e $ "Not a valid named argument: " ++ prettyShow e patternSynArgs :: [Either Hiding LamBinding] -> Parser [Arg Name] patternSynArgs = mapM pSynArg where - pSynArg Left{} = parseError "Absurd patterns are not allowed in pattern synonyms" - pSynArg (Right DomainFull{}) = parseError "Unexpected type signature in pattern synonym argument" + pSynArg Left{} = parseError "Absurd patterns are not allowed in pattern synonyms" + pSynArg (Right DomainFull{}) = parseError "Unexpected type signature in pattern synonym argument" pSynArg (Right (DomainFree x)) - | let h = getHiding x, h `notElem` [Hidden, NotHidden] = parseError $ prettyShow h ++ " arguments not allowed to pattern synonyms" - | getRelevance x /= Relevant = parseError "Arguments to pattern synonyms must be relevant" - | otherwise = return $ fmap (boundName . namedThing) x + | let h = getHiding x, h `notElem` [Hidden, NotHidden] + = parseError $ prettyShow h ++ " arguments not allowed to pattern synonyms" + | not (isRelevant x) = parseError "Arguments to pattern synonyms must be relevant" + | otherwise = return $ fmap (boundName . binderName . namedThing) x parsePanic s = parseError $ "Internal parser error: " ++ s ++ ". Please report this as a bug." @@ -2209,24 +2294,24 @@ return [FunClause lhs rhs wh False] TypeSigsRHS e -> case wh of NoWhere -> case lhs of - LHS p _ _ | hasEllipsis p -> parseError "The ellipsis ... cannot have a type signature" - LHS _ _ (_:_) -> parseError "Illegal: with in type signature" - LHS _ (_:_) _ -> parseError "Illegal: rewrite in type signature" - LHS p _ _ | hasWithPatterns p -> parseError "Illegal: with patterns in type signature" - LHS p [] [] -> forMM (patternToNames p) $ \ (info, x) -> do + LHS p _ _ _ | hasEllipsis p -> parseError "The ellipsis ... cannot have a type signature" + LHS _ _ (_:_) _ -> parseError "Illegal: with in type signature" + LHS _ (_:_) _ _ -> parseError "Illegal: rewrite in type signature" + LHS p _ _ _ | hasWithPatterns p -> parseError "Illegal: with patterns in type signature" + LHS p [] [] _ -> forMM (patternToNames p) $ \ (info, x) -> do info <- applyAttrs attrs info - return $ typeSig info x e + return $ typeSig info (getTacticAttr attrs) x e _ -> parseError "A type signature cannot have a where clause" parseDisplayPragma :: Range -> Position -> String -> Parser Pragma parseDisplayPragma r pos s = case parsePosString pos defaultParseFlags [normal] funclauseParser s of - ParseOk s [FunClause (LHS lhs [] []) (RHS rhs) NoWhere ca] | null (parseInp s) -> + ParseOk s [FunClause (LHS lhs [] [] _) (RHS rhs) NoWhere ca] | null (parseInp s) -> return $ DisplayPragma r lhs rhs _ -> parseError "Invalid DISPLAY pragma. Should have form {-# DISPLAY LHS = RHS #-}." -typeSig :: ArgInfo -> Name -> Expr -> Declaration -typeSig i n e = TypeSig i n (Generalized e) +typeSig :: ArgInfo -> TacticAttribute -> Name -> Expr -> Declaration +typeSig i tac n e = TypeSig i tac n (Generalized e) -- * Attributes @@ -2245,8 +2330,8 @@ setRange r (Attr _ x a) = Attr r x a -- | Parse an attribute. -toAttribute :: (HasRange e, Pretty e) => e -> Parser Attr -toAttribute x = maybe failure (return . Attr (getRange x) y) $ stringToAttribute y +toAttribute :: Expr -> Parser Attr +toAttribute x = maybe failure (return . Attr (getRange x) y) $ exprToAttribute x where y = prettyShow x failure = parseErrorRange x $ "Unknown attribute: " ++ y @@ -2268,7 +2353,23 @@ let attrs = reverse rattrs checkForUniqueAttribute (isJust . isQuantityAttribute ) attrs checkForUniqueAttribute (isJust . isRelevanceAttribute) attrs + checkForUniqueAttribute (isJust . isTacticAttribute) attrs foldM (flip applyAttr) arg attrs + +-- | Set the tactic attribute of a binder +setTacticAttr :: [Attr] -> NamedArg Binder -> NamedArg Binder +setTacticAttr as = updateNamedArg $ fmap $ \ b -> + case getTacticAttr as of + Just t -> b { bnameTactic = Just t } + Nothing -> b + +-- | Get the tactic attribute if present. +getTacticAttr :: [Attr] -> TacticAttribute +getTacticAttr as = + case tacticAttributes [ a | Attr _ _ a <- as ] of + [TacticAttribute e] -> Just e + [] -> Nothing + _ -> __IMPOSSIBLE__ -- | Report a parse error if two attributes in the list are of the same kind, -- thus, present conflicting information. diff --git a/src/full/Agda/Syntax/Parser/StringLiterals.hs b/src/full/Agda/Syntax/Parser/StringLiterals.hs --- a/src/full/Agda/Syntax/Parser/StringLiterals.hs +++ b/src/full/Agda/Syntax/Parser/StringLiterals.hs @@ -14,7 +14,6 @@ import Agda.Syntax.Position import Agda.Syntax.Literal -import Agda.Utils.Char ( decDigit, hexDigit, octDigit ) import Agda.Utils.Tuple ( (-*-) ) {-------------------------------------------------------------------------- @@ -123,10 +122,10 @@ then return (chr (ord c - ord '@')) else lookAheadError "invalid control character" - 'x' -> readNum isHexDigit 16 hexDigit - 'o' -> readNum isOctDigit 8 octDigit + 'x' -> readNum isHexDigit 16 digitToInt + 'o' -> readNum isOctDigit 8 digitToInt x | isDigit x - -> readNumAcc isDigit 10 decDigit (decDigit x) + -> readNumAcc isDigit 10 digitToInt (digitToInt x) c -> -- Try to match the input (starting with c) against the diff --git a/src/full/Agda/Syntax/Parser/Tokens.hs b/src/full/Agda/Syntax/Parser/Tokens.hs --- a/src/full/Agda/Syntax/Parser/Tokens.hs +++ b/src/full/Agda/Syntax/Parser/Tokens.hs @@ -23,10 +23,11 @@ | KwIMPOSSIBLE | KwSTATIC | KwINJECTIVE | KwINLINE | KwNOINLINE | KwETA | KwNO_TERMINATION_CHECK | KwTERMINATING | KwNON_TERMINATING - | KwWARNING_ON_USAGE + | KwNON_COVERING + | KwWARNING_ON_USAGE | KwWARNING_ON_IMPORT | KwMEASURE | KwDISPLAY | KwREWRITE - | KwQuoteGoal | KwQuoteContext | KwQuote | KwQuoteTerm + | KwQuote | KwQuoteTerm | KwUnquote | KwUnquoteDecl | KwUnquoteDef | KwSyntax | KwPatternSyn | KwTactic | KwCATCHALL @@ -44,7 +45,7 @@ | SymColon | SymArrow | SymEqual | SymLambda | SymUnderscore | SymQuestionMark | SymAs | SymOpenParen | SymCloseParen - | SymOpenIdiomBracket | SymCloseIdiomBracket + | SymOpenIdiomBracket | SymCloseIdiomBracket | SymEmptyIdiomBracket | SymDoubleOpenBrace | SymDoubleCloseBrace | SymOpenBrace | SymCloseBrace | SymOpenVirtualBrace | SymCloseVirtualBrace diff --git a/src/full/Agda/Syntax/Position.hs b/src/full/Agda/Syntax/Position.hs --- a/src/full/Agda/Syntax/Position.hs +++ b/src/full/Agda/Syntax/Position.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE DeriveGeneric #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} @@ -66,21 +65,17 @@ , interleaveRanges ) where -#if MIN_VERSION_base(4,11,0) -import Prelude hiding ( (<>), null ) -#else import Prelude hiding ( null ) -#endif -import Control.Applicative hiding (empty) -import Control.Monad -import Control.Monad.Writer (runWriter, Writer, tell) +import Control.Monad.Writer (runWriter, tell) import Data.Foldable (Foldable) import qualified Data.Foldable as Fold import Data.Function import Data.Int import Data.List hiding (null) +import Data.List.NonEmpty (NonEmpty(..)) +import qualified Data.List.NonEmpty as NonEmpty import Data.Map (Map) import qualified Data.Map as Map import Data.Set (Set) @@ -96,11 +91,9 @@ import Agda.Utils.FileName import Agda.Utils.List import qualified Agda.Utils.Maybe.Strict as Strict -import Agda.Utils.NonemptyList import Agda.Utils.Null import Agda.Utils.Pretty -#include "undefined.h" import Agda.Utils.Impossible {-------------------------------------------------------------------------- @@ -268,6 +261,9 @@ instance HasRange Range where getRange = id +instance HasRange () where + getRange _ = noRange + instance HasRange Bool where getRange _ = noRange @@ -278,7 +274,7 @@ -- | Precondition: The ranges of the list elements must point to the -- same file (or be empty). -instance HasRange a => HasRange (NonemptyList a) where +instance HasRange a => HasRange (NonEmpty a) where getRange = Fold.foldr fuseRange noRange -- | Precondition: The ranges of the tuple elements must point to the @@ -312,8 +308,7 @@ getRange (x,y,z,w,v,u,t) = getRange (x,(y,(z,(w,(v,(u,t)))))) instance HasRange a => HasRange (Maybe a) where - getRange Nothing = noRange - getRange (Just a) = getRange a + getRange = maybe noRange getRange instance (HasRange a, HasRange b) => HasRange (Either a b) where getRange = either getRange getRange @@ -330,6 +325,9 @@ instance SetRange a => SetRange [a] where setRange r = fmap $ setRange r +instance SetRange a => SetRange (Maybe a) where + setRange r = fmap $ setRange r + -- | Killing the range of an object sets all range information to 'noRange'. class KillRange a where killRange :: KillRangeT a @@ -484,7 +482,7 @@ instance {-# OVERLAPPABLE #-} KillRange a => KillRange [a] where killRange = map killRange -instance KillRange a => KillRange (NonemptyList a) where +instance KillRange a => KillRange (NonEmpty a) where killRange = fmap killRange -- | Overlaps with @KillRange [a]@. @@ -509,6 +507,9 @@ killRange (x, y, z, u) = killRange4 (,,,) x y z u instance KillRange a => KillRange (Maybe a) where + killRange = fmap killRange + +instance KillRange a => KillRange (Strict.Maybe a) where killRange = fmap killRange instance (KillRange a, KillRange b) => KillRange (Either a b) where diff --git a/src/full/Agda/Syntax/Reflected.hs b/src/full/Agda/Syntax/Reflected.hs --- a/src/full/Agda/Syntax/Reflected.hs +++ b/src/full/Agda/Syntax/Reflected.hs @@ -5,6 +5,7 @@ import Agda.Syntax.Common import Agda.Syntax.Literal import Agda.Syntax.Abstract.Name +import Agda.Syntax.Internal (Dom) type Args = [Arg Term] diff --git a/src/full/Agda/Syntax/Scope/Base.hs b/src/full/Agda/Syntax/Scope/Base.hs --- a/src/full/Agda/Syntax/Scope/Base.hs +++ b/src/full/Agda/Syntax/Scope/Base.hs @@ -1,4 +1,4 @@ -{-# LANGUAGE CPP #-} +{-# LANGUAGE BangPatterns #-} {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE GADTs #-} @@ -6,20 +6,16 @@ -} module Agda.Syntax.Scope.Base where -#if MIN_VERSION_base(4,11,0) -import Prelude hiding ( (<>), null ) -#else import Prelude hiding ( null ) -#endif -import Control.Arrow (first, second, (***)) -import Control.Applicative hiding (empty) -import Control.DeepSeq +import Control.Arrow (first, second) import Control.Monad import Data.Either (partitionEithers) import Data.Function import qualified Data.List as List +import Data.List.NonEmpty (NonEmpty(..)) +import qualified Data.List.NonEmpty as NonEmpty import Data.Map (Map) import qualified Data.Map as Map import Data.Set (Set) @@ -44,13 +40,12 @@ import Agda.Utils.Functor import Agda.Utils.Lens import Agda.Utils.List -import Agda.Utils.NonemptyList +import Agda.Utils.Maybe (filterMaybe) import Agda.Utils.Null import Agda.Utils.Pretty import Agda.Utils.Singleton import qualified Agda.Utils.Map as Map -#include "undefined.h" import Agda.Utils.Impossible -- * Scope representation @@ -71,17 +66,16 @@ = PrivateNS -- ^ Things not exported by this module. | PublicNS -- ^ Things defined and exported by this module. | ImportedNS -- ^ Things from open public, exported by this module. - | OnlyQualifiedNS -- ^ Visible (as qualified) from outside, - -- but not exported when opening the module. - -- Used for qualified constructors. deriving (Data, Eq, Bounded, Enum, Show) +allNameSpaces :: [NameSpaceId] +allNameSpaces = [minBound..maxBound] + type ScopeNameSpaces = [(NameSpaceId, NameSpace)] localNameSpace :: Access -> NameSpaceId localNameSpace PublicAccess = PublicNS localNameSpace PrivateAccess{} = PrivateNS -localNameSpace OnlyQualified = OnlyQualifiedNS nameSpaceAccess :: NameSpaceId -> Access nameSpaceAccess PrivateNS = PrivateAccess Inserted @@ -104,22 +98,22 @@ -- | The complete information about the scope at a particular program point -- includes the scope stack, the local variables, and the context precedence. data ScopeInfo = ScopeInfo - { scopeCurrent :: A.ModuleName - , scopeModules :: Map A.ModuleName Scope - , scopeVarsToBind :: LocalVars - , scopeLocals :: LocalVars - , scopePrecedence :: PrecedenceStack - , scopeInverseName :: NameMap - , scopeInverseModule :: ModuleMap - , scopeInScope :: InScopeSet - , scopeFixities :: C.Fixities -- ^ Maps concrete names to fixities - , scopePolarities :: C.Polarities -- ^ Maps concrete names to polarities + { _scopeCurrent :: A.ModuleName + , _scopeModules :: Map A.ModuleName Scope + , _scopeVarsToBind :: LocalVars + , _scopeLocals :: LocalVars + , _scopePrecedence :: PrecedenceStack + , _scopeInverseName :: NameMap + , _scopeInverseModule :: ModuleMap + , _scopeInScope :: InScopeSet + , _scopeFixities :: C.Fixities -- ^ Maps concrete names C.Name to fixities + , _scopePolarities :: C.Polarities -- ^ Maps concrete names C.Name to polarities } deriving (Data, Show) -type NameMap = Map A.QName (NonemptyList C.QName) +type NameMap = Map A.QName (NonEmpty C.QName) type ModuleMap = Map A.ModuleName [C.QName] --- type ModuleMap = Map A.ModuleName (NonemptyList C.QName) +-- type ModuleMap = Map A.ModuleName (NonEmpty C.QName) instance Eq ScopeInfo where ScopeInfo c1 m1 v1 l1 p1 _ _ _ _ _ == ScopeInfo c2 m2 v2 l2 p2 _ _ _ _ _ = @@ -130,7 +124,7 @@ -- | For each bound variable, we want to know whether it was bound by a -- λ, Π, module telescope, pattern, or @let@. -data Binder +data BindingSource = LambdaBound -- ^ @λ@ (currently also used for @Π@ and module parameters) | PatternBound -- ^ @f ... =@ | LetBound -- ^ @let ... in@ @@ -140,11 +134,11 @@ -- In case of reference to a shadowed variable, we want to report -- a scope error. data LocalVar = LocalVar - { localVar :: A.Name + { localVar :: A.Name -- ^ Unique ID of local variable. - , localBinder :: Binder + , localBindingSource :: BindingSource -- ^ Kind of binder used to introduce the variable (@λ@, @let@, ...). - , localShadowedBy :: [AbstractName] + , localShadowedBy :: [AbstractName] -- ^ If this list is not empty, the local variable is -- shadowed by one or more imports. } @@ -169,7 +163,8 @@ -- | Treat patternBound variable as a module parameter patternToModuleBound :: LocalVar -> LocalVar patternToModuleBound x - | localBinder x == PatternBound = x { localBinder = LambdaBound } + | localBindingSource x == PatternBound = + x { localBindingSource = LambdaBound } | otherwise = x -- | Project name of unshadowed local variable. @@ -181,22 +176,88 @@ notShadowedLocals :: LocalVars -> AssocList C.Name A.Name notShadowedLocals = mapMaybe $ \ (c,x) -> (c,) <$> notShadowedLocal x +-- | Lenses for ScopeInfo components +scopeCurrent :: Lens' A.ModuleName ScopeInfo +scopeCurrent f s = + f (_scopeCurrent s) <&> + \x -> s { _scopeCurrent = x } + +scopeModules :: Lens' (Map A.ModuleName Scope) ScopeInfo +scopeModules f s = + f (_scopeModules s) <&> + \x -> s { _scopeModules = x } + +scopeVarsToBind :: Lens' LocalVars ScopeInfo +scopeVarsToBind f s = + f (_scopeVarsToBind s) <&> + \x -> s { _scopeVarsToBind = x } + +scopeLocals :: Lens' LocalVars ScopeInfo +scopeLocals f s = + f (_scopeLocals s) <&> + \x -> s { _scopeLocals = x } + +scopePrecedence :: Lens' PrecedenceStack ScopeInfo +scopePrecedence f s = + f (_scopePrecedence s) <&> + \x -> s { _scopePrecedence = x } + +scopeInverseName :: Lens' NameMap ScopeInfo +scopeInverseName f s = + f (_scopeInverseName s) <&> + \x -> s { _scopeInverseName = x } + +scopeInverseModule :: Lens' ModuleMap ScopeInfo +scopeInverseModule f s = + f (_scopeInverseModule s) <&> + \x -> s { _scopeInverseModule = x } + +scopeInScope :: Lens' InScopeSet ScopeInfo +scopeInScope f s = + f (_scopeInScope s) <&> + \x -> s { _scopeInScope = x } + +scopeFixities :: Lens' C.Fixities ScopeInfo +scopeFixities f s = + f (_scopeFixities s) <&> + \x -> s { _scopeFixities = x } + +scopePolarities :: Lens' C.Polarities ScopeInfo +scopePolarities f s = + f (_scopePolarities s) <&> + \x -> s { _scopePolarities = x } + +scopeFixitiesAndPolarities :: Lens' (C.Fixities, C.Polarities) ScopeInfo +scopeFixitiesAndPolarities f s = + f' (_scopeFixities s) (_scopePolarities s) <&> + \ (fixs, pols) -> s { _scopeFixities = fixs, _scopePolarities = pols } + where + -- Andreas, 2019-08-18: strict matching avoids space leak, see #1829. + f' !fixs !pols = f (fixs, pols) + -- Andrea comments on https://github.com/agda/agda/issues/1829#issuecomment-522312084 + -- on a naive version without the bang patterns: + -- + -- useScope (because of useR) forces the result of projecting the + -- lens, this usually prevents retaining the whole structure when we + -- only need a field. However your combined lens adds an extra layer + -- of laziness with the pairs, so the actual projections remain + -- unforced. + -- + -- I guess scopeFixitiesAndPolarities could add some strictness when building the pair? + -- | Lens for 'scopeVarsToBind'. updateVarsToBind :: (LocalVars -> LocalVars) -> ScopeInfo -> ScopeInfo -updateVarsToBind f sc = sc { scopeVarsToBind = f (scopeVarsToBind sc) } +updateVarsToBind = over scopeVarsToBind setVarsToBind :: LocalVars -> ScopeInfo -> ScopeInfo -setVarsToBind vars = updateVarsToBind (const vars) +setVarsToBind = set scopeVarsToBind -- | Lens for 'scopeLocals'. updateScopeLocals :: (LocalVars -> LocalVars) -> ScopeInfo -> ScopeInfo -updateScopeLocals f sc = sc { scopeLocals = f (scopeLocals sc) } +updateScopeLocals = over scopeLocals setScopeLocals :: LocalVars -> ScopeInfo -> ScopeInfo -setScopeLocals vars = updateScopeLocals (const vars) - -mapScopeInfo :: (Scope -> Scope) -> ScopeInfo -> ScopeInfo -mapScopeInfo f i = i{ scopeModules = f <$> scopeModules i } +setScopeLocals = set scopeLocals ------------------------------------------------------------------------ -- * Name spaces @@ -213,6 +274,8 @@ , nsModules :: ModulesInScope -- ^ Maps concrete module names to a list of abstract module names. , nsInScope :: InScopeSet + -- ^ All abstract names targeted by a concrete name in scope. + -- Computed by 'recomputeInScopeSets'. } deriving (Data, Eq, Show) @@ -229,7 +292,7 @@ ModuleTag :: InScopeTag AbstractModule -- | Type class for some dependent-types trickery. -class Eq a => InScope a where +class Ord a => InScope a where inScopeTag :: InScopeTag a instance InScope AbstractName where @@ -246,6 +309,10 @@ NameTag -> nsNames ModuleTag -> nsModules +-- | Non-dependent tag for name or module. +data NameOrModule = NameNotModule | ModuleNotName + deriving (Data, Eq, Ord, Show, Enum, Bounded) + ------------------------------------------------------------------------ -- * Decorated names -- @@ -255,21 +322,51 @@ -- | For the sake of parsing left-hand sides, we distinguish -- constructor and record field names from defined names. + +-- Note: order does matter in this enumeration, see 'isDefName'. data KindOfName - = ConName -- ^ Constructor name. - | FldName -- ^ Record field name. - | DefName -- ^ Ordinary defined name. - | PatternSynName -- ^ Name of a pattern synonym. - | GeneralizeName -- ^ Name to be generalized + = ConName -- ^ Constructor name. + | FldName -- ^ Record field name. + | PatternSynName -- ^ Name of a pattern synonym. + | GeneralizeName -- ^ Name to be generalized | DisallowedGeneralizeName -- ^ Generalizable variable from a let open - | MacroName -- ^ Name of a macro - | QuotableName -- ^ A name that can only be quoted. - deriving (Eq, Show, Data, Enum, Bounded) + | MacroName -- ^ Name of a macro + | QuotableName -- ^ A name that can only be quoted. + -- Previous category @DefName@: + -- (Refined in a flat manner as Enum and Bounded are not hereditary.) + | DataName -- ^ Name of a @data@. + | RecName -- ^ Name of a @record@. + | FunName -- ^ Name of a defined function. + | AxiomName -- ^ Name of a @postulate@. + | PrimName -- ^ Name of a @primitive@. + | OtherDefName -- ^ A @DefName@, but either other kind or don't know which kind. + -- End @DefName@. Keep these together in sequence, for sake of @isDefName@! + deriving (Eq, Ord, Show, Data, Enum, Bounded) --- | A list containing all name kinds. -allKindsOfNames :: [KindOfName] -allKindsOfNames = [minBound..maxBound] +isDefName :: KindOfName -> Bool +isDefName = (>= DataName) +-- | A set of 'KindOfName', for the sake of 'elemKindsOfNames'. +data KindsOfNames + = AllKindsOfNames + | SomeKindsOfNames (Set KindOfName) -- ^ Only these kinds. + | ExceptKindsOfNames (Set KindOfName) -- ^ All but these Kinds. + +elemKindsOfNames :: KindOfName -> KindsOfNames -> Bool +elemKindsOfNames k = \case + AllKindsOfNames -> True + SomeKindsOfNames ks -> k `Set.member` ks + ExceptKindsOfNames ks -> k `Set.notMember` ks + +allKindsOfNames :: KindsOfNames +allKindsOfNames = AllKindsOfNames + +someKindsOfNames :: [KindOfName] -> KindsOfNames +someKindsOfNames = SomeKindsOfNames . Set.fromList + +exceptKindsOfNames :: [KindOfName] -> KindsOfNames +exceptKindsOfNames = ExceptKindsOfNames . Set.fromList + -- | Where does a name come from? -- -- This information is solely for reporting to the user, @@ -316,6 +413,9 @@ instance Ord AbstractName where compare = compare `on` anameName +instance LensFixity AbstractName where + lensFixity = lensAnameName . lensFixity + -- | Van Laarhoven lens on 'anameName'. lensAnameName :: Functor m => (A.QName -> m A.QName) -> AbstractName -> m AbstractName lensAnameName f am = f (anameName am) <&> \ m -> am { anameName = m } @@ -334,21 +434,21 @@ data ResolvedName = -- | Local variable bound by λ, Π, module telescope, pattern, @let@. VarName - { resolvedVar :: A.Name - , resolvedBinder :: Binder -- ^ What kind of binder? + { resolvedVar :: A.Name + , resolvedBindingSource :: BindingSource -- ^ What kind of binder? } | -- | Function, data/record type, postulate. DefinedName Access AbstractName -- ^ 'anameKind' can be 'DefName', 'MacroName', 'QuotableName'. | -- | Record field name. Needs to be distinguished to parse copatterns. - FieldName (NonemptyList AbstractName) -- ^ @('FldName' ==) . 'anameKind'@ for all names. + FieldName (NonEmpty AbstractName) -- ^ @('FldName' ==) . 'anameKind'@ for all names. | -- | Data or record constructor name. - ConstructorName (NonemptyList AbstractName) -- ^ @('ConName' ==) . 'anameKind'@ for all names. + ConstructorName (NonEmpty AbstractName) -- ^ @('ConName' ==) . 'anameKind'@ for all names. | -- | Name of pattern synonym. - PatternSynResName (NonemptyList AbstractName) -- ^ @('PatternSynName' ==) . 'anameKind'@ for all names. + PatternSynResName (NonEmpty AbstractName) -- ^ @('PatternSynName' ==) . 'anameKind'@ for all names. | -- | Unbound name. UnknownName @@ -368,6 +468,9 @@ mergeNames :: Eq a => ThingsInScope a -> ThingsInScope a -> ThingsInScope a mergeNames = Map.unionWith List.union +mergeNamesMany :: Eq a => [ThingsInScope a] -> ThingsInScope a +mergeNamesMany = Map.unionsWith List.union + ------------------------------------------------------------------------ -- * Operations on name spaces ------------------------------------------------------------------------ @@ -418,7 +521,9 @@ emptyScope = Scope { scopeName = noModuleName , scopeParents = [] - , scopeNameSpaces = [ (nsid, emptyNameSpace) | nsid <- [minBound..maxBound] ] + , scopeNameSpaces = [ (nsid, emptyNameSpace) | nsid <- allNameSpaces ] + -- Note (Andreas, 2019-08-19): Cannot have [] here because + -- zipScope assumes all NameSpaces to be present and in the same order. , scopeImports = Map.empty , scopeDatatypeModule = Nothing } @@ -426,16 +531,16 @@ -- | The empty scope info. emptyScopeInfo :: ScopeInfo emptyScopeInfo = ScopeInfo - { scopeCurrent = noModuleName - , scopeModules = Map.singleton noModuleName emptyScope - , scopeVarsToBind = [] - , scopeLocals = [] - , scopePrecedence = [] - , scopeInverseName = Map.empty - , scopeInverseModule = Map.empty - , scopeInScope = Set.empty - , scopeFixities = Map.empty - , scopePolarities = Map.empty + { _scopeCurrent = noModuleName + , _scopeModules = Map.singleton noModuleName emptyScope + , _scopeVarsToBind = [] + , _scopeLocals = [] + , _scopePrecedence = [] + , _scopeInverseName = Map.empty + , _scopeInverseModule = Map.empty + , _scopeInScope = Set.empty + , _scopeFixities = Map.empty + , _scopePolarities = Map.empty } -- | Map functions over the names and modules in a scope. @@ -455,13 +560,12 @@ mapScope_ fd fm fs = mapScope (const fd) (const fm) (const fs) -- | Same as 'mapScope' but applies the function only on the given name space. -mapScope' :: NameSpaceId -> (NamesInScope -> NamesInScope ) -> - (ModulesInScope -> ModulesInScope) -> - (InScopeSet -> InScopeSet ) -> - Scope -> Scope -mapScope' i fd fm fs = mapScope (\ j -> if i == j then fd else id) - (\ j -> if i == j then fm else id) - (\ j -> if i == j then fs else id) +mapScopeNS :: NameSpaceId + -> (NamesInScope -> NamesInScope ) + -> (ModulesInScope -> ModulesInScope) + -> (InScopeSet -> InScopeSet ) + -> Scope -> Scope +mapScopeNS nsid fd fm fs = modifyNameSpace nsid $ mapNameSpace fd fm fs -- | Map monadic functions over the names and modules in a scope. mapScopeM :: Applicative m => @@ -515,8 +619,9 @@ recomputeInScopeSets :: Scope -> Scope recomputeInScopeSets = updateScopeNameSpaces (map $ second recomputeInScope) where - recomputeInScope ns = ns { nsInScope = Set.unions $ map (Set.fromList . map anameName) - $ Map.elems $ nsNames ns } + recomputeInScope ns = ns { nsInScope = allANames $ nsNames ns } + allANames :: NamesInScope -> InScopeSet + allANames = Set.fromList . map anameName . concat . Map.elems -- | Filter a scope keeping only concrete names matching the predicates. -- The first predicate is applied to the names and the second to the modules. @@ -527,23 +632,27 @@ -- | Return all names in a scope. allNamesInScope :: InScope a => Scope -> ThingsInScope a -allNamesInScope = namesInScope [minBound..maxBound] +allNamesInScope = mergeNamesMany . map (inNameSpace . snd) . scopeNameSpaces allNamesInScope' :: InScope a => Scope -> ThingsInScope (a, Access) allNamesInScope' s = - foldr1 mergeNames [ map (, nameSpaceAccess ns) <$> namesInScope [ns] s - | ns <- [minBound..maxBound] ] + mergeNamesMany [ map (, nameSpaceAccess nsId) <$> inNameSpace ns + | (nsId, ns) <- scopeNameSpaces s ] -- | Returns the scope's non-private names. exportedNamesInScope :: InScope a => Scope -> ThingsInScope a -exportedNamesInScope = namesInScope [PublicNS, ImportedNS, OnlyQualifiedNS] +exportedNamesInScope = namesInScope [PublicNS, ImportedNS] namesInScope :: InScope a => [NameSpaceId] -> Scope -> ThingsInScope a namesInScope ids s = - foldr1 mergeNames [ inNameSpace (scopeNameSpace nsid s) | nsid <- ids ] + mergeNamesMany [ inNameSpace (scopeNameSpace nsid s) | nsid <- ids ] allThingsInScope :: Scope -> NameSpace -allThingsInScope = thingsInScope [minBound..maxBound] +allThingsInScope s = + NameSpace { nsNames = allNamesInScope s + , nsModules = allNamesInScope s + , nsInScope = Set.unions $ map (nsInScope . snd) $ scopeNameSpaces s + } thingsInScope :: [NameSpaceId] -> Scope -> NameSpace thingsInScope fs s = @@ -572,7 +681,7 @@ zero = emptyNameSpace one = allThingsInScope s imp = thingsInScope [ImportedNS] s - noimp = thingsInScope [PublicNS, PrivateNS, OnlyQualifiedNS] s + noimp = thingsInScope [PublicNS, PrivateNS] s ns b = case (a, b) of (PublicNS, PublicNS) -> noimp @@ -588,83 +697,153 @@ modifyNameSpace :: NameSpaceId -> (NameSpace -> NameSpace) -> Scope -> Scope modifyNameSpace nsid f = updateScopeNameSpaces $ AssocList.updateAt nsid f --- | Add names to a scope. -addNamesToScope :: NameSpaceId -> C.Name -> [AbstractName] -> Scope -> Scope -addNamesToScope acc x ys s = mergeScope s s1 - where - s1 = setScopeAccess acc $ setNameSpace PublicNS ns emptyScope - ns = emptyNameSpace { nsNames = Map.singleton x ys - , nsInScope = Set.fromList (map anameName ys) } - -- | Add a name to a scope. addNameToScope :: NameSpaceId -> C.Name -> AbstractName -> Scope -> Scope -addNameToScope acc x y s = addNamesToScope acc x [y] s +addNameToScope nsid x y = + mapScopeNS nsid + (Map.insertWith (flip List.union) x [y]) -- bind name x ↦ y + id -- no change to modules + (Set.insert $ anameName y) -- y is in scope now -- | Remove a name from a scope. Caution: does not update the nsInScope set. -- This is only used by rebindName and in that case we add the name right -- back (but with a different kind). removeNameFromScope :: NameSpaceId -> C.Name -> Scope -> Scope -removeNameFromScope ns x s = mapScope remove (const id) (const id) s - where - remove ns' | ns' /= ns = id - | otherwise = Map.delete x +removeNameFromScope nsid x = mapScopeNS nsid (Map.delete x) id id -- | Add a module to a scope. addModuleToScope :: NameSpaceId -> C.Name -> AbstractModule -> Scope -> Scope -addModuleToScope acc x m s = mergeScope s s1 - where - s1 = setScopeAccess acc $ setNameSpace PublicNS ns emptyScope - ns = emptyNameSpace { nsModules = Map.singleton x [m] } +addModuleToScope nsid x m = mapScopeNS nsid id addM id + where addM = Map.insertWith (flip List.union) x [m] --- When we get here we cannot have both using and hiding -type UsingOrHiding = Either C.Using [C.ImportedName] +-- | When we get here we cannot have both @using@ and @hiding@. +data UsingOrHiding + = UsingOnly [C.ImportedName] + | HidingOnly [C.ImportedName] usingOrHiding :: C.ImportDirective -> UsingOrHiding usingOrHiding i = case (using i, hiding i) of - (UseEverything, xs) -> Right xs - (u, []) -> Left u + (UseEverything, ys) -> HidingOnly ys + (Using xs , []) -> UsingOnly xs _ -> __IMPOSSIBLE__ --- | Apply an 'ImportDirective' to a scope. +-- | Apply an 'ImportDirective' to a scope: +-- +-- 1. rename keys (C.Name) according to @renaming@; +-- +-- 2. for untouched keys, either of +-- +-- a) remove keys according to @hiding@, or +-- b) filter keys according to @using@. +-- +-- Both steps could be done in one pass, by first preparing key-filtering +-- functions @C.Name -> Maybe C.Name@ for defined names and module names. +-- However, the penalty of doing it in two passes should not be too high. +-- (Doubling the run time.) applyImportDirective :: C.ImportDirective -> Scope -> Scope -applyImportDirective dir s = mergeScope usedOrHidden renamed +applyImportDirective dir = fst . applyImportDirective_ dir + +-- | Version of 'applyImportDirective' that also returns sets of name +-- and module name clashes introduced by @renaming@ to identifiers +-- that are already imported by @using@ or lack of @hiding@. +applyImportDirective_ + :: C.ImportDirective + -> Scope + -> (Scope, (Set C.Name, Set C.Name)) -- ^ Merged scope, clashing names, clashing module names. +applyImportDirective_ dir@(ImportDirective{ impRenaming }) s + | null dir = (s, (empty, empty)) + -- Since each run of applyImportDirective rebuilds the scope + -- with cost O(n log n) time, it makes sense to test for the identity. + | otherwise = (recomputeInScopeSets $ mergeScope sUse sRen, (nameClashes, moduleClashes)) where - usedOrHidden = useOrHide (hideLHS (impRenaming dir) $ usingOrHiding dir) s - renamed = rename (impRenaming dir) $ useOrHide useRenamedThings s + -- | Names kept via using/hiding. + sUse :: Scope + sUse = useOrHide (usingOrHiding dir) s - useRenamedThings = Left $ Using $ map renFrom $ impRenaming dir + -- | Things kept (under a different name) via renaming. + sRen :: Scope + sRen = rename impRenaming s - hideLHS :: [C.Renaming] -> UsingOrHiding -> UsingOrHiding - hideLHS _ i@(Left _) = i - hideLHS ren (Right xs) = Right $ xs ++ map renFrom ren + -- | Which names are considered to be defined by a module? + -- The ones actually defined there publicly ('publicNS') + -- and the ones imported publicly ('ImportedNS')? + exportedNSs = [PublicNS, ImportedNS] + -- | Name clashes introduced by the @renaming@ clause. + nameClashes :: Set C.Name + nameClashes = Map.keysSet rNames `Set.intersection` Map.keysSet uNames + -- NB: `intersection` returns a subset of the first argument. + -- To get the correct error location, i.e., in the @renaming@ clause + -- rather than at the definition location, we neet to return + -- names from the @renaming@ clause. (Issue #4154.) + where + uNames, rNames :: NamesInScope + uNames = namesInScope exportedNSs sUse + rNames = namesInScope exportedNSs sRen + + -- | Module name clashes introduced by the @renaming@ clause. + + -- Note: need to cut and paste because of 'InScope' dependent types trickery. + moduleClashes :: Set C.Name + moduleClashes = Map.keysSet uModules `Set.intersection` Map.keysSet rModules + where + uModules, rModules :: ModulesInScope + uModules = namesInScope exportedNSs sUse + rModules = namesInScope exportedNSs sRen + + + -- Restrict scope by directive. useOrHide :: UsingOrHiding -> Scope -> Scope - useOrHide (Right xs) s = filterNames notElem notElem xs s - useOrHide (Left (Using xs)) s = filterNames elem elem xs s - useOrHide _ _ = __IMPOSSIBLE__ + useOrHide (UsingOnly xs) = filterNames Set.member xs + -- Filter scope, keeping only xs. + useOrHide (HidingOnly xs) = filterNames Set.notMember $ map renFrom impRenaming ++ xs + -- Filter out xs and the to be renamed names from scope. - filterNames :: (C.Name -> [C.Name] -> Bool) -> - (C.Name -> [C.Name] -> Bool) -> - [C.ImportedName] -> Scope -> Scope - filterNames pd pm xs = filterScope (`pd` ds) (`pm` ms) + -- Filter scope by (`rel` xs). + -- O(n * log (length xs)). + filterNames :: (C.Name -> Set C.Name -> Bool) -> [C.ImportedName] -> + Scope -> Scope + filterNames rel xs = filterScope (`rel` Set.fromList ds) (`rel` Set.fromList ms) where - ds = [ x | ImportedName x <- xs ] - ms = [ m | ImportedModule m <- xs ] + (ds, ms) = partitionEithers $ for xs $ \case + ImportedName x -> Left x + ImportedModule m -> Right m - -- Renaming + -- Apply a renaming to a scope. + -- O(n * (log n + log (length rho))). rename :: [C.Renaming] -> Scope -> Scope - rename rho = mapScope_ (Map.mapKeys $ ren drho) - (Map.mapKeys $ ren mrho) + rename rho = mapScope_ (updateFxs . + updateThingsInScope (AssocList.apply drho)) + (updateThingsInScope (AssocList.apply mrho)) id where (drho, mrho) = partitionEithers $ for rho $ \case - Renaming (ImportedName x) (ImportedName y) _ -> Left (x,y) - Renaming (ImportedModule x) (ImportedModule y) _ -> Right (x,y) + Renaming (ImportedName x) (ImportedName y) _fx _ -> Left (x, y) + Renaming (ImportedModule x) (ImportedModule y) _fx _ -> Right (x, y) _ -> __IMPOSSIBLE__ - ren r x = fromMaybe x $ lookup x r + fixities :: AssocList C.Name Fixity + fixities = (`mapMaybe` rho) $ \case + Renaming _ (ImportedName y) (Just fx) _ -> Just (y, fx) + _ -> Nothing + -- Update fixities of abstract names targeted by renamed imported identifies. + updateFxs :: NamesInScope -> NamesInScope + updateFxs m = foldl upd m fixities + where + -- Update fixity of all abstract names targeted by concrete name y. + upd m (y, fx) = Map.adjust (map $ set lensFixity fx) y m + + updateThingsInScope + :: forall a. SetBindingSite a + => (C.Name -> Maybe C.Name) + -> ThingsInScope a -> ThingsInScope a + updateThingsInScope f = Map.fromList . mapMaybe upd . Map.toAscList + where + upd :: (C.Name, [a]) -> Maybe (C.Name, [a]) + upd (x, ys) = f x <&> \ x' -> (x', setBindingSite (getRange x') ys) + -- | Rename the abstract names in a scope. renameCanonicalNames :: Map A.QName A.QName -> Map A.ModuleName A.ModuleName -> Scope -> Scope @@ -686,16 +865,14 @@ -- | Remove private things from the given module from a scope. restrictLocalPrivate :: ModuleName -> Scope -> Scope -restrictLocalPrivate m = mapScope' PrivateNS (Map.mapMaybe rName) (Map.mapMaybe rMod) - (Set.filter (not . (`isInModule` m))) +restrictLocalPrivate m = + mapScopeNS PrivateNS + (Map.mapMaybe rName) + (Map.mapMaybe rMod) + (Set.filter (not . (`isInModule` m))) where - check p x = x <$ guard (p x) - rName as = check (not . null) $ filter (not . (`isInModule` m) . anameName) as - rMod as = check (not . null) $ filter (not . (`isSubModuleOf` m) . amodName) as - --- | Remove names that can only be used qualified (when opening a scope) -removeOnlyQualified :: Scope -> Scope -removeOnlyQualified s = setNameSpace OnlyQualifiedNS emptyNameSpace s + rName as = filterMaybe (not . null) $ filter (not . (`isInModule` m) . anameName) as + rMod as = filterMaybe (not . null) $ filter (not . (`isLtChildModuleOf` m) . amodName) as -- | Disallow using generalized variables from the scope disallowGeneralizedVars :: Scope -> Scope @@ -717,8 +894,8 @@ publicModules scope = Map.filterWithKey (\ m _ -> reachable m) allMods where -- Get all modules in the ScopeInfo. - allMods = Map.map restrictPrivate $ scopeModules scope - root = scopeCurrent scope + allMods = Map.map restrictPrivate $ scope ^. scopeModules + root = scope ^. scopeCurrent modules s = map amodName $ concat $ Map.elems $ allNamesInScope s @@ -736,17 +913,17 @@ everythingInScope scope = allThingsInScope $ mergeScopes $ (s0 :) $ map look $ scopeParents s0 where - look m = fromMaybe __IMPOSSIBLE__ $ Map.lookup m $ scopeModules scope - s0 = look $ scopeCurrent scope + look m = fromMaybe __IMPOSSIBLE__ $ Map.lookup m $ scope ^. scopeModules + s0 = look $ scope ^. scopeCurrent everythingInScopeQualified :: ScopeInfo -> NameSpace everythingInScopeQualified scope = allThingsInScope $ mergeScopes $ chase Set.empty scopes where - s0 = look $ scopeCurrent scope + s0 = look $ scope ^. scopeCurrent scopes = s0 : map look (scopeParents s0) - look m = fromMaybe __IMPOSSIBLE__ $ Map.lookup m $ scopeModules scope + look m = fromMaybe __IMPOSSIBLE__ $ Map.lookup m $ scope ^. scopeModules lookP = restrictPrivate . look -- We start with the current module and all its parents and look through @@ -768,7 +945,7 @@ (build ms allNamesInScope root) imported where - current = moduleScope $ scopeCurrent scope + current = moduleScope $ scope ^. scopeCurrent root = mergeScopes $ current : map moduleScope (scopeParents current) imported = Map.unionsWith (++) @@ -793,17 +970,17 @@ , AbsModule m _ <- mods ] moduleScope :: A.ModuleName -> Scope - moduleScope m = fromMaybe __IMPOSSIBLE__ $ Map.lookup m $ scopeModules scope + moduleScope m = fromMaybe __IMPOSSIBLE__ $ Map.lookup m $ scope ^. scopeModules -- | Get all concrete names in scope. Includes bound variables. concreteNamesInScope :: ScopeInfo -> Set C.QName concreteNamesInScope scope = Set.unions [ build allNamesInScope root, imported, locals ] where - current = moduleScope $ scopeCurrent scope + current = moduleScope $ scope ^. scopeCurrent root = mergeScopes $ current : map moduleScope (scopeParents current) - locals = Set.fromList [ C.QName x | (x, _) <- scopeLocals scope ] + locals = Set.fromList [ C.QName x | (x, _) <- scope ^. scopeLocals ] imported = Set.unions [ qual c (build exportedNamesInScope $ moduleScope a) @@ -823,7 +1000,7 @@ , AbsModule m _ <- mods ] moduleScope :: A.ModuleName -> Scope - moduleScope m = fromMaybe __IMPOSSIBLE__ $ Map.lookup m $ scopeModules scope + moduleScope m = fromMaybe __IMPOSSIBLE__ $ Map.lookup m $ scope ^. scopeModules -- | Look up a name in the scope scopeLookup :: InScope a => C.QName -> ScopeInfo -> [a] @@ -831,17 +1008,17 @@ scopeLookup' :: forall a. InScope a => C.QName -> ScopeInfo -> [(a, Access)] scopeLookup' q scope = - List.nubBy ((==) `on` fst) $ + nubOn fst $ findName q root ++ maybeToList topImports ++ imports where -- 1. Finding a name in the current scope and its parents. moduleScope :: A.ModuleName -> Scope - moduleScope m = fromMaybe __IMPOSSIBLE__ $ Map.lookup m $ scopeModules scope + moduleScope m = fromMaybe __IMPOSSIBLE__ $ Map.lookup m $ scope ^. scopeModules current :: Scope - current = moduleScope $ scopeCurrent scope + current = moduleScope $ scope ^. scopeCurrent root :: Scope root = mergeScopes $ current : map moduleScope (scopeParents current) @@ -868,7 +1045,7 @@ -- trace ("mods ++ defs = " ++ show (mods ++ defs)) $ do -- m <- nub $ mods ++ defs -- record types will appear both as a mod and a def -- Get the scope of module m, if any, and remove its private definitions. - let ss = Map.lookup m $ scopeModules scope + let ss = Map.lookup m $ scope ^. scopeModules ss' = restrictPrivate <$> ss -- trace ("ss = " ++ show ss ) $ do -- trace ("ss' = " ++ show ss') $ do @@ -918,7 +1095,7 @@ isNameInScope :: A.QName -> ScopeInfo -> Bool isNameInScope q scope = billToPure [ Scoping, InverseScopeLookup ] $ - Set.member q (scopeInScope scope) + Set.member q (scope ^. scopeInScope) -- | Find the concrete names that map (uniquely) to a given abstract name. -- Sort by length, shortest first. @@ -932,8 +1109,8 @@ Left m -> best $ filter unambiguousModule $ findModule m Right q -> best $ filter unambiguousName $ findName q where - findName x = maybe [] toList $ Map.lookup x (scopeInverseName scope) - findModule x = fromMaybe [] $ Map.lookup x (scopeInverseModule scope) + findName x = maybe [] NonEmpty.toList $ Map.lookup x (scope ^. scopeInverseName) + findModule x = fromMaybe [] $ Map.lookup x (scope ^. scopeInverseModule) len :: C.QName -> Int len (C.QName _) = 1 @@ -956,17 +1133,17 @@ recomputeInverseScopeMaps :: ScopeInfo -> ScopeInfo recomputeInverseScopeMaps scope = billToPure [ Scoping , InverseScopeLookup ] $ - scope { scopeInverseName = nameMap - , scopeInverseModule = Map.fromList [ (x, findModule x) | x <- Map.keys moduleMap ++ Map.keys importMap ] - , scopeInScope = nsInScope $ everythingInScopeQualified scope + scope { _scopeInverseName = nameMap + , _scopeInverseModule = Map.fromList [ (x, findModule x) | x <- Map.keys moduleMap ++ Map.keys importMap ] + , _scopeInScope = nsInScope $ everythingInScopeQualified scope } where - this = scopeCurrent scope + this = scope ^. scopeCurrent current = this : scopeParents (moduleScope this) - scopes = [ (m, restrict m s) | (m, s) <- Map.toList (scopeModules scope) ] + scopes = [ (m, restrict m s) | (m, s) <- Map.toList (scope ^. scopeModules) ] moduleScope :: A.ModuleName -> Scope - moduleScope m = fromMaybe __IMPOSSIBLE__ $ Map.lookup m $ scopeModules scope + moduleScope m = fromMaybe __IMPOSSIBLE__ $ Map.lookup m $ scope ^. scopeModules restrict m s | m `elem` current = s | otherwise = restrictPrivate s @@ -1010,7 +1187,7 @@ (m, s) <- scopes (x, ms) <- Map.toList (allNamesInScope s) q <- anameName <$> ms - if elem m current + if m `elem` current then return (q, singleton (C.QName x)) else do y <- findModule m @@ -1032,6 +1209,38 @@ inverseScopeLookupModule x = inverseScopeLookup (Left x) ------------------------------------------------------------------------ +-- * Update binding site +------------------------------------------------------------------------ + +-- | Set the 'nameBindingSite' in an abstract name. +class SetBindingSite a where + setBindingSite :: Range -> a -> a + + default setBindingSite + :: (SetBindingSite b, Functor t, t b ~ a) + => Range -> a -> a + setBindingSite = fmap . setBindingSite + +instance SetBindingSite a => SetBindingSite [a] + +instance SetBindingSite A.Name where + setBindingSite r x = x { nameBindingSite = r } + +instance SetBindingSite A.QName where + setBindingSite r x = x { qnameName = setBindingSite r $ qnameName x } + +-- | Sets the binding site of all names in the path. +instance SetBindingSite A.ModuleName where + setBindingSite r (MName x) = MName $ setBindingSite r x + +instance SetBindingSite AbstractName where + setBindingSite r x = x { anameName = setBindingSite r $ anameName x } + +instance SetBindingSite AbstractModule where + setBindingSite r x = x { amodName = setBindingSite r $ amodName x } + + +------------------------------------------------------------------------ -- * (Debug) printing ------------------------------------------------------------------------ @@ -1046,7 +1255,6 @@ PublicNS -> "public" PrivateNS -> "private" ImportedNS -> "imported" - OnlyQualifiedNS -> "only-qualified" instance Pretty NameSpace where pretty = vcat . prettyNameSpace @@ -1063,8 +1271,8 @@ pretty (scope@Scope{ scopeName = name, scopeParents = parents, scopeImports = imps }) = vcat $ [ "scope" <+> pretty name ] ++ ind ( - concat [ blockOfLines (pretty nsid) $ prettyNameSpace $ scopeNameSpace nsid scope - | nsid <- [minBound..maxBound] ] + concat [ blockOfLines (pretty nsid) $ prettyNameSpace ns + | (nsid, ns) <- scopeNameSpaces scope ] ++ blockOfLines "imports" (case Map.keys imps of [] -> []; ks -> [ prettyList ks ]) ) diff --git a/src/full/Agda/Syntax/Scope/Monad.hs b/src/full/Agda/Syntax/Scope/Monad.hs --- a/src/full/Agda/Syntax/Scope/Monad.hs +++ b/src/full/Agda/Syntax/Scope/Monad.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE NondecreasingIndentation #-} {-| The scope monad with operations. @@ -6,69 +5,67 @@ module Agda.Syntax.Scope.Monad where -import Prelude hiding (mapM, any, all) -import Control.Arrow (first, second, (***), (&&&)) +import Prelude hiding (mapM, any, all, null) + +import Control.Arrow ((***)) import Control.Monad hiding (mapM, forM) import Control.Monad.Writer hiding (mapM, forM) import Control.Monad.State hiding (mapM, forM) import Data.Either ( partitionEithers ) import qualified Data.List as List +import Data.List.NonEmpty (NonEmpty(..), nonEmpty) +import qualified Data.List.NonEmpty as NonEmpty import Data.Map (Map) import qualified Data.Map as Map import Data.Maybe import Data.Set (Set) import qualified Data.Set as Set -import Data.Foldable (any, all) +import Data.Foldable (all) import Data.Traversable hiding (for) +import Agda.Interaction.Options +import Agda.Interaction.Options.Warnings + import Agda.Syntax.Common import Agda.Syntax.Position import Agda.Syntax.Fixity +import Agda.Syntax.Notation import Agda.Syntax.Abstract.Name as A import qualified Agda.Syntax.Abstract as A -import Agda.Syntax.Abstract (ScopeCopyInfo(..), initCopyInfo) +import Agda.Syntax.Abstract (ScopeCopyInfo(..)) import Agda.Syntax.Concrete as C import Agda.Syntax.Concrete.Fixity import Agda.Syntax.Concrete.Definitions (DeclarationWarning(..)) -- TODO: move the relevant warnings out of there -import Agda.Syntax.Scope.Base +import Agda.Syntax.Scope.Base as A import Agda.TypeChecking.Monad.Base import Agda.TypeChecking.Monad.Debug -import Agda.TypeChecking.Monad.Options import Agda.TypeChecking.Monad.State -import Agda.TypeChecking.Monad.Trace ( setCurrentRange ) +import Agda.TypeChecking.Monad.Trace import Agda.TypeChecking.Positivity.Occurrence (Occurrence) import Agda.TypeChecking.Warnings ( warning ) import qualified Agda.Utils.AssocList as AssocList -import Agda.Utils.Function +import Agda.Utils.Except import Agda.Utils.Functor +import Agda.Utils.Lens import Agda.Utils.List import Agda.Utils.Maybe import Agda.Utils.Monad -import Agda.Utils.Null (unlessNull) -import Agda.Utils.NonemptyList +import Agda.Utils.Null import Agda.Utils.Pretty -import Agda.Utils.Size -import Agda.Utils.Tuple -#include "undefined.h" import Agda.Utils.Impossible +--------------------------------------------------------------------------- -- * The scope checking monad +--------------------------------------------------------------------------- -- | To simplify interaction between scope checking and type checking (in -- particular when chasing imports), we use the same monad. type ScopeM = TCM --- * Errors - -isDatatypeModule :: A.ModuleName -> ScopeM (Maybe DataOrRecord) -isDatatypeModule m = do - scopeDatatypeModule . Map.findWithDefault __IMPOSSIBLE__ m . scopeModules <$> getScope - - -- Debugging printLocals :: Int -> String -> ScopeM () @@ -76,16 +73,21 @@ locals <- getLocalVars reportSLn "scope.top" v $ s ++ " " ++ prettyShow locals - +--------------------------------------------------------------------------- -- * General operations +--------------------------------------------------------------------------- -getCurrentModule :: ScopeM A.ModuleName -getCurrentModule = setRange noRange . scopeCurrent <$> getScope +isDatatypeModule :: ReadTCState m => A.ModuleName -> m (Maybe DataOrRecord) +isDatatypeModule m = do + scopeDatatypeModule . Map.findWithDefault __IMPOSSIBLE__ m <$> useScope scopeModules -setCurrentModule :: A.ModuleName -> ScopeM () -setCurrentModule m = modifyScope $ \s -> s { scopeCurrent = m } +getCurrentModule :: ReadTCState m => m A.ModuleName +getCurrentModule = setRange noRange <$> useScope scopeCurrent -withCurrentModule :: A.ModuleName -> ScopeM a -> ScopeM a +setCurrentModule :: MonadTCState m => A.ModuleName -> m () +setCurrentModule m = modifyScope $ set scopeCurrent m + +withCurrentModule :: (ReadTCState m, MonadTCState m) => A.ModuleName -> m a -> m a withCurrentModule new action = do old <- getCurrentModule setCurrentModule new @@ -104,7 +106,7 @@ getNamedScope :: A.ModuleName -> ScopeM Scope getNamedScope m = do scope <- getScope - case Map.lookup m (scopeModules scope) of + case Map.lookup m (scope ^. scopeModules) of Just s -> return s Nothing -> do reportSLn "" 0 $ "ERROR: In scope\n" ++ prettyShow scope ++ "\nNO SUCH SCOPE " ++ prettyShow m @@ -129,7 +131,7 @@ -- | Apply a function to the scope map. modifyScopes :: (Map A.ModuleName Scope -> Map A.ModuleName Scope) -> ScopeM () -modifyScopes f = modifyScope $ \s -> s { scopeModules = f $ scopeModules s } +modifyScopes = modifyScope . over scopeModules -- | Apply a function to the given scope. modifyNamedScope :: A.ModuleName -> (Scope -> Scope) -> ScopeM () @@ -157,20 +159,15 @@ modifyCurrentNameSpace acc f = modifyCurrentScope $ updateScopeNameSpaces $ AssocList.updateAt acc f -pushContextPrecedence :: Precedence -> ScopeM PrecedenceStack -pushContextPrecedence p = do - old <- scopePrecedence <$> getScope - modifyScope_ $ \ s -> s { scopePrecedence = pushPrecedence p $ scopePrecedence s } - return old - setContextPrecedence :: PrecedenceStack -> ScopeM () -setContextPrecedence ps = modifyScope_ $ \ s -> s { scopePrecedence = ps } +setContextPrecedence = modifyScope_ . set scopePrecedence -withContextPrecedence :: Precedence -> ScopeM a -> ScopeM a -withContextPrecedence p = bracket_ (pushContextPrecedence p) setContextPrecedence +withContextPrecedence :: ReadTCState m => Precedence -> m a -> m a +withContextPrecedence p = + locallyTCState (stScope . scopePrecedence) $ pushPrecedence p -getLocalVars :: ScopeM LocalVars -getLocalVars = scopeLocals <$> getScope +getLocalVars :: ReadTCState m => m LocalVars +getLocalVars = useScope scopeLocals modifyLocalVars :: (LocalVars -> LocalVars) -> ScopeM () modifyLocalVars = modifyScope_ . updateScopeLocals @@ -182,8 +179,50 @@ withLocalVars :: ScopeM a -> ScopeM a withLocalVars = bracket_ getLocalVars setLocalVars +-- | Run a computation outside some number of local variables and add them back afterwards. This +-- lets you bind variables in the middle of the context and is used when binding generalizable +-- variables (#3735). +outsideLocalVars :: Int -> ScopeM a -> ScopeM a +outsideLocalVars n m = do + inner <- take n <$> getLocalVars + modifyLocalVars (drop n) + x <- m + modifyLocalVars (inner ++) + return x + +-- | Check that the newly added variable have unique names. + +withCheckNoShadowing :: ScopeM a -> ScopeM a +withCheckNoShadowing = bracket_ getLocalVars $ \ lvarsOld -> + checkNoShadowing lvarsOld =<< getLocalVars + +checkNoShadowing :: LocalVars -- ^ Old local scope + -> LocalVars -- ^ New local scope + -> ScopeM () +checkNoShadowing old new = do + opts <- pragmaOptions + when (ShadowingInTelescope_ `Set.member` + (optWarningMode opts ^. warningSet)) $ do + -- LocalVars is currnently an AssocList so the difference between + -- two local scope is the left part of the new one. + let diff = dropEnd (length old) new + -- Filter out the underscores. + let newNames = filter (not . isNoName) $ AssocList.keys diff + -- Associate each name to its occurrences. + let nameOccs = Map.toList $ Map.fromListWith (++) $ map pairWithRange newNames + -- Warn if we have two or more occurrences of the same name. + unlessNull (filter (atLeastTwo . snd) nameOccs) $ \ conflicts -> do + warning $ NicifierIssue $ ShadowingInTelescope conflicts + where + pairWithRange :: C.Name -> (C.Name, [Range]) + pairWithRange n = (n, [getRange n]) + + atLeastTwo :: [a] -> Bool + atLeastTwo (_ : _ : _) = True + atLeastTwo _ = False + getVarsToBind :: ScopeM LocalVars -getVarsToBind = scopeVarsToBind <$> getScope +getVarsToBind = useScope scopeVarsToBind addVarToBind :: C.Name -> LocalVar -> ScopeM () addVarToBind x y = modifyScope_ $ updateVarsToBind $ AssocList.insert x y @@ -197,7 +236,9 @@ printLocals 10 "bound variables:" modifyScope_ $ setVarsToBind [] +--------------------------------------------------------------------------- -- * Names +--------------------------------------------------------------------------- -- | Create a fresh abstract name from a concrete name. -- @@ -231,7 +272,18 @@ fx <- getConcreteFixity x freshAbstractQName fx x +-- | Create a concrete name that is not yet in scope. +freshConcreteName :: Range -> Int -> String -> ScopeM C.Name +freshConcreteName r i s = do + let cname = C.Name r C.NotInScope [Id $ stringToRawName $ s ++ show i] + rn <- resolveName $ C.QName cname + case rn of + UnknownName -> return cname + _ -> freshConcreteName r (i+1) s + +--------------------------------------------------------------------------- -- * Resolving names +--------------------------------------------------------------------------- -- | Look up the abstract name referred to by a given concrete name. resolveName :: C.QName -> ScopeM ResolvedName @@ -244,31 +296,34 @@ -- Then, we can ignore conflicting definitions of that name -- of a different kind. (See issue 822.) resolveName' :: - [KindOfName] -> Maybe (Set A.Name) -> C.QName -> ScopeM ResolvedName -resolveName' kinds names x = do + KindsOfNames -> Maybe (Set A.Name) -> C.QName -> ScopeM ResolvedName +resolveName' kinds names x = runExceptT (tryResolveName kinds names x) >>= \case + Left ys -> traceCall (SetRange $ getRange x) $ typeError $ AmbiguousName x ys + Right x' -> return x' + +tryResolveName + :: (ReadTCState m, MonadError (NonEmpty A.QName) m) + => KindsOfNames -- ^ Restrict search to these kinds of names. + -> Maybe (Set A.Name) -- ^ Unless 'Nothing', restrict search to match any of these names. + -> C.QName -- ^ Name to be resolved + -> m ResolvedName -- ^ If illegally ambiguous, throw error with the ambiguous name. +tryResolveName kinds names x = do scope <- getScope - let vars = AssocList.mapKeysMonotonic C.QName $ scopeLocals scope - retVar y = return . VarName y{ nameConcrete = unqualify x } - aName = A.qnameName . anameName + let vars = AssocList.mapKeysMonotonic C.QName $ scope ^. scopeLocals case lookup x vars of - -- Case: we have a local variable x. - Just (LocalVar y b []) -> retVar y b - -- Case: ... but is (perhaps) shadowed by some imports. - Just (LocalVar y b ys) -> case names of - Nothing -> shadowed ys - Just ns -> case filter (\ y -> aName y `Set.member` ns) ys of - [] -> retVar y b - ys -> shadowed ys - where - shadowed ys = - typeError $ AmbiguousName x $ A.qualify_ y :! map anameName ys + -- Case: we have a local variable x, but is (perhaps) shadowed by some imports ys. + Just (LocalVar y b ys) -> + -- We may ignore the imports filtered out by the @names@ filter. + ifNull (filterNames id ys) + {-then-} (return $ VarName y{ nameConcrete = unqualify x } b) + {-else-} $ \ ys' -> + throwError $ A.qualify_ y :| map anameName ys' -- Case: we do not have a local variable x. Nothing -> do -- Consider only names of one of the given kinds - let filtKind = filter $ \ y -> anameKind (fst y) `elem` kinds + let filtKind = filter $ (`elemKindsOfNames` kinds) . anameKind . fst -- Consider only names in the given set of names - filtName = filter $ \ y -> maybe True (Set.member (aName (fst y))) names - caseListNe (filtKind $ filtName $ scopeLookup' x scope) (return UnknownName) $ \ case + caseMaybe (nonEmpty $ filtKind $ filterNames fst $ scopeLookup' x scope) (return UnknownName) $ \ case ds | all ((ConName ==) . anameKind . fst) ds -> return $ ConstructorName $ fmap (upd . fst) ds @@ -278,11 +333,19 @@ ds | all ((PatternSynName ==) . anameKind . fst) ds -> return $ PatternSynResName $ fmap (upd . fst) ds - (d, a) :! [] -> + (d, a) :| [] -> return $ DefinedName a $ upd d - ds -> typeError $ AmbiguousName x (fmap (anameName . fst) ds) + ds -> throwError $ fmap (anameName . fst) ds where + -- @names@ intended semantics: a filter on names. + -- @Nothing@: don't filter out anything. + -- @Just ns@: filter by membership in @ns@. + filterNames :: forall a. (a -> AbstractName) -> [a] -> [a] + filterNames = case names of + Nothing -> \ f -> id + Just ns -> \ f -> filter $ (`Set.member` ns) . A.qnameName . anameName . f + -- lambda-dropped style by intention upd d = updateConcreteName d $ unqualify x updateConcreteName :: AbstractName -> C.Name -> AbstractName updateConcreteName d@(AbsName { anameName = A.QName qm qn }) x = @@ -292,17 +355,17 @@ resolveModule :: C.QName -> ScopeM AbstractModule resolveModule x = do ms <- scopeLookup x <$> getScope - caseListNe ms (typeError $ NoSuchModule x) $ \ case - AbsModule m why :! [] -> return $ AbsModule (m `withRangeOf` x) why + caseMaybe (nonEmpty ms) (typeError $ NoSuchModule x) $ \ case + AbsModule m why :| [] -> return $ AbsModule (m `withRangeOf` x) why ms -> typeError $ AmbiguousModule x (fmap amodName ms) -- | Get the fixity of a not yet bound name. getConcreteFixity :: C.Name -> ScopeM Fixity' -getConcreteFixity x = Map.findWithDefault noFixity' x . scopeFixities <$> getScope +getConcreteFixity x = Map.findWithDefault noFixity' x <$> useScope scopeFixities -- | Get the polarities of a not yet bound name. getConcretePolarity :: C.Name -> ScopeM (Maybe [Occurrence]) -getConcretePolarity x = Map.lookup x . scopePolarities <$> getScope +getConcretePolarity x = Map.lookup x <$> useScope scopePolarities instance MonadFixityError ScopeM where throwMultipleFixityDecls xs = case xs of @@ -319,13 +382,14 @@ -- | Collect the fixity/syntax declarations and polarity pragmas from the list -- of declarations and store them in the scope. computeFixitiesAndPolarities :: DoWarn -> [C.Declaration] -> ScopeM a -> ScopeM a -computeFixitiesAndPolarities warn ds ret = do - (fixs0, pols0) <- (scopeFixities &&& scopePolarities) <$> getScope - (fixs, pols) <- fixitiesAndPolarities warn ds - modifyScope $ \ s -> s { scopeFixities = fixs, scopePolarities = pols } - x <- ret - modifyScope $ \ s -> s { scopeFixities = fixs0, scopePolarities = pols0 } - return x +computeFixitiesAndPolarities warn ds cont = do + fp <- fixitiesAndPolarities warn ds + -- Andreas, 2019-08-16: + -- Since changing fixities and polarities does not affect the name sets, + -- we do not need to invoke @modifyScope@ here + -- (which does @recomputeInverseScopeMaps@). + -- A simple @locallyScope@ is sufficient. + locallyScope scopeFixitiesAndPolarities (const fp) cont -- | Get the notation of a name. The name is assumed to be in scope. getNotation @@ -345,17 +409,19 @@ where notation = namesToNotation x . qnameName . anameName oneNotation ds = - case mergeNotations $ map notation $ toList ds of + case mergeNotations $ map notation $ NonEmpty.toList ds of [n] -> n _ -> __IMPOSSIBLE__ +--------------------------------------------------------------------------- -- * Binding names +--------------------------------------------------------------------------- -- | Bind a variable. bindVariable - :: Binder -- ^ @λ@, @Π@, @let@, ...? - -> C.Name -- ^ Concrete name. - -> A.Name -- ^ Abstract name. + :: A.BindingSource -- ^ @λ@, @Π@, @let@, ...? + -> C.Name -- ^ Concrete name. + -> A.Name -- ^ Abstract name. -> ScopeM () bindVariable b x y = modifyLocalVars $ AssocList.insert x $ LocalVar y b [] @@ -371,7 +437,7 @@ bindName' acc kind meta x y = do when (isNoName x) $ modifyScopes $ Map.map $ removeNameFromScope PrivateNS x r <- resolveName (C.QName x) - ys <- case r of + y' <- case r of -- Binding an anonymous declaration always succeeds. -- In case it's not the first one, we simply remove the one that came before _ | isNoName x -> success @@ -382,14 +448,14 @@ PatternSynResName n -> ambiguous PatternSynName n UnknownName -> success let ns = if isNoName x then PrivateNS else localNameSpace acc - modifyCurrentScope $ addNamesToScope ns x ys + modifyCurrentScope $ addNameToScope ns x y' where - success = return [ AbsName y kind Defined meta ] + success = return $ AbsName y kind Defined meta clash = typeError . ClashingDefinition (C.QName x) ambiguous k ds = if kind == k && all ((== k) . anameKind) ds - then success else clash $ anameName (headNe ds) + then success else clash $ anameName (NonEmpty.head ds) -- | Rebind a name. Use with care! -- Ulf, 2014-06-29: Currently used to rebind the name defined by an @@ -410,7 +476,9 @@ bindQModule acc q m = modifyCurrentScope $ \s -> s { scopeImports = Map.insert q m (scopeImports s) } +--------------------------------------------------------------------------- -- * Module manipulation operations +--------------------------------------------------------------------------- -- | Clear the scope of any no names. stripNoNames :: ScopeM () @@ -534,8 +602,7 @@ -- Ulf (issue 1985): If copying a reexported module we put it at the -- top-level, to make sure we don't mess up the invariant that all -- (abstract) names M.f share the argument telescope of M. - let newM | x `isSubModuleOf` old = newL - | otherwise = mnameToList new0 + let newM = if x `isLtChildModuleOf` old then newL else mnameToList new0 y <- do -- Andreas, Jesper, 2015-07-02: Issue 1597 @@ -564,49 +631,85 @@ s <- withCurrentModule' y $ copy y s0 lift $ modifyNamedScope y (const s) +--------------------------------------------------------------------------- +-- * Import directives +--------------------------------------------------------------------------- + +-- | Warn about useless fixity declarations in @renaming@ directives. +checkNoFixityInRenamingModule :: [C.Renaming] -> ScopeM () +checkNoFixityInRenamingModule ren = do + whenJust (nonEmpty $ mapMaybe rangeOfUselessInfix ren) $ \ rs -> do + traceCall (SetRange $ getRange rs) $ do + warning $ FixityInRenamingModule rs + where + rangeOfUselessInfix :: C.Renaming -> Maybe Range + rangeOfUselessInfix = \case + Renaming ImportedModule{} _ mfx _ -> getRange <$> mfx + _ -> Nothing + -- | Apply an import directive and check that all the names mentioned actually -- exist. -applyImportDirectiveM :: C.QName -> C.ImportDirective -> Scope -> ScopeM (A.ImportDirective, Scope) +applyImportDirectiveM + :: C.QName -- ^ Name of the scope, only for error reporting. + -> C.ImportDirective -- ^ Description of how scope is to be modified. + -> Scope -- ^ Input scope. + -> ScopeM (A.ImportDirective, Scope) -- ^ Scope-checked description, output scope. applyImportDirectiveM m (ImportDirective rng usn' hdn' ren' public) scope = do - -- We start by checking that all of the names talked about in the import - -- directive do exist. If some do not then we remove them and raise a warning. + -- Modules names do not come with fixities, thus, we should complain if the + -- user supplied fixity annotations to renaming-module clauses. + checkNoFixityInRenamingModule ren' - let (missingExports, namesA) = checkExist $ fromUsing usn' ++ hdn' ++ map renFrom ren' + -- We start by checking that all of the names talked about in the import + -- directive do exist. If some do not then we remove them and raise a warning. + let usingList = fromUsing usn' + let (missingExports, namesA) = checkExist $ usingList ++ hdn' ++ map renFrom ren' unless (null missingExports) $ setCurrentRange rng $ do reportSLn "scope.import.apply" 20 $ "non existing names: " ++ prettyShow missingExports warning $ ModuleDoesntExport m missingExports - -- We can now define a cleaned-up version of the input - let usn = fromUsing usn' List.\\ missingExports - let hdn = hdn' List.\\ missingExports - let ren = filter (\ r -> renFrom r `notElem` missingExports) ren' - let dir = (\ u -> ImportDirective rng u hdn ren public) - $ case usn' of { Using{} -> Using usn; _ -> UseEverything } + -- We can now define a cleaned-up version of the import directive. + let notMissing = not . (missingExports `hasElem`) -- #3997, efficient lookup in missingExports + let usn = filter notMissing usingList -- remove missingExports from usn' + let hdn = filter notMissing hdn' -- remove missingExports from hdn' + let ren = filter (notMissing . renFrom) ren' -- and from ren' + let dir = ImportDirective rng (mapUsing (const usn) usn') hdn ren public - -- As well as convenient shorthands for defined names and names brought into scope - let names = map renFrom ren ++ hdn ++ usn + -- Convenient shorthands for defined names and names brought into scope: + let names = map renFrom ren ++ hdn ++ usn let definedNames = map renTo ren - let targetNames = usn ++ definedNames + let targetNames = usn ++ definedNames - let extraModules = - [ x | ImportedName x <- names - , let mx = ImportedModule x - , notElem mx missingExports - , notElem mx names - ] - dir' = addExtraModules extraModules dir + -- Efficient test of (`elem` names): + let inNames = (names `hasElem`) - dir' <- sanityCheck dir' names + -- Efficient test of whether a module import should be added to the import + -- of a definition (like a data or record definition). + let extra x = and + [ inNames $ ImportedName x + , notMissing $ ImportedModule x + , not . inNames $ ImportedModule x + -- The last test implies that @hiding (module M)@ prevents @module M@ + -- from entering the @using@ list in @addExtraModule@. + ] + dir' <- sanityCheck (not . inNames) $ addExtraModules extra dir + -- Check for duplicate imports in a single import directive. -- @dup@ : To be imported names that are mentioned more than once. - let dup = targetNames List.\\ List.nub targetNames - unless (null dup) $ typeError $ DuplicateImports m dup + unlessNull (allDuplicates targetNames) $ \ dup -> + typeError $ DuplicateImports m dup -- Apply the import directive. - let scope' = applyImportDirective dir' scope + let (scope', (nameClashes, moduleClashes)) = applyImportDirective_ dir' scope + -- Andreas, 2019-11-08, issue #4154, report clashes + -- introduced by the @renaming@. + unless (null nameClashes) $ + warning $ ClashesViaRenaming NameNotModule $ Set.toList nameClashes + unless (null moduleClashes) $ + warning $ ClashesViaRenaming ModuleNotName $ Set.toList moduleClashes + -- Look up the defined names in the new scope. let namesInScope' = (allNamesInScope scope' :: ThingsInScope AbstractName) let modulesInScope' = (allNamesInScope scope' :: ThingsInScope AbstractModule) @@ -623,38 +726,42 @@ where -- | Names in the @using@ directive fromUsing :: Using' a b -> [ImportedName' a b] - fromUsing u = case u of + fromUsing = \case Using xs -> xs UseEverything -> [] - sanityCheck dir names = - case (using dir, hiding dir) of - (Using xs, ys) -> do - let uselessHiding = [ x | x@ImportedName{} <- ys ] ++ - [ x | x@(ImportedModule y) <- ys, ImportedName y `notElem` names ] - unless (null uselessHiding) $ typeError $ GenericError $ "Hiding " ++ List.intercalate ", " (map prettyShow uselessHiding) - ++ " has no effect" + -- If both @using@ and @hiding@ directive are present, + -- the hiding directive may only contain modules whose twins are mentioned. + sanityCheck notMentioned = \case + dir@(ImportDirective{ using = Using{}, hiding = ys }) -> do + let useless = \case + ImportedName{} -> True + ImportedModule y -> notMentioned (ImportedName y) + unlessNull (filter useless ys) $ \ uselessHiding -> do + typeError $ GenericError $ unwords $ + [ "Hiding" + , List.intercalate ", " $ map prettyShow uselessHiding + , "has no effect" + ] + -- We can empty @hiding@ now, since there is an explicit @using@ directive + -- and @hiding@ served its purpose to prevent modules to enter the @Using@ list. return dir{ hiding = [] } - _ -> return dir + dir -> return dir - addExtraModules :: [C.Name] -> C.ImportDirective -> C.ImportDirective + addExtraModules :: (C.Name -> Bool) -> C.ImportDirective -> C.ImportDirective addExtraModules extra dir = - dir{ using = - case using dir of - Using xs -> Using $ concatMap addExtra xs - UseEverything -> UseEverything - , hiding = concatMap addExtra (hiding dir) - , impRenaming = concatMap extraRenaming (impRenaming dir) + dir{ using = mapUsing (concatMap addExtra) $ using dir + , hiding = concatMap addExtra $ hiding dir + , impRenaming = concatMap extraRenaming $ impRenaming dir } where - addExtra f@(ImportedName y) | elem y extra = [f, ImportedModule y] + addExtra f@(ImportedName y) | extra y = [f, ImportedModule y] addExtra m = [m] - extraRenaming r@(Renaming from to rng) = - case (from, to) of - (ImportedName y, ImportedName z) | elem y extra -> - [r, Renaming (ImportedModule y) (ImportedModule z) rng] - _ -> [r] + extraRenaming = \case + r@(Renaming (ImportedName y) (ImportedName z) _fixity rng) | extra y -> + [ r , Renaming (ImportedModule y) (ImportedModule z) Nothing rng ] + r -> [r] -- | Names and modules (abstract) in scope before the import. namesInScope = (allNamesInScope scope :: ThingsInScope AbstractName) @@ -671,54 +778,65 @@ where resolve :: Ord a => err -> a -> Map a [b] -> Either err b resolve err x m = maybe (Left err) (Right . head) $ Map.lookup x m - --- | A finite map for @ImportedName@s. -lookupImportedName - :: (Eq a, Eq b) - => ImportedName' a b - -> [ImportedName' (a,c) (b,d)] - -> ImportedName' c d -lookupImportedName (ImportedName x) = loop where - loop [] = __IMPOSSIBLE__ - loop (ImportedName (y,z) : _) | x == y = ImportedName z - loop (_ : ns) = loop ns -lookupImportedName (ImportedModule x) = loop where - loop [] = __IMPOSSIBLE__ - loop (ImportedModule (y,z) : _) | x == y = ImportedModule z - loop (_ : ns) = loop ns - -- | Translation of @ImportDirective@. mapImportDir - :: (Eq n1, Eq m1) + :: (Ord n1, Ord m1) => [ImportedName' (n1,n2) (m1,m2)] -- ^ Translation of imported names. -> [ImportedName' (n1,n2) (m1,m2)] -- ^ Translation of names defined by this import. -> ImportDirective' n1 m1 -> ImportDirective' n2 m2 -mapImportDir src tgt (ImportDirective r u h ren open) = +mapImportDir src0 tgt0 (ImportDirective r u h ren open) = ImportDirective r - (mapUsing src u) - (map (`lookupImportedName` src) h) - (map (mapRenaming src tgt) ren) open + (mapUsing (map (lookupImportedName src)) u) + (map (lookupImportedName src) h) + (map (mapRenaming src tgt) ren) + open + where + src = importedNameMapFromList src0 + tgt = importedNameMapFromList tgt0 --- | Translation of @Using or Hiding@. -mapUsing - :: (Eq n1, Eq m1) - => [ImportedName' (n1,n2) (m1,m2)] -- ^ Translation of names in @using@ or @hiding@ list. - -> Using' n1 m1 - -> Using' n2 m2 -mapUsing src UseEverything = UseEverything -mapUsing src (Using xs) = Using $ map (`lookupImportedName` src) xs +-- | A finite map for @ImportedName@s. +data ImportedNameMap n1 n2 m1 m2 = ImportedNameMap + { inameMap :: Map n1 n2 + , imoduleMap :: Map m1 m2 + } + +-- | Create a 'ImportedNameMap'. +importedNameMapFromList + :: (Ord n1, Ord m1) + => [ImportedName' (n1,n2) (m1,m2)] + -> ImportedNameMap n1 n2 m1 m2 +importedNameMapFromList = foldr (flip add) $ ImportedNameMap Map.empty Map.empty + where + add (ImportedNameMap nm mm) = \case + ImportedName (x,y) -> ImportedNameMap (Map.insert x y nm) mm + ImportedModule (x,y) -> ImportedNameMap nm (Map.insert x y mm) + +-- | Apply a 'ImportedNameMap'. +lookupImportedName + :: (Ord n1, Ord m1) + => ImportedNameMap n1 n2 m1 m2 + -> ImportedName' n1 m1 + -> ImportedName' n2 m2 +lookupImportedName (ImportedNameMap nm mm) = \case + ImportedName x -> ImportedName $ Map.findWithDefault __IMPOSSIBLE__ x nm + ImportedModule x -> ImportedModule $ Map.findWithDefault __IMPOSSIBLE__ x mm + -- | Translation of @Renaming@. mapRenaming - :: (Eq n1, Eq m1) - => [ImportedName' (n1,n2) (m1,m2)] -- ^ Translation of 'renFrom' names and module names. - -> [ImportedName' (n1,n2) (m1,m2)] -- ^ Translation of 'rento' names and module names. + :: (Ord n1, Ord m1) + => ImportedNameMap n1 n2 m1 m2 -- ^ Translation of 'renFrom' names and module names. + -> ImportedNameMap n1 n2 m1 m2 -- ^ Translation of 'rento' names and module names. -> Renaming' n1 m1 -- ^ Renaming before translation (1). -> Renaming' n2 m2 -- ^ Renaming after translation (2). -mapRenaming src tgt (Renaming from to r) = - Renaming (lookupImportedName from src) (lookupImportedName to tgt) r +mapRenaming src tgt (Renaming from to fixity r) = + Renaming (lookupImportedName src from) (lookupImportedName tgt to) fixity r +--------------------------------------------------------------------------- +-- * Opening a module +--------------------------------------------------------------------------- + data OpenKind = LetOpenModule | TopOpenModule noGeneralizedVarsIfLetOpen :: OpenKind -> Scope -> Scope @@ -727,17 +845,21 @@ -- | Open a module. openModule_ :: OpenKind -> C.QName -> C.ImportDirective -> ScopeM A.ImportDirective -openModule_ kind cm dir = do +openModule_ kind cm dir = openModule kind Nothing cm dir + +-- | Open a module, possibly given an already resolved module name. +openModule :: OpenKind -> Maybe A.ModuleName -> C.QName -> C.ImportDirective -> ScopeM A.ImportDirective +openModule kind mam cm dir = do current <- getCurrentModule - m <- amodName <$> resolveModule cm - let acc | not (publicOpen dir) = PrivateNS - | m `isSubModuleOf` current = PublicNS - | otherwise = ImportedNS + m <- caseMaybe mam (amodName <$> resolveModule cm) return + let acc | Nothing <- publicOpen dir = PrivateNS + | m `isLtChildModuleOf` current = PublicNS + | otherwise = ImportedNS -- Get the scope exported by module to be opened. (adir, s') <- applyImportDirectiveM cm dir . inScopeBecause (Opened cm) . noGeneralizedVarsIfLetOpen kind . - removeOnlyQualified . restrictPrivate =<< getNamedScope m + restrictPrivate =<< getNamedScope m let s = setScopeAccess acc s' let ns = scopeNameSpace acc s modifyCurrentScope (`mergeScope` s) @@ -764,7 +886,7 @@ where -- Only checks for clashes that would lead to the same -- name being exported twice from the module. - checkForClashes = when (publicOpen dir) $ do + checkForClashes = when (isJust $ publicOpen dir) $ do exported <- allThingsInScope . restrictPrivate <$> (getNamedScope =<< getCurrentModule) diff --git a/src/full/Agda/Syntax/Translation/AbstractToConcrete.hs b/src/full/Agda/Syntax/Translation/AbstractToConcrete.hs --- a/src/full/Agda/Syntax/Translation/AbstractToConcrete.hs +++ b/src/full/Agda/Syntax/Translation/AbstractToConcrete.hs @@ -20,27 +20,30 @@ , abstractToConcreteCtx , withScope , preserveInteractionIds - , AbsToCon, Env + , MonadAbsToCon, AbsToCon, Env , noTakenNames ) where import Prelude hiding (null) -import Control.Applicative hiding (empty) +import Control.Arrow (first) import Control.Monad.Reader import Control.Monad.State -import Data.Either +import qualified Control.Monad.Fail as Fail + import qualified Data.Map as Map import Data.Maybe import Data.Monoid import Data.Set (Set) import qualified Data.Set as Set import Data.Map (Map) -import qualified Data.Map as Map +import qualified Data.Foldable as Fold import Data.Traversable (traverse) import Data.Void import Data.List (sortBy) +import Data.List.NonEmpty (NonEmpty(..)) +import qualified Data.List.NonEmpty as NonEmpty import Agda.Syntax.Common import Agda.Syntax.Position @@ -50,34 +53,32 @@ import qualified Agda.Syntax.Internal as I import Agda.Syntax.Fixity import Agda.Syntax.Concrete as C +import Agda.Syntax.Concrete.Pattern as C import Agda.Syntax.Abstract as A import Agda.Syntax.Abstract.Views as A import Agda.Syntax.Abstract.Pattern as A import Agda.Syntax.Abstract.PatternSynonyms import Agda.Syntax.Scope.Base -import Agda.Syntax.Scope.Monad ( resolveName' ) +import Agda.Syntax.Scope.Monad ( tryResolveName ) import Agda.TypeChecking.Monad.State (getScope, getAllPatternSyns) import Agda.TypeChecking.Monad.Base import Agda.TypeChecking.Monad.Debug -import Agda.TypeChecking.Monad.Options import Agda.TypeChecking.Monad.Builtin import Agda.Interaction.Options import qualified Agda.Utils.AssocList as AssocList import Agda.Utils.Either +import Agda.Utils.Except import Agda.Utils.Function import Agda.Utils.Functor -import Agda.Utils.List +import Agda.Utils.Lens import Agda.Utils.Maybe import Agda.Utils.Monad import Agda.Utils.Null -import Agda.Utils.NonemptyList import Agda.Utils.Singleton -import Agda.Utils.Tuple import Agda.Utils.Pretty -#include "undefined.h" import Agda.Utils.Impossible -- Environment ------------------------------------------------------------ @@ -96,10 +97,10 @@ , foldPatternSynonyms :: Bool } -makeEnv :: ScopeInfo -> TCM Env +makeEnv :: MonadAbsToCon m => ScopeInfo -> m Env makeEnv scope = do -- zero and suc doesn't have to be in scope for natural number literals to work - let noScopeCheck b = elem b [builtinZero, builtinSuc] + let noScopeCheck b = b `elem` [builtinZero, builtinSuc] name (I.Def q _) = Just q name (I.Con q _ _) = Just (I.conName q) name _ = Nothing @@ -107,11 +108,13 @@ Just v | Just q <- name v, noScopeCheck b || isNameInScope q scope -> return [(b, q)] _ -> return [] - vars <- map (fst . unDom) <$> asksTC envContext + ctxVars <- map (fst . I.unDom) <$> asksTC envContext + letVars <- Map.keys <$> asksTC envLetBindings + let vars = ctxVars ++ letVars -- pick concrete names for in-scope names now so we don't -- accidentally shadow them - forM_ (scopeLocals scope) $ \(y , x) -> do + forM_ (scope ^. scopeLocals) $ \(y , x) -> do pickConcreteName (localVar x) y builtinList <- concat <$> mapM builtin [ builtinFromNat, builtinFromString, builtinFromNeg, builtinZero, builtinSuc ] @@ -135,14 +138,14 @@ nsNames $ everythingInScope scope currentPrecedence :: AbsToCon PrecedenceStack -currentPrecedence = asks $ scopePrecedence . currentScope +currentPrecedence = asks $ (^. scopePrecedence) . currentScope preserveInteractionIds :: AbsToCon a -> AbsToCon a preserveInteractionIds = local $ \ e -> e { preserveIIds = True } withPrecedence' :: PrecedenceStack -> AbsToCon a -> AbsToCon a withPrecedence' ps = local $ \e -> - e { currentScope = (currentScope e) { scopePrecedence = ps } } + e { currentScope = set scopePrecedence ps (currentScope e) } withPrecedence :: Precedence -> AbsToCon a -> AbsToCon a withPrecedence p ret = do @@ -171,27 +174,107 @@ isBuiltinFun = asks $ is . builtins where is m q b = Just q == Map.lookup b m +-- | Resolve a concrete name. If illegally ambiguous fail with the ambiguous names. +resolveName :: KindsOfNames -> Maybe (Set A.Name) -> C.QName -> AbsToCon (Either (NonEmpty A.QName) ResolvedName) +resolveName kinds candidates q = runExceptT $ tryResolveName kinds candidates q + +-- | Treat illegally ambiguous names as UnknownNames. +resolveName_ :: C.QName -> [A.Name] -> AbsToCon ResolvedName +resolveName_ q cands = either (const UnknownName) id <$> resolveName allKindsOfNames (Just $ Set.fromList cands) q + -- The Monad -------------------------------------------------------------- --- | We put the translation into TCM in order to print debug messages. -type AbsToCon = ReaderT Env TCM +-- | We need: +-- - Read access to the AbsToCon environment +-- - Read access to the TC environment +-- - Read access to the TC state +-- - Read and write access to the stConcreteNames part of the TC state +-- - Read access to the options +-- - Permission to print debug messages +type MonadAbsToCon m = + ( MonadTCEnv m + , ReadTCState m + , MonadStConcreteNames m + , HasOptions m + , HasBuiltins m + , MonadDebug m + ) -runAbsToCon :: AbsToCon c -> TCM c +newtype AbsToCon a = AbsToCon + { unAbsToCon :: forall m. + ( MonadReader Env m + , MonadAbsToCon m + ) => m a + } + +-- TODO: Is there some way to automatically derive these boilerplate +-- instances? GeneralizedNewtypeDeriving fails us here. +instance Functor AbsToCon where + fmap f x = AbsToCon $ fmap f $ unAbsToCon x + +instance Applicative AbsToCon where + pure x = AbsToCon $ pure x + f <*> m = AbsToCon $ unAbsToCon f <*> unAbsToCon m + +instance Monad AbsToCon where + m >>= f = AbsToCon $ unAbsToCon m >>= unAbsToCon . f +#if __GLASGOW_HASKELL__ < 808 + fail = Fail.fail +#endif + +instance Fail.MonadFail AbsToCon where + fail = error + +instance MonadReader Env AbsToCon where + ask = AbsToCon ask + local f m = AbsToCon $ local f $ unAbsToCon m + +instance MonadTCEnv AbsToCon where + askTC = AbsToCon askTC + localTC f m = AbsToCon $ localTC f $ unAbsToCon m + +instance ReadTCState AbsToCon where + getTCState = AbsToCon getTCState + locallyTCState l f m = AbsToCon $ locallyTCState l f $ unAbsToCon m + +instance MonadStConcreteNames AbsToCon where + runStConcreteNames m = AbsToCon $ runStConcreteNames $ StateT $ unAbsToCon . runStateT m + +instance HasOptions AbsToCon where + pragmaOptions = AbsToCon pragmaOptions + commandLineOptions = AbsToCon commandLineOptions + +instance MonadDebug AbsToCon where + displayDebugMessage k n s = AbsToCon $ displayDebugMessage k n s + formatDebugMessage k n s = AbsToCon $ formatDebugMessage k n s + verboseBracket k n s m = AbsToCon $ verboseBracket k n s $ unAbsToCon m + +runAbsToCon :: MonadAbsToCon m => AbsToCon c -> m c runAbsToCon m = do scope <- getScope - reportSLn "toConcrete" 50 $ render $ "entering AbsToCon with scope:" <+> prettyList_ (map (text . C.nameToRawName . fst) $ scopeLocals scope) - runReaderT m =<< makeEnv scope + verboseBracket "toConcrete" 50 "runAbsToCon" $ do + reportSLn "toConcrete" 50 $ render $ hsep $ + [ "entering AbsToCon with scope:" + , prettyList_ (map (text . C.nameToRawName . fst) $ scope ^. scopeLocals) + ] + x <- runReaderT (unAbsToCon m) =<< makeEnv scope + reportSLn "toConcrete" 50 $ "leaving AbsToCon" + return x -abstractToConcreteScope :: ToConcrete a c => ScopeInfo -> a -> TCM c -abstractToConcreteScope scope a = runReaderT (toConcrete a) =<< makeEnv scope +abstractToConcreteScope :: (ToConcrete a c, MonadAbsToCon m) + => ScopeInfo -> a -> m c +abstractToConcreteScope scope a = runReaderT (unAbsToCon $ toConcrete a) =<< makeEnv scope -abstractToConcreteCtx :: ToConcrete a c => Precedence -> a -> TCM c +abstractToConcreteCtx :: (ToConcrete a c, MonadAbsToCon m) + => Precedence -> a -> m c abstractToConcreteCtx ctx x = runAbsToCon $ withPrecedence ctx (toConcrete x) -abstractToConcrete_ :: ToConcrete a c => a -> TCM c +abstractToConcrete_ :: (ToConcrete a c, MonadAbsToCon m) + => a -> m c abstractToConcrete_ = runAbsToCon . toConcrete -abstractToConcreteHiding :: (LensHiding i, ToConcrete a c) => i -> a -> TCM c +abstractToConcreteHiding :: (LensHiding i, ToConcrete a c, MonadAbsToCon m) + => i -> a -> m c abstractToConcreteHiding i = runAbsToCon . toConcreteHiding i -- Dealing with names ----------------------------------------------------- @@ -210,7 +293,7 @@ return (C.QName $ C.Name noRange C.InScope $ C.stringNameParts s) lookupQName ambCon x = do ys <- inverseScopeLookupName' ambCon x <$> asks currentScope - lift $ reportSLn "scope.inverse" 100 $ + reportSLn "scope.inverse" 100 $ "inverse looking up abstract name " ++ prettyShow x ++ " yields " ++ prettyShow ys loop ys @@ -243,38 +326,31 @@ -- name in the current scope? lookupNameInScope :: C.Name -> AbsToCon (Maybe A.Name) lookupNameInScope y = - fmap localVar . lookup y . scopeLocals <$> asks currentScope + fmap localVar . lookup y <$> asks ((^. scopeLocals) . currentScope) -- | Have we already committed to a specific concrete name for this -- abstract name? If yes, return the concrete name(s). -hasConcreteNames :: (MonadTCState m) => A.Name -> m [C.Name] -hasConcreteNames x = Map.findWithDefault [] x <$> useTC stConcreteNames +hasConcreteNames :: (MonadStConcreteNames m) => A.Name -> m [C.Name] +hasConcreteNames x = Map.findWithDefault [] x <$> useConcreteNames -- | Commit to a specific concrete name for printing the given -- abstract name. If the abstract name already has associated --- concrete name(s), the new name is only used when all previous --- names are shadowed. Precondition: the abstract name should be in -- scope. -pickConcreteName :: (MonadTCState m) => A.Name -> C.Name -> m () -pickConcreteName x y = modifyTCLens stConcreteNames $ flip Map.alter x $ \case +pickConcreteName :: (MonadStConcreteNames m) => A.Name -> C.Name -> m () +pickConcreteName x y = modifyConcreteNames $ flip Map.alter x $ \case Nothing -> Just $ [y] (Just ys) -> Just $ ys ++ [y] --- | For the given abstract name, return the names that could shadow it: --- 1. first set: names for which we have already picked a --- concrete name (so we should definitely avoid these names) --- 2. second set: flexible names that we would like to keep free if --- possible (we can try to avoid them, but it's not required) -shadowingNames :: (MonadTCState m) => A.Name -> m (Set C.Name, Set C.Name) -shadowingNames x = do - shadows <- Map.findWithDefault [] x <$> useTC stShadowingNames - ys <- concat <$> forM shadows hasConcreteNames - let zs = map nameConcrete shadows - return (Set.fromList ys , Set.fromList zs) +-- | For the given abstract name, return the names that could shadow it. +shadowingNames :: (ReadTCState m, MonadStConcreteNames m) + => A.Name -> m (Set RawName) +shadowingNames x = Set.fromList . Map.findWithDefault [] x <$> useR stShadowingNames toConcreteName :: A.Name -> AbsToCon C.Name toConcreteName x | y <- nameConcrete x , isNoName y = return y -toConcreteName x = (Map.findWithDefault [] x <$> useTC stConcreteNames) >>= loop +toConcreteName x = (Map.findWithDefault [] x <$> useConcreteNames) >>= loop where -- case: we already have picked some name(s) for x loop (y:ys) = ifM (isGoodName x y) (return y) (loop ys) @@ -305,35 +381,26 @@ return $ nameConcrete x -- Otherwise we pick a name that does not shadow other names _ -> do - taken <- takenConcreteNames - toAvoid <- do - (mustAvoid , tryToAvoid) <- shadowingNames x - let tryToAvoid' = Set.filter ((== InScope) . isInScope) tryToAvoid - return $ case isInScope x of - -- If in scope, we only rename when the name is already taken - -- in the future - InScope -> mustAvoid - -- If not in scope, we also rename to avoid renaming in-scope - -- variables in the future. - C.NotInScope -> mustAvoid `Set.union` tryToAvoid' - let shouldAvoid = (`Set.member` (taken `Set.union` toAvoid)) + taken <- takenNames + toAvoid <- shadowingNames x + let shouldAvoid = (`Set.member` (taken `Set.union` toAvoid)) . C.nameToRawName y = firstNonTakenName shouldAvoid $ nameConcrete x reportSLn "toConcrete.bindName" 80 $ render $ vcat [ "picking concrete name for:" <+> text (C.nameToRawName $ nameConcrete x) - , "names already taken: " <+> prettyList_ (map C.nameToRawName $ Set.toList taken) - , "names to avoid: " <+> prettyList_ (map C.nameToRawName $ Set.toList toAvoid) + , "names already taken: " <+> prettyList_ (Set.toList taken) + , "names to avoid: " <+> prettyList_ (Set.toList toAvoid) , "concrete name chosen: " <+> text (C.nameToRawName y) ] return y where - takenConcreteNames :: AbsToCon (Set C.Name) - takenConcreteNames = do + takenNames :: AbsToCon (Set RawName) + takenNames = do xs <- asks takenDefNames ys0 <- asks takenVarNames reportSLn "toConcrete.bindName" 90 $ render $ "abstract names of local vars: " <+> prettyList_ (map (C.nameToRawName . nameConcrete) $ Set.toList ys0) ys <- Set.fromList . concat <$> mapM hasConcreteNames (Set.toList ys0) - return $ xs `Set.union` ys + return $ Set.map C.nameToRawName $ xs `Set.union` ys -- | Add a abstract name to the scope and produce an available concrete version of it. @@ -419,7 +486,7 @@ withAbstractPrivate i m = priv (defAccess i) . abst (A.defAbstract i) - . addInstanceB (A.defInstance i == InstanceDef) + . addInstanceB (case A.defInstance i of InstanceDef r -> Just r; NotInstanceDef -> Nothing) <$> m where priv (PrivateAccess UserWritten) @@ -428,9 +495,9 @@ abst AbstractDef ds = [ C.Abstract (getRange ds) ds ] abst ConcreteDef ds = ds -addInstanceB :: Bool -> [C.Declaration] -> [C.Declaration] -addInstanceB True ds = [ C.InstanceB (getRange ds) ds ] -addInstanceB False ds = ds +addInstanceB :: Maybe Range -> [C.Declaration] -> [C.Declaration] +addInstanceB (Just r) ds = [ C.InstanceB r ds ] +addInstanceB Nothing ds = ds -- The To Concrete Class -------------------------------------------------- @@ -478,6 +545,12 @@ -- General instances ------------------------------------------------------ +instance ToConcrete () () where + toConcrete = pure + +instance ToConcrete Bool Bool where + toConcrete = pure + instance ToConcrete a c => ToConcrete [a] [c] where toConcrete = mapM toConcrete -- Andreas, 2017-04-11, Issue #2543 @@ -557,9 +630,9 @@ toConcrete = \case VarName x _ -> C.QName <$> toConcrete x DefinedName _ x -> toConcrete x - FieldName xs -> toConcrete (headNe xs) - ConstructorName xs -> toConcrete (headNe xs) - PatternSynResName xs -> toConcrete (headNe xs) + FieldName xs -> toConcrete (NonEmpty.head xs) + ConstructorName xs -> toConcrete (NonEmpty.head xs) + PatternSynResName xs -> toConcrete (NonEmpty.head xs) UnknownName -> __IMPOSSIBLE__ -- Expression instance ---------------------------------------------------- @@ -630,24 +703,34 @@ bracket lamBrackets $ return $ C.AbsurdLam (getRange i) h toConcrete e@(A.Lam i _ _) = tryToRecoverOpApp e -- recover sections - $ bracket lamBrackets $ case lamView e of - (bs, e) -> + ([], e) -> toConcrete e + (bs, e) -> bracket lamBrackets $ bindToConcrete (map makeDomainFree bs) $ \ bs -> do - e <- toConcreteTop e - return $ C.Lam (getRange i) bs e + e <- toConcreteTop e + return $ C.Lam (getRange i) bs e where - lamView (A.Lam _ b@(A.DomainFree _) e) = - case lamView e of - ([], e) -> ([b], e) - (bs@(A.DomainFree _ : _), e) -> (b:bs, e) - _ -> ([b], e) - lamView (A.Lam _ b@(A.DomainFull _) e) = + -- #3238 GA: We drop the hidden lambda abstractions which have + -- been inserted by the machine rather than the user. This means + -- that the result of lamView may actually be an empty list of + -- binders. + lamView :: A.Expr -> ([A.LamBinding], A.Expr) + lamView (A.Lam _ b@(A.DomainFree _ x) e) + | isInsertedHidden x = lamView e + | otherwise = case lamView e of + (bs@(A.DomainFree{} : _), e) -> (b:bs, e) + _ -> ([b] , e) + lamView (A.Lam _ b@(A.DomainFull A.TLet{}) e) = case lamView e of + (bs@(A.DomainFull _ : _), e) -> (b:bs, e) + _ -> ([b], e) + lamView (A.Lam _ (A.DomainFull (A.TBind r t xs ty)) e) = + case filter (not . isInsertedHidden) xs of + [] -> lamView e + xs' -> let b = A.DomainFull (A.TBind r t xs' ty) in case lamView e of - ([], e) -> ([b], e) - (bs@(A.DomainFull _ : _), e) -> (b:bs, e) - _ -> ([b], e) - lamView e = ([], e) + (bs@(A.DomainFull _ : _), e) -> (b:bs, e) + _ -> ([b], e) + lamView e = ([], e) toConcrete (A.ExtendedLam i di qname cs) = bracket lamBrackets $ do decls <- concat <$> toConcrete cs @@ -669,13 +752,13 @@ removeApp x@C.IdentP{} = return $ C.RawAppP (getRange x) [] removeApp p = do - lift $ reportSLn "extendedlambda" 50 $ "abstractToConcrete removeApp p = " ++ show p + reportSLn "extendedlambda" 50 $ "abstractToConcrete removeApp p = " ++ show p return p -- __IMPOSSIBLE__ -- Andreas, this is actually not impossible, my strictification exposed this sleeping bug let decl2clause (C.FunClause lhs rhs wh ca) = do let p = lhsOriginalPattern lhs - lift $ reportSLn "extendedlambda" 50 $ "abstractToConcrete extended lambda pattern p = " ++ show p + reportSLn "extendedlambda" 50 $ "abstractToConcrete extended lambda pattern p = " ++ show p p' <- removeApp p - lift $ reportSLn "extendedlambda" 50 $ "abstractToConcrete extended lambda pattern p' = " ++ show p' + reportSLn "extendedlambda" 50 $ "abstractToConcrete extended lambda pattern p' = " ++ show p' return $ LamClause lhs{ lhsOriginalPattern = p' } rhs wh ca decl2clause _ = __IMPOSSIBLE__ C.ExtendedLam (getRange i) <$> mapM decl2clause decls @@ -687,25 +770,25 @@ e' <- toConcreteTop e return $ C.Pi tel' e' where - piTel (A.Pi _ tel e) = (tel ++) -*- id $ piTel e + piTel (A.Pi _ tel e) = first (tel ++) $ piTel e piTel e = ([], e) toConcrete (A.Generalized _ e) = C.Generalized <$> toConcrete e toConcrete (A.Fun i a b) = bracket piBrackets - $ do a' <- toConcreteCtx (if irr then DotPatternCtx else FunctionSpaceDomainCtx) a + $ do a' <- toConcreteCtx ctx a b' <- toConcreteTop b - return $ C.Fun (getRange i) (defaultArg $ addRel a' $ mkArg a') b' + let dom = setQuantity (getQuantity a') $ defaultArg $ addRel a' $ mkArg a' + return $ C.Fun (getRange i) dom b' -- Andreas, 2018-06-14, issue #2513 -- TODO: print attributes where - irr = getRelevance a `elem` [Irrelevant, NonStrict] + ctx = if isRelevant a then FunctionSpaceDomainCtx else DotPatternCtx addRel a e = case getRelevance a of - Irrelevant -> addDot a e - NonStrict -> addDot a (addDot a e) + Irrelevant -> C.Dot (getRange a) e + NonStrict -> C.DoubleDot (getRange a) e _ -> e - addDot a e = C.Dot (getRange a) e mkArg (Arg info e) = case getHiding info of Hidden -> HiddenArg (getRange e) (unnamed e) Instance{} -> InstanceArg (getRange e) (unnamed e) @@ -733,23 +816,15 @@ toConcrete (A.ETel tel) = C.ETel <$> toConcrete tel toConcrete (A.ScopedExpr _ e) = toConcrete e - - toConcrete (A.QuoteGoal i x e) = - bracket lamBrackets $ - bindToConcrete x $ \ x' -> do - e' <- toConcrete e - return $ C.QuoteGoal (getRange i) x' e' - toConcrete (A.QuoteContext i) = return $ C.QuoteContext (getRange i) toConcrete (A.Quote i) = return $ C.Quote (getRange i) toConcrete (A.QuoteTerm i) = return $ C.QuoteTerm (getRange i) toConcrete (A.Unquote i) = return $ C.Unquote (getRange i) - toConcrete (A.Tactic i e xs ys) = do + toConcrete (A.Tactic i e xs) = do e' <- toConcrete e xs' <- toConcrete xs - ys' <- toConcrete ys let r = getRange i rawtac = foldl (C.App r) e' xs' - return $ C.Tactic (getRange i) rawtac (map namedArg ys') + return $ C.Tactic (getRange i) rawtac -- Andreas, 2012-04-02: TODO! print DontCare as irrAxiom -- Andreas, 2010-10-05 print irrelevant things as ordinary things @@ -758,10 +833,10 @@ toConcrete (A.PatternSyn n) = C.Ident <$> toConcrete (headAmbQ n) makeDomainFree :: A.LamBinding -> A.LamBinding -makeDomainFree b@(A.DomainFull (A.TBind _ [x] t)) = +makeDomainFree b@(A.DomainFull (A.TBind _ tac [x] t)) = case unScope t of A.Underscore A.MetaInfo{metaNumber = Nothing} -> - A.DomainFree x + A.DomainFree tac x _ -> b makeDomainFree b = b @@ -781,42 +856,56 @@ -- If there is no label we set it to the bound name, to make renaming the bound -- name safe. -forceNameIfHidden :: NamedArg A.BindName -> NamedArg A.BindName +forceNameIfHidden :: NamedArg A.Binder -> NamedArg A.Binder forceNameIfHidden x - | isJust $ nameOf $ unArg x = x - | visible x = x - | otherwise = x <&> \ y -> y { nameOf = Just name } + | isJust $ getNameOf x = x + | visible x = x + | otherwise = setNameOf (Just name) x where - name = Ranged (getRange x) $ C.nameToRawName $ nameConcrete $ unBind $ namedArg x + name = WithOrigin Inserted + $ Ranged (getRange x) + $ C.nameToRawName $ nameConcrete + $ unBind $ A.binderName $ namedArg x +instance ToConcrete a b => ToConcrete (A.Binder' a) (C.Binder' b) where + bindToConcrete (A.Binder p a) ret = + bindToConcrete a $ \ a -> + bindToConcrete p $ \ p -> + ret $ C.Binder p a + instance ToConcrete A.LamBinding C.LamBinding where - bindToConcrete (A.DomainFree x) ret = - bindToConcrete (forceNameIfHidden x) $ ret . C.DomainFree + bindToConcrete (A.DomainFree t x) ret = do + t <- traverse toConcrete t + let setTac x = x { bnameTactic = t } + bindToConcrete (forceNameIfHidden x) $ + ret . C.DomainFree . updateNamedArg (fmap setTac) bindToConcrete (A.DomainFull b) ret = bindToConcrete b $ ret . C.DomainFull instance ToConcrete A.TypedBinding C.TypedBinding where - bindToConcrete (A.TBind r xs e) ret = + bindToConcrete (A.TBind r t xs e) ret = do + t <- traverse toConcrete t bindToConcrete (map forceNameIfHidden xs) $ \ xs -> do - e <- toConcreteTop e - ret $ C.TBind r xs e + e <- toConcreteTop e + let setTac x = x { bnameTactic = t } + ret $ C.TBind r (map (updateNamedArg (fmap setTac)) xs) e bindToConcrete (A.TLet r lbs) ret = bindToConcrete lbs $ \ ds -> do ret $ C.TLet r $ concat ds -instance ToConcrete LetBinding [C.Declaration] where - bindToConcrete (LetBind i info x t e) ret = +instance ToConcrete A.LetBinding [C.Declaration] where + bindToConcrete (A.LetBind i info x t e) ret = bindToConcrete x $ \ x -> do (t, (e, [], [], [])) <- toConcrete (t, A.RHS e Nothing) - ret $ addInstanceB (isInstance info) $ - [ C.TypeSig info (C.boundName x) t - , C.FunClause (C.LHS (C.IdentP $ C.QName $ C.boundName x) [] []) + ret $ addInstanceB (if isInstance info then Just noRange else Nothing) $ + [ C.TypeSig info Nothing (C.boundName x) t + , C.FunClause (C.LHS (C.IdentP $ C.QName $ C.boundName x) [] [] NoEllipsis) e C.NoWhere False ] -- TODO: bind variables bindToConcrete (LetPatBind i p e) ret = do p <- toConcrete p e <- toConcrete e - ret [ C.FunClause (C.LHS p [] []) (C.RHS e) NoWhere False ] + ret [ C.FunClause (C.LHS p [] [] NoEllipsis) (C.RHS e) NoWhere False ] bindToConcrete (LetApply i x modapp _ _) ret = do x' <- unqualify <$> toConcrete x modapp <- toConcrete modapp @@ -850,16 +939,16 @@ mergeSigAndDef :: [C.Declaration] -> [C.Declaration] mergeSigAndDef (C.RecordSig _ x bs e : C.RecordDef r y ind eta c _ fs : ds) | x == y = C.Record r y ind eta c bs e fs : mergeSigAndDef ds -mergeSigAndDef (C.DataSig _ _ x bs e : C.DataDef r i y _ cs : ds) - | x == y = C.Data r i y bs e cs : mergeSigAndDef ds +mergeSigAndDef (C.DataSig _ x bs e : C.DataDef r y _ cs : ds) + | x == y = C.Data r y bs e cs : mergeSigAndDef ds mergeSigAndDef (d : ds) = d : mergeSigAndDef ds mergeSigAndDef [] = [] openModule' :: A.ModuleName -> C.ImportDirective -> (Scope -> Scope) -> Env -> Env -openModule' x dir restrict env = env{currentScope = sInfo{scopeModules = mods'}} +openModule' x dir restrict env = env{currentScope = set scopeModules mods' sInfo} where sInfo = currentScope env - amod = scopeCurrent sInfo - mods = scopeModules sInfo + amod = sInfo ^. scopeCurrent + mods = sInfo ^. scopeModules news = setScopeAccess PrivateNS $ applyImportDirective dir $ maybe emptyScope restrict @@ -872,7 +961,7 @@ declsToConcrete :: [A.Declaration] -> AbsToCon [C.Declaration] declsToConcrete ds = mergeSigAndDef . concat <$> toConcrete ds -instance ToConcrete A.RHS (C.RHS, [C.Expr], [C.Expr], [C.Declaration]) where +instance ToConcrete A.RHS (C.RHS, [C.RewriteEqn], [WithHiding C.Expr], [C.Declaration]) where toConcrete (A.RHS e (Just c)) = return (C.RHS c, [], [], []) toConcrete (A.RHS e Nothing) = do e <- toConcrete e @@ -885,16 +974,18 @@ toConcrete (A.RewriteRHS xeqs _spats rhs wh) = do wh <- declsToConcrete (A.whereDecls wh) (rhs, eqs', es, whs) <- toConcrete rhs - unless (null eqs') - __IMPOSSIBLE__ - eqs <- toConcrete $ map snd xeqs + unless (null eqs') __IMPOSSIBLE__ + eqs <- toConcrete xeqs return (rhs, eqs, es, wh ++ whs) +instance (ToConcrete p q, ToConcrete a b) => + ToConcrete (RewriteEqn' qn p a) (RewriteEqn' () q b) where + toConcrete = \case + Rewrite es -> Rewrite <$> mapM (toConcrete . (\ (_, e) -> ((),e))) es + Invert qn pes -> Invert () <$> mapM toConcrete pes + instance ToConcrete (Maybe A.QName) (Maybe C.Name) where - toConcrete Nothing = return Nothing - toConcrete (Just x) = do - x' <- toConcrete (qnameName x) - return $ Just x' + toConcrete = mapM (toConcrete . qnameName) instance ToConcrete (Constr A.Constructor) C.Declaration where toConcrete (Constr (A.ScopedDecl scope [d])) = @@ -902,17 +993,17 @@ toConcrete (Constr (A.Axiom _ i info Nothing x t)) = do x' <- unsafeQNameToName <$> toConcrete x t' <- toConcreteTop t - return $ C.TypeSig info x' t' + return $ C.TypeSig info Nothing x' t' toConcrete (Constr (A.Axiom _ _ _ (Just _) _ _)) = __IMPOSSIBLE__ toConcrete (Constr d) = head <$> toConcrete d instance ToConcrete a C.LHS => ToConcrete (A.Clause' a) [C.Declaration] where toConcrete (A.Clause lhs _ rhs wh catchall) = bindToConcrete lhs $ \case - C.LHS p _ _ -> do + C.LHS p _ _ ell -> do bindToConcrete wh $ \ wh' -> do (rhs', eqs, with, wcs) <- toConcreteTop rhs - return $ FunClause (C.LHS p eqs with) rhs' wh' catchall : wcs + return $ FunClause (C.LHS p eqs with ell) rhs' wh' catchall : wcs instance ToConcrete A.ModuleApplication C.ModuleApplication where toConcrete (A.SectionApp tel y es) = do @@ -939,28 +1030,30 @@ (case mp of Nothing -> [] Just occs -> [C.Pragma (PolarityPragma noRange x' occs)]) ++ - [C.Postulate (getRange i) [C.TypeSig info x' t']] + [C.Postulate (getRange i) [C.TypeSig info Nothing x' t']] toConcrete (A.Generalize s i j x t) = do x' <- unsafeQNameToName <$> toConcrete x + tac <- traverse toConcrete (defTactic i) withAbstractPrivate i $ withInfixDecl i x' $ do t' <- toConcreteTop t - return [C.Generalize (getRange i) [C.TypeSig j x' $ C.Generalized t']] + return [C.Generalize (getRange i) [C.TypeSig j tac x' $ C.Generalized t']] toConcrete (A.Field i x t) = do x' <- unsafeQNameToName <$> toConcrete x + tac <- traverse toConcrete (defTactic i) withAbstractPrivate i $ withInfixDecl i x' $ do t' <- toConcreteTop t - return [C.Field (A.defInstance i) x' t'] + return [C.FieldSig (A.defInstance i) tac x' t'] toConcrete (A.Primitive i x t) = do x' <- unsafeQNameToName <$> toConcrete x withAbstractPrivate i $ withInfixDecl i x' $ do t' <- toConcreteTop t - return [C.Primitive (getRange i) [C.TypeSig defaultArgInfo x' t']] + return [C.Primitive (getRange i) [C.TypeSig defaultArgInfo Nothing x' t']] -- Primitives are always relevant. toConcrete (A.FunDef i _ _ cs) = @@ -971,13 +1064,13 @@ bindToConcrete (A.generalizeTel bs) $ \ tel' -> do x' <- unsafeQNameToName <$> toConcrete x t' <- toConcreteTop t - return [ C.DataSig (getRange i) Inductive x' (map C.DomainFull tel') t' ] + return [ C.DataSig (getRange i) x' (map C.DomainFull tel') t' ] toConcrete (A.DataDef i x uc bs cs) = withAbstractPrivate i $ bindToConcrete (map makeDomainFree $ dataDefParams bs) $ \ tel' -> do - (x',cs') <- (unsafeQNameToName -*- id) <$> toConcrete (x, map Constr cs) - return [ C.DataDef (getRange i) Inductive x' tel' cs' ] + (x',cs') <- first unsafeQNameToName <$> toConcrete (x, map Constr cs) + return [ C.DataDef (getRange i) x' tel' cs' ] toConcrete (A.RecSig i x bs t) = withAbstractPrivate i $ @@ -989,7 +1082,7 @@ toConcrete (A.RecDef i x uc ind eta c bs t cs) = withAbstractPrivate i $ bindToConcrete (map makeDomainFree $ dataDefParams bs) $ \ tel' -> do - (x',cs') <- (unsafeQNameToName -*- id) <$> toConcrete (x, map Constr cs) + (x',cs') <- first unsafeQNameToName <$> toConcrete (x, map Constr cs) return [ C.RecordDef (getRange i) x' ind eta Nothing tel' cs' ] toConcrete (A.Mutual i ds) = declsToConcrete ds @@ -1046,7 +1139,7 @@ A.OptionsPragma xs -> return $ C.OptionsPragma r xs A.BuiltinPragma b x -> C.BuiltinPragma r b <$> toConcrete x A.BuiltinNoDefPragma b x -> C.BuiltinPragma r b <$> toConcrete x - A.RewritePragma x -> C.RewritePragma r . singleton <$> toConcrete x + A.RewritePragma r' x -> C.RewritePragma r r' <$> toConcrete x A.CompilePragma b x s -> do x <- toConcrete x return $ C.CompilePragma r b x s @@ -1065,7 +1158,7 @@ instance ToConcrete A.LHS C.LHS where bindToConcrete (A.LHS i lhscore) ret = do bindToConcreteCtx TopCtx lhscore $ \ lhs -> - ret $ C.LHS lhs [] [] + ret $ C.LHS (reintroduceEllipsis (lhsEllipsis i) lhs) [] [] NoEllipsis instance ToConcrete A.LHSCore C.Pattern where bindToConcrete = bindToConcrete . lhsCoreToPattern @@ -1081,7 +1174,7 @@ newtype FreshenName = FreshenName BindName instance ToConcrete FreshenName A.Name where - bindToConcrete (FreshenName (BindName x)) ret = bindToConcrete x $ \ y -> ret x { nameConcrete = y } + bindToConcrete (FreshenName BindName{ unBind = x }) ret = bindToConcrete x $ \ y -> ret x { nameConcrete = y } -- Pass 1: (Issue #2729) -- Takes care of binding the originally user-written pattern variables, but doesn't actually @@ -1095,7 +1188,7 @@ case isInScope x of InScope -> bindName' x $ ret $ A.VarP bx C.NotInScope -> bindName x $ \y -> - ret $ A.VarP $ BindName $ x { nameConcrete = y } + ret $ A.VarP $ mkBindName $ x { nameConcrete = y } A.WildP{} -> ret p A.ProjP{} -> ret p A.AbsurdP{} -> ret p @@ -1106,7 +1199,7 @@ -- Do not go into patterns generated by case-split here! -- They are treated in a second pass. A.ConP i c args - | patOrigin i == ConOSplit -> ret p + | conPatOrigin i == ConOSplit -> ret p | otherwise -> bindToConcrete (map UserPattern args) $ ret . A.ConP i c A.DefP i f args -> bindToConcrete (map UserPattern args) $ ret . A.DefP i f A.PatternSynP i f args -> bindToConcrete (map UserPattern args) $ ret . A.PatternSynP i f @@ -1137,7 +1230,7 @@ -- Andreas, 2017-09-03, issue #2729: -- For patterns generated by case-split here, switch to freshening & binding. A.ConP i c args - | patOrigin i == ConOSplit + | conPatOrigin i == ConOSplit -> bindToConcrete ((map . fmap . fmap) BindingPat args) $ ret . A.ConP i c | otherwise -> bindToConcrete (map SplitPattern args) $ ret . A.ConP i c A.DefP i f args -> bindToConcrete (map SplitPattern args) $ ret . A.DefP i f @@ -1161,20 +1254,20 @@ bindToConcrete (BindingPat p) ret = do reportSLn "toConcrete.pat" 100 $ "binding pattern (pass 2b)" ++ show p case p of - A.VarP x -> bindToConcrete (FreshenName x) $ ret . A.VarP . BindName + A.VarP x -> bindToConcrete (FreshenName x) $ ret . A.VarP . mkBindName A.WildP{} -> ret p A.ProjP{} -> ret p A.AbsurdP{} -> ret p A.LitP{} -> ret p A.DotP{} -> ret p A.EqualP{} -> ret p - A.ConP i c args -> bindToConcrete ((map . fmap . fmap) BindingPat args) $ ret . A.ConP i c - A.DefP i f args -> bindToConcrete ((map . fmap . fmap) BindingPat args) $ ret . A.DefP i f - A.PatternSynP i f args -> bindToConcrete ((map . fmap . fmap) BindingPat args) $ ret . A.PatternSynP i f + A.ConP i c args -> bindToConcrete (map (updateNamedArg BindingPat) args) $ ret . A.ConP i c + A.DefP i f args -> bindToConcrete (map (updateNamedArg BindingPat) args) $ ret . A.DefP i f + A.PatternSynP i f args -> bindToConcrete (map (updateNamedArg BindingPat) args) $ ret . A.PatternSynP i f A.RecP i args -> bindToConcrete ((map . fmap) BindingPat args) $ ret . A.RecP i A.AsP i x p -> bindToConcrete (FreshenName x) $ \ x -> bindToConcrete (BindingPat p) $ \ p -> - ret (A.AsP i (BindName x) p) + ret (A.AsP i (mkBindName x) p) A.WithP i p -> bindToConcrete (BindingPat p) $ ret . A.WithP i instance ToConcrete A.Pattern C.Pattern where @@ -1225,12 +1318,13 @@ -- Erase @v@ to a concrete name and resolve it back to check whether -- we have a conflicting field name. cn <- toConcreteName v - liftTCM (resolveName' [FldName] Nothing (C.QName cn)) >>= \case + resolveName (someKindsOfNames [FldName]) Nothing (C.QName cn) >>= \ case -- If we do then we print .(v) rather than .v - FieldName{} -> do + Right FieldName{} -> do reportSLn "print.dotted" 50 $ "Wrapping ambiguous name " ++ show (nameConcrete v) C.DotP r . C.Paren r <$> toConcrete (A.Var v) - _ -> printDotDefault i e + Right _ -> printDotDefault i e + Left _ -> __IMPOSSIBLE__ A.DotP i e -> printDotDefault i e @@ -1263,7 +1357,7 @@ -- we take off the exceeding arguments first -- and apply them pointwise with C.AppP later. let (args1, args2) = splitAt (numHoles x) args - let funCtx = if null args2 then id else withPrecedence FunctionCtx + let funCtx = applyUnless (null args2) (withPrecedence FunctionCtx) tryToRecoverPatternSynP (f args) $ funCtx (tryToRecoverOpAppP $ f args1) >>= \case Just c -> applyTo args2 c Nothing -> applyTo args . C.IdentP =<< toConcrete x @@ -1271,6 +1365,9 @@ applyTo args c = bracketP_ (appBracketsArgs args) $ do foldl C.AppP c <$> toConcreteCtx argumentCtx_ args +instance ToConcrete (Maybe A.Pattern) (Maybe C.Pattern) where + toConcrete = traverse toConcrete + -- Helpers for recovering natural number literals tryToRecoverNatural :: A.Expr -> AbsToCon C.Expr -> AbsToCon C.Expr @@ -1337,13 +1434,13 @@ view e -- Do we have a series of inserted lambdas? | Just xs@(_:_) <- traverse insertedName bs = - (,) <$> getHead hd <*> sectionArgs (map unBind xs) args + (,) <$> getHead hd <*> sectionArgs (map (unBind . A.binderName) xs) args where LamView bs body = A.lamView e Application hd args = A.appView' body -- Only inserted domain-free visible lambdas come from sections. - insertedName (A.DomainFree x) + insertedName (A.DomainFree _ x) | getOrigin x == Inserted && visible x = Just $ namedArg x insertedName _ = Nothing @@ -1370,7 +1467,7 @@ tryToRecoverOpAppP :: A.Pattern -> AbsToCon (Maybe C.Pattern) tryToRecoverOpAppP p = do res <- recoverOpApp bracketP_ (const False) opApp view p - lift $ reportSLn "print.op" 90 $ unlines + reportS "print.op" 90 [ "tryToRecoverOpApp" , "in: " ++ show p , "out: " ++ show res @@ -1427,7 +1524,16 @@ doQNameHelper n args = do x <- either (C.QName <.> toConcrete) toConcrete n let n' = either id A.qnameName n - doQName (theFixity $ nameFixity n') x n' args (C.nameParts $ C.unqualify x) + -- #1346: The fixity of the abstract name is not necessarily correct, it depends on which + -- concrete name we choose! Make sure to resolve ambiguities with n'. + fx <- resolveName_ x [n'] <&> \ case + VarName y _ -> y ^. lensFixity + DefinedName _ q -> q ^. lensFixity + FieldName (q :| _) -> q ^. lensFixity + ConstructorName (q :| _) -> q ^. lensFixity + PatternSynResName (q :| _) -> q ^. lensFixity + UnknownName -> noFixity + doQName fx x n' args (C.nameParts $ C.unqualify x) doQName :: Fixity -> C.QName -> A.Name -> [MaybeSection (AppInfo, a)] -> [NamePart] -> AbsToCon (Maybe c) @@ -1517,14 +1623,28 @@ recoverPatternSyn applySyn match e fallback = do doFold <- asks foldPatternSynonyms if not doFold then fallback else do - psyns <- lift getAllPatternSyns - scope <- lift getScope + psyns <- getAllPatternSyns + scope <- getScope + reportSLn "toConcrete.patsyn" 100 $ render $ hsep $ + [ "Scope when attempting to recover pattern synonyms:" + , pretty scope + ] let isConP ConP{} = True -- #2828: only fold pattern synonyms with isConP _ = False -- constructor rhs - cands = [ (q, args, score rhs) | (q, psyndef@(_, rhs)) <- reverse $ Map.toList psyns, - isConP rhs, Just args <- [match psyndef e], - isNameInScope q scope ] + cands = [ (q, args, score rhs) + | (q, psyndef@(_, rhs)) <- reverse $ Map.toList psyns + , isConP rhs + , Just args <- [match psyndef e] + -- #3879: only fold pattern synonyms with an unqualified concrete name in scope + -- Note that we only need to consider the head of the inverse lookup result: they + -- are already sorted from shortest to longest! + , C.QName{} <- Fold.toList $ listToMaybe $ inverseScopeLookupName q scope + ] cmp (_, _, x) (_, _, y) = flip compare x y + reportSLn "toConcrete.patsyn" 50 $ render $ hsep $ + [ "Found pattern synonym candidates:" + , prettyList_ $ map (\ (q,_,_) -> q) cands + ] case sortBy cmp cands of (q, args, _) : _ -> toConcrete $ applySyn q $ (map . fmap) unnamed args [] -> fallback diff --git a/src/full/Agda/Syntax/Translation/ConcreteToAbstract.hs b/src/full/Agda/Syntax/Translation/ConcreteToAbstract.hs --- a/src/full/Agda/Syntax/Translation/ConcreteToAbstract.hs +++ b/src/full/Agda/Syntax/Translation/ConcreteToAbstract.hs @@ -1,4 +1,4 @@ -{-# LANGUAGE CPP #-} +{-# LANGUAGE TypeFamilies #-} -- for type equality ~ {-# LANGUAGE UndecidableInstances #-} {-| Translation from "Agda.Syntax.Concrete" to "Agda.Syntax.Abstract". Involves scope analysis, @@ -16,15 +16,10 @@ , AbstractRHS , NewModuleName, OldModuleName , NewName, OldQName - , LeftHandSide, RightHandSide , PatName, APatName ) where -#if MIN_VERSION_base(4,11,0) -import Prelude hiding ( (<>), mapM, null ) -#else import Prelude hiding ( mapM, null ) -#endif import Control.Applicative import Control.Arrow (second) @@ -32,10 +27,11 @@ import Data.Foldable (Foldable, traverse_) import Data.Traversable (mapM, traverse) -import Data.List ((\\), nub, foldl') import Data.Set (Set) import Data.Map (Map) import qualified Data.List as List +import Data.List.NonEmpty (NonEmpty(..)) +import qualified Data.List.NonEmpty as NonEmpty import qualified Data.Set as Set import qualified Data.Map as Map import Data.Maybe @@ -57,20 +53,18 @@ import Agda.Syntax.Fixity import Agda.Syntax.Concrete.Fixity (DoWarn(..)) import Agda.Syntax.Notation -import Agda.Syntax.Scope.Base +import Agda.Syntax.Scope.Base as A import Agda.Syntax.Scope.Monad import Agda.Syntax.Translation.AbstractToConcrete (ToConcrete) import Agda.Syntax.DoNotation import Agda.Syntax.IdiomBrackets import Agda.TypeChecking.Monad.Base hiding (ModuleInfo, MetaInfo) -import qualified Agda.TypeChecking.Monad.Benchmark as Bench import Agda.TypeChecking.Monad.Builtin import Agda.TypeChecking.Monad.Trace (traceCall, setCurrentRange) import Agda.TypeChecking.Monad.State import Agda.TypeChecking.Monad.MetaVars (registerInteractionPoint) import Agda.TypeChecking.Monad.Debug -import Agda.TypeChecking.Monad.Options import Agda.TypeChecking.Monad.Env (insideDotPattern, isInsideDotPattern, getCurrentPath) import Agda.TypeChecking.Rules.Builtin (isUntypedBuiltin, bindUntypedBuiltin, builtinKindOfName) @@ -78,14 +72,13 @@ import Agda.TypeChecking.Pretty hiding (pretty, prettyA) import Agda.TypeChecking.Warnings -import Agda.Interaction.FindFile (checkModuleName) +import Agda.Interaction.FindFile (checkModuleName, rootNameModule, SourceFile(SourceFile)) -- import Agda.Interaction.Imports -- for type-checking in ghci import {-# SOURCE #-} Agda.Interaction.Imports (scopeCheckImport) import Agda.Interaction.Options import qualified Agda.Interaction.Options.Lenses as Lens import Agda.Interaction.Options.Warnings -import Agda.Utils.AssocList (AssocList) import qualified Agda.Utils.AssocList as AssocList import Agda.Utils.Either import Agda.Utils.Except ( MonadError(catchError, throwError) ) @@ -95,14 +88,12 @@ import Agda.Utils.List import Agda.Utils.Maybe import Agda.Utils.Monad -import Agda.Utils.NonemptyList import Agda.Utils.Null import qualified Agda.Utils.Pretty as P import Agda.Utils.Pretty (render, Pretty, pretty, prettyShow) +import Agda.Utils.Singleton import Agda.Utils.Tuple -import Agda.Interaction.FindFile ( rootNameModule ) -#include "undefined.h" import Agda.Utils.Impossible import Agda.ImpossibleTest (impossibleTest) @@ -127,9 +118,9 @@ {-------------------------------------------------------------------------- Helpers --------------------------------------------------------------------------} - -annotateDecl :: ScopeM A.Declaration -> ScopeM A.Declaration -annotateDecl m = annotateDecls $ (:[]) <$> m +--UNUSED Liang-Ting Chen 2019-07-16 +--annotateDecl :: ScopeM A.Declaration -> ScopeM A.Declaration +--annotateDecl m = annotateDecls $ (:[]) <$> m annotateDecls :: ScopeM [A.Declaration] -> ScopeM A.Declaration annotateDecls m = do @@ -162,10 +153,10 @@ A.PatternSynP i c args -> A.PatternSynP i c <$> (traverse $ traverse $ traverse dot) args A.RecP i fs -> A.RecP i <$> (traverse $ traverse dot) fs A.WithP i p -> A.WithP i <$> dot p - --- | Make sure that there are no dot patterns (WAS: called on pattern synonyms). -noDotPattern :: String -> A.Pattern' e -> ScopeM (A.Pattern' Void) -noDotPattern err = traverse $ const $ genericError err +--UNUSED Liang-Ting Chen 2019-07-16 +---- | Make sure that there are no dot patterns (WAS: called on pattern synonyms). +--noDotPattern :: String -> A.Pattern' e -> ScopeM (A.Pattern' Void) +--noDotPattern err = traverse $ const $ genericError err newtype RecordConstructorType = RecordConstructorType [C.Declaration] @@ -199,25 +190,25 @@ mkLet d = A.TLet r <$> toAbstract (LetDef d) traceCall (SetRange r) $ case d of - C.NiceField r pr ab inst x a -> do + C.NiceField r pr ab inst tac x a -> do fx <- getConcreteFixity x - let bv = unnamed (C.mkBoundName x fx) <$ a + let bv = unnamed (C.mkBinder $ (C.mkBoundName x fx) { bnameTactic = tac }) <$ a tel <- toAbstract $ C.TBind r [bv] (unArg a) return tel -- Public open is allowed and will take effect when scope checking as -- proper declarations. C.NiceOpen r m dir -> do - mkLet $ C.NiceOpen r m dir{ publicOpen = False } + mkLet $ C.NiceOpen r m dir{ publicOpen = Nothing } C.NiceModuleMacro r p x modapp open dir -> do - mkLet $ C.NiceModuleMacro r p x modapp open dir{ publicOpen = False } + mkLet $ C.NiceModuleMacro r p x modapp open dir{ publicOpen = Nothing } -- Do some rudimentary matching here to get NotValidBeforeField instead -- of NotAValidLetDecl. - C.NiceMutual _ _ _ - [ C.FunSig _ _ _ _instanc macro _info _ _ _ - , C.FunDef _ _ abstract _ _ _ - [ C.Clause _top _catchall (C.LHS _p [] []) (C.RHS _rhs) NoWhere [] ] + C.NiceMutual _ _ _ _ + [ C.FunSig _ _ _ _ macro _ _ _ _ _ + , C.FunDef _ _ abstract _ _ _ _ + [ C.Clause _ _ (C.LHS _p [] [] NoEllipsis) (C.RHS _) NoWhere [] ] ] | abstract /= AbstractDef && macro /= MacroDef -> do mkLet d @@ -261,13 +252,9 @@ -- Scope check the old module name and the module args. m1 <- toAbstract $ OldModuleName m args' <- toAbstractCtx (ArgumentCtx PreferParen) args - -- Drop constructors (OnlyQualified) if there are arguments. The record constructor - -- isn't properly in the record module, so copying it will lead to badness. - let noRecConstr | null args = id - | otherwise = removeOnlyQualified -- Copy the scope associated with m and take the parts actually imported. (adir, s) <- applyImportDirectiveM (C.QName x) dir' =<< getNamedScope m1 - (s', copyInfo) <- copyScope m m0 (noRecConstr s) + (s', copyInfo) <- copyScope m m0 s -- Set the current scope to @s'@ modifyCurrentScope $ const s' printScope "mod.inst" 20 "copied source module" @@ -286,7 +273,7 @@ m1 <- toAbstract $ OldModuleName recN s <- getNamedScope m1 (adir, s) <- applyImportDirectiveM recN dir' s - (s', copyInfo) <- copyScope recN m0 (removeOnlyQualified s) + (s', copyInfo) <- copyScope recN m0 s modifyCurrentScope $ const s' printScope "mod.inst" 20 "copied record module" @@ -316,7 +303,7 @@ reportSDoc "scope.decl" 70 $ vcat $ [ text $ "scope checking ModuleMacro " ++ prettyShow x ] - notPublicWithoutOpen open dir + dir <- notPublicWithoutOpen open dir m0 <- toAbstract (NewModuleName x) reportSDoc "scope.decl" 90 $ "NewModuleName: m0 =" <+> prettyA m0 @@ -328,7 +315,7 @@ -- "public" is always applied to the "open". let (moduleDir, openDir) = case (open, isNoName x) of (DoOpen, False) -> (defaultImportDir, dir) - (DoOpen, True) -> ( dir { publicOpen = False } + (DoOpen, True) -> ( dir { publicOpen = Nothing } , defaultImportDir { publicOpen = publicOpen dir } ) (DontOpen, _) -> (dir, defaultImportDir) @@ -346,10 +333,10 @@ printScope "mod.inst.copy.after" 20 "after copying" -- Open the module if DoOpen. - -- Andreas, 2014-09-02 openModule_ might shadow some locals! + -- Andreas, 2014-09-02: @openModule@ might shadow some locals! adir <- case open of DontOpen -> return adir' - DoOpen -> openModule_ kind (C.QName x) openDir + DoOpen -> openModule kind (Just m0) (C.QName x) openDir printScope "mod.inst" 20 $ show open reportSDoc "scope.decl" 90 $ "after open : m0 =" <+> prettyA m0 @@ -381,10 +368,12 @@ -- | The @public@ keyword must only be used together with @open@. -notPublicWithoutOpen :: OpenShortHand -> C.ImportDirective -> ScopeM () -notPublicWithoutOpen DoOpen dir = return () -notPublicWithoutOpen DontOpen dir = when (publicOpen dir) $ genericError - "The public keyword must only be used together with the open keyword" +notPublicWithoutOpen :: OpenShortHand -> C.ImportDirective -> ScopeM C.ImportDirective +notPublicWithoutOpen DoOpen dir = return dir +notPublicWithoutOpen DontOpen dir = do + whenJust (publicOpen dir) $ \ r -> + setCurrentRange r $ warning UselessPublic + return $ dir { publicOpen = Nothing } -- | Computes the range of all the \"to\" keywords used in a renaming -- directive. @@ -394,9 +383,12 @@ -- | Scope check a 'NiceOpen'. checkOpen - :: Range -> C.QName -> C.ImportDirective -- ^ Arguments of 'NiceOpen' + :: Range -- ^ Range of @open@ statement. + -> Maybe A.ModuleName -- ^ Resolution of concrete module name (if already resolved). + -> C.QName -- ^ Module to open. + -> C.ImportDirective -- ^ Scope modifier. -> ScopeM (ModuleInfo, A.ModuleName, A.ImportDirective) -- ^ Arguments of 'A.Open' -checkOpen r x dir = do +checkOpen r mam x dir = do reportSDoc "scope.decl" 70 $ do cm <- getCurrentModule vcat $ @@ -406,13 +398,13 @@ , text $ " C.ImportDirective = " ++ prettyShow dir ] -- Andreas, 2017-01-01, issue #2377: warn about useless `public` - when (publicOpen dir) $ do + whenJust (publicOpen dir) $ \ r -> do whenM ((A.noModuleName ==) <$> getCurrentModule) $ do - warning $ UselessPublic + setCurrentRange r $ warning UselessPublic - m <- toAbstract (OldModuleName x) + m <- caseMaybe mam (toAbstract (OldModuleName x)) return printScope "open" 20 $ "opening " ++ prettyShow x - adir <- openModule_ TopOpenModule x dir + adir <- openModule TopOpenModule (Just m) x dir printScope "open" 20 $ "result:" let minfo = ModuleInfo { minfoRange = r @@ -448,22 +440,24 @@ Precedence -> concrete -> ScopeM abstract toAbstractCtx ctx c = withContextPrecedence ctx $ toAbstract c -toAbstractTopCtx :: ToAbstract c a => c -> ScopeM a -toAbstractTopCtx = toAbstractCtx TopCtx +--UNUSED Liang-Ting Chen 2019-07-16 +--toAbstractTopCtx :: ToAbstract c a => c -> ScopeM a +--toAbstractTopCtx = toAbstractCtx TopCtx toAbstractHiding :: (LensHiding h, ToAbstract c a) => h -> c -> ScopeM a toAbstractHiding h | visible h = toAbstract -- don't change precedence if visible toAbstractHiding _ = toAbstractCtx TopCtx -setContextCPS :: Precedence -> (a -> ScopeM b) -> - ((a -> ScopeM b) -> ScopeM b) -> ScopeM b -setContextCPS p ret f = do - old <- scopePrecedence <$> getScope - withContextPrecedence p $ f $ \ x -> setContextPrecedence old >> ret x - -localToAbstractCtx :: ToAbstract concrete abstract => - Precedence -> concrete -> (abstract -> ScopeM a) -> ScopeM a -localToAbstractCtx ctx c ret = setContextCPS ctx ret (localToAbstract c) +--UNUSED Liang-Ting Chen 2019-07-16 +--setContextCPS :: Precedence -> (a -> ScopeM b) -> +-- ((a -> ScopeM b) -> ScopeM b) -> ScopeM b +--setContextCPS p ret f = do +-- old <- useScope scopePrecedence +-- withContextPrecedence p $ f $ \ x -> setContextPrecedence old >> ret x +-- +--localToAbstractCtx :: ToAbstract concrete abstract => +-- Precedence -> concrete -> (abstract -> ScopeM a) -> ScopeM a +--localToAbstractCtx ctx c ret = setContextCPS ctx ret (localToAbstract c) -- | This operation does not affect the scope, i.e. the original scope -- is restored upon completion. @@ -477,6 +471,9 @@ scope <- getScope withScope scope $ ret =<< toAbstract x +instance ToAbstract () () where + toAbstract = pure + instance (ToAbstract c1 a1, ToAbstract c2 a2) => ToAbstract (c1,c2) (a1,a2) where toAbstract (x,y) = (,) <$> toAbstract x <*> toAbstract y @@ -499,13 +496,20 @@ -- Names ------------------------------------------------------------------ data NewName a = NewName - { newBinder :: Binder -- what kind of binder? + { newBinder :: A.BindingSource -- what kind of binder? , newName :: a - } + } deriving (Functor) -data OldQName = OldQName C.QName (Maybe (Set A.Name)) - -- ^ If a set is given, then the first name must correspond to one - -- of the names in the set. +data OldQName = OldQName + C.QName -- ^ Concrete name to be resolved + (Maybe (Set A.Name)) -- ^ If a set is given, then the first name must + -- correspond to one of the names in the set. + +-- | We sometimes do not want to fail hard if the name is not actually +-- in scope because we have a strategy to recover from this problem +-- (e.g. drop the offending COMPILE pragma) +data MaybeOldQName = MaybeOldQName OldQName + newtype OldName a = OldName a -- | Wrapper to resolve a name to a 'ResolvedName' (rather than an 'A.Expr'). @@ -522,17 +526,21 @@ return y instance ToAbstract (NewName C.BoundName) A.BindName where - toAbstract (NewName b BName{ boundName = x, bnameFixity = fx }) = do + toAbstract NewName{ newBinder = b, newName = BName{ boundName = x, bnameFixity = fx }} = do y <- freshAbstractName fx x bindVariable b x y return $ A.BindName y instance ToAbstract OldQName A.Expr where - toAbstract (OldQName x ns) = do + toAbstract q@(OldQName x _) = + fromMaybeM (notInScopeError x) $ toAbstract (MaybeOldQName q) + +instance ToAbstract MaybeOldQName (Maybe A.Expr) where + toAbstract (MaybeOldQName (OldQName x ns)) = do qx <- resolveName' allKindsOfNames ns x reportSLn "scope.name" 10 $ "resolved " ++ prettyShow x ++ ": " ++ prettyShow qx case qx of - VarName x' _ -> return $ A.Var x' + VarName x' _ -> return $ Just $ A.Var x' DefinedName _ d -> do -- In case we find a defined name, we start by checking whether there's -- a warning attached to it @@ -553,31 +561,31 @@ text "Cannot use generalized variable from let-opened module:" <+> prettyTCM (anameName d) _ -> return () -- and then we return the name - return $ nameExpr d - FieldName ds -> return $ A.Proj ProjPrefix $ AmbQ (fmap anameName ds) - ConstructorName ds -> return $ A.Con $ AmbQ (fmap anameName ds) - UnknownName -> notInScope x - PatternSynResName ds -> return $ A.PatternSyn $ AmbQ (fmap anameName ds) + return $ Just $ nameToExpr d + FieldName ds -> return $ Just $ A.Proj ProjPrefix $ AmbQ (fmap anameName ds) + ConstructorName ds -> return $ Just $ A.Con $ AmbQ (fmap anameName ds) + UnknownName -> pure Nothing + PatternSynResName ds -> return $ Just $ A.PatternSyn $ AmbQ (fmap anameName ds) instance ToAbstract ResolveQName ResolvedName where toAbstract (ResolveQName x) = resolveName x >>= \case - UnknownName -> notInScope x + UnknownName -> notInScopeError x q -> return q data APatName = VarPatName A.Name - | ConPatName (NonemptyList AbstractName) - | PatternSynPatName (NonemptyList AbstractName) + | ConPatName (NonEmpty AbstractName) + | PatternSynPatName (NonEmpty AbstractName) instance ToAbstract PatName APatName where toAbstract (PatName x ns) = do reportSLn "scope.pat" 10 $ "checking pattern name: " ++ prettyShow x - rx <- resolveName' [ConName, PatternSynName] ns x + rx <- resolveName' (someKindsOfNames [ConName, PatternSynName]) ns x -- Andreas, 2013-03-21 ignore conflicting names which cannot -- be meant since we are in a pattern case (rx, x) of (VarName y _, C.QName x) -> bindPatVar x (FieldName d, C.QName x) -> bindPatVar x - (DefinedName _ d, C.QName x) | DefName == anameKind d -> bindPatVar x + (DefinedName _ d, C.QName x) | isDefName (anameKind d)-> bindPatVar x (UnknownName, C.QName x) -> bindPatVar x (ConstructorName ds, _) -> patCon ds (PatternSynResName d, _) -> patSyn d @@ -615,11 +623,11 @@ case rx of DefinedName _ d -> return $ anameName d -- We can get the cases below for DISPLAY pragmas - ConstructorName ds -> return $ anameName (headNe ds) -- We'll throw out this one, so it doesn't matter which one we pick - FieldName ds -> return $ anameName (headNe ds) - PatternSynResName ds -> return $ anameName (headNe ds) + ConstructorName ds -> return $ anameName (NonEmpty.head ds) -- We'll throw out this one, so it doesn't matter which one we pick + FieldName ds -> return $ anameName (NonEmpty.head ds) + PatternSynResName ds -> return $ anameName (NonEmpty.head ds) VarName x _ -> genericError $ "Not a defined name: " ++ prettyShow x - UnknownName -> notInScope (toQName x) + UnknownName -> notInScopeError (toQName x) newtype NewModuleName = NewModuleName C.Name newtype NewModuleQName = NewModuleQName C.QName @@ -630,7 +638,7 @@ checkForModuleClash :: C.Name -> ScopeM () checkForModuleClash x = do - ms <- scopeLookup (C.QName x) <$> getScope + ms :: [AbstractModule] <- scopeLookup (C.QName x) <$> getScope unless (null ms) $ do reportSLn "scope.clash" 20 $ "clashing modules ms = " ++ prettyShow ms reportSLn "scope.clash" 60 $ "clashing modules ms = " ++ show ms @@ -662,53 +670,48 @@ amodName <$> resolveModule q -- Expressions ------------------------------------------------------------ - --- | Peel off 'C.HiddenArg' and represent it as an 'NamedArg'. -mkNamedArg :: C.Expr -> NamedArg C.Expr -mkNamedArg (C.HiddenArg _ e) = Arg (hide defaultArgInfo) e -mkNamedArg (C.InstanceArg _ e) = Arg (makeInstance defaultArgInfo) e -mkNamedArg e = Arg defaultArgInfo $ unnamed e +--UNUSED Liang-Ting Chen 2019-07-16 +---- | Peel off 'C.HiddenArg' and represent it as an 'NamedArg'. +--mkNamedArg :: C.Expr -> NamedArg C.Expr +--mkNamedArg (C.HiddenArg _ e) = Arg (hide defaultArgInfo) e +--mkNamedArg (C.InstanceArg _ e) = Arg (makeInstance defaultArgInfo) e +--mkNamedArg e = Arg defaultArgInfo $ unnamed e -- | Peel off 'C.HiddenArg' and represent it as an 'Arg', throwing away any name. mkArg' :: ArgInfo -> C.Expr -> Arg C.Expr mkArg' info (C.HiddenArg _ e) = Arg (hide info) $ namedThing e mkArg' info (C.InstanceArg _ e) = Arg (makeInstance info) $ namedThing e mkArg' info e = Arg (setHiding NotHidden info) e - --- | By default, arguments are @Relevant@. -mkArg :: C.Expr -> Arg C.Expr -mkArg e = mkArg' defaultArgInfo e +--UNUSED Liang-Ting 2019-07-16 +---- | By default, arguments are @Relevant@. +--mkArg :: C.Expr -> Arg C.Expr +--mkArg e = mkArg' defaultArgInfo e inferParenPreference :: C.Expr -> ParenPreference inferParenPreference C.Paren{} = PreferParen inferParenPreference _ = PreferParenless --- | Parse a possibly dotted C.Expr as A.Expr. Bool = True if dotted. -toAbstractDot :: Precedence -> C.Expr -> ScopeM (A.Expr, Bool) +-- | Parse a possibly dotted @C.Expr@ as @A.Expr@, interpreting dots as relevance. +toAbstractDot :: Precedence -> C.Expr -> ScopeM (A.Expr, Relevance) toAbstractDot prec e = do reportSLn "scope.irrelevance" 100 $ "toAbstractDot: " ++ (render $ pretty e) traceCall (ScopeCheckExpr e) $ case e of - C.Dot _ e -> do - e <- toAbstractCtx prec e - return (e, True) - - C.RawApp r es -> do - e <- parseApplication es - toAbstractDot prec e - - C.Paren _ e -> toAbstractDot TopCtx e - - e -> do - e <- toAbstractCtx prec e - return (e, False) + C.RawApp _ es -> toAbstractDot prec =<< parseApplication es + C.Paren _ e -> toAbstractDot TopCtx e + C.Dot _ e -> (,Irrelevant) <$> toAbstractCtx prec e + C.DoubleDot _ e -> (,NonStrict) <$> toAbstractCtx prec e + e -> (,Relevant) <$> toAbstractCtx prec e -- | Translate concrete expression under at least one binder into nested -- lambda abstraction in abstract syntax. toAbstractLam :: Range -> [C.LamBinding] -> C.Expr -> Precedence -> ScopeM A.Expr toAbstractLam r bs e ctx = do -- Translate the binders + lvars0 <- getLocalVars localToAbstract (map (C.DomainFull . makeDomainFull) bs) $ \ bs -> do + lvars1 <- getLocalVars + checkNoShadowing lvars0 lvars1 -- Translate the body e <- toAbstractCtx ctx e -- We have at least one binder. Get first @b@ and rest @bs@. @@ -724,17 +727,19 @@ genericError "Extended lambdas are not allowed in dot patterns" -- Find an unused name for the extended lambda definition. - cname <- nextlamname r 0 extendedLambdaName + cname <- freshConcreteName r 0 extendedLambdaName name <- freshAbstractName_ cname - reportSLn "scope.extendedLambda" 10 $ "new extended lambda name: " ++ prettyShow name + a <- asksTC (^. lensIsAbstract) + reportSDoc "scope.extendedLambda" 10 $ vcat + [ text $ "new extended lambda name (" ++ show a ++ "): " ++ prettyShow name + ] verboseS "scope.extendedLambda" 60 $ do forM_ cs $ \ c -> do reportSLn "scope.extendedLambda" 60 $ "extended lambda lhs: " ++ show (C.lamLHS c) qname <- qualifyName_ name - bindName (PrivateAccess Inserted) DefName cname qname + bindName (PrivateAccess Inserted) FunName cname qname -- Compose a function definition and scope check it. - a <- aModeToDef <$> asksTC envAbstractMode let insertApp :: C.Pattern -> ScopeM C.Pattern insertApp (C.RawAppP r es) = return $ C.RawAppP r $ IdentP (C.QName cname) : es @@ -763,7 +768,10 @@ -- _ -> __IMPOSSIBLE__ -- __IMPOSSIBLE__ - d <- C.FunDef r [] a NotInstanceDef __IMPOSSIBLE__ cname <$> do + -- Andreas, 2019-08-20 + -- Keep the following __IMPOSSIBLE__, which is triggered by -v scope.decl.trace:80, + -- for testing issue #4016. + d <- C.FunDef r [] a NotInstanceDef __IMPOSSIBLE__ __IMPOSSIBLE__ cname <$> do forM cs $ \ (LamClause lhs rhs wh ca) -> do -- wh == NoWhere, see parser for more info lhs' <- mapLhsOriginalPatternM insertApp lhs return $ C.Clause cname ca lhs' rhs wh [] @@ -776,15 +784,7 @@ return $ A.ExtendedLam (ExprRange r) di qname' cs _ -> __IMPOSSIBLE__ - where - -- Get a concrete name that is not yet in scope. - nextlamname :: Range -> Int -> String -> ScopeM C.Name - nextlamname r i s = do - let cname = C.Name r C.NotInScope [Id $ stringToRawName $ s ++ show i] - rn <- resolveName $ C.QName cname - case rn of - UnknownName -> return cname - _ -> nextlamname r (i+1) s +-- | Scope check an expression. instance ToAbstract C.Expr A.Expr where toAbstract e = @@ -876,17 +876,21 @@ -- Relevant and irrelevant non-dependent function type C.Fun r (Arg info1 e1) e2 -> do - Arg info (e0, dotted) <- traverse (toAbstractDot FunctionSpaceDomainCtx) $ mkArg' info1 e1 - let e1 = Arg ((if dotted then setRelevance Irrelevant else id) info) e0 - e2 <- toAbstractCtx TopCtx e2 - return $ A.Fun (ExprRange r) e1 e2 + Arg info (e1', rel) <- traverse (toAbstractDot FunctionSpaceDomainCtx) $ mkArg' info1 e1 + let updRel = case rel of + Relevant -> id + rel -> setRelevance rel + A.Fun (ExprRange r) (Arg (updRel info) e1') <$> toAbstractCtx TopCtx e2 -- Dependent function type - e0@(C.Pi tel e) -> + e0@(C.Pi tel e) -> do + lvars0 <- getLocalVars localToAbstract tel $ \tel -> do - e <- toAbstractCtx TopCtx e - let info = ExprRange (getRange e0) - return $ A.Pi info tel e + lvars1 <- getLocalVars + checkNoShadowing lvars0 lvars1 + e <- toAbstractCtx TopCtx e + let info = ExprRange (getRange e0) + return $ A.Pi info tel e -- Sorts C.Set _ -> return $ A.Set (ExprRange $ getRange e) 0 @@ -919,8 +923,8 @@ C.Paren _ e -> toAbstractCtx TopCtx e -- Idiom brackets - C.IdiomBrackets r e -> - toAbstractCtx TopCtx =<< parseIdiomBrackets r e + C.IdiomBrackets r es -> + toAbstractCtx TopCtx =<< parseIdiomBracketsSeq r es -- Do notation C.DoBlock r ss -> @@ -937,22 +941,18 @@ C.ETel _ -> __IMPOSSIBLE__ C.Equal{} -> genericError "Parse error: unexpected '='" C.Ellipsis _ -> genericError "Parse error: unexpected '...'" + C.DoubleDot _ _ -> genericError "Parse error: unexpected '..'" -- Quoting - C.QuoteGoal _ x e -> do - x' <- toAbstract (NewName LetBound x) - e' <- toAbstract e - return $ A.QuoteGoal (ExprRange $ getRange e) x' e' - C.QuoteContext r -> return $ A.QuoteContext (ExprRange r) C.Quote r -> return $ A.Quote (ExprRange r) C.QuoteTerm r -> return $ A.QuoteTerm (ExprRange r) C.Unquote r -> return $ A.Unquote (ExprRange r) - C.Tactic r e es -> do + C.Tactic r e -> do let AppView e' args = appView e - e' : es <- toAbstract (e' : es) - args <- toAbstract args - return $ A.Tactic (ExprRange r) e' args (map defaultNamedArg es) + e' <- toAbstract e' + args <- toAbstract args + return $ A.Tactic (ExprRange r) e' args -- DontCare C.DontCare e -> A.DontCare <$> toAbstract e @@ -977,8 +977,29 @@ instance ToAbstract c a => ToAbstract (FieldAssignment' c) (FieldAssignment' a) where toAbstract = traverse toAbstract +instance ToAbstract (C.Binder' (NewName C.BoundName)) A.Binder where + toAbstract (C.Binder p n) = do + let name = C.boundName $ newName n + -- If we do have a pattern then the variable needs to be inserted + -- so we do need a proper internal name for it. + n <- if not (isNoName name && isJust p) then pure n else do + n' <- freshConcreteName (getRange $ newName n) 0 patternInTeleName + pure $ fmap (\ n -> n { C.boundName = n' }) n + n <- toAbstract n + -- Actually parsing the pattern, checking it is linear, + -- and bind its variables + p <- traverse parsePattern p + p <- toAbstract p + checkPatternLinearity p $ \ys -> + typeError $ RepeatedVariablesInPattern ys + bindVarsToBind + p <- toAbstract p + pure $ A.Binder p n + instance ToAbstract C.LamBinding A.LamBinding where - toAbstract (C.DomainFree x) = A.DomainFree <$> toAbstract ((fmap . fmap) (NewName LambdaBound) x) + toAbstract (C.DomainFree x) = do + tac <- traverse toAbstract $ bnameTactic $ C.binderName $ namedArg x + A.DomainFree tac <$> toAbstract (updateNamedArg (fmap $ NewName LambdaBound) x) toAbstract (C.DomainFull tb) = A.DomainFull <$> toAbstract tb makeDomainFull :: C.LamBinding -> C.TypedBinding @@ -989,8 +1010,14 @@ instance ToAbstract C.TypedBinding A.TypedBinding where toAbstract (C.TBind r xs t) = do t' <- toAbstractCtx TopCtx t - xs' <- toAbstract $ (map . fmap . fmap) (NewName LambdaBound) xs - return $ A.TBind r xs' t' + tac <- traverse toAbstract $ + case mapMaybe (bnameTactic . C.binderName . namedArg) xs of + [] -> Nothing + tac : _ -> Just tac + -- Invariant: all tactics are the same + -- (distributed in the parser, TODO: don't) + xs' <- toAbstract $ map (updateNamedArg (fmap $ NewName LambdaBound)) xs + return $ A.TBind r tac xs' t' toAbstract (C.TLet r ds) = A.TLet r <$> toAbstract (LetDefs ds) -- | Scope check a module (top level function). @@ -1039,8 +1066,8 @@ -- unless it's private, in which case we just open it (#2099) when open $ void $ -- We can discard the returned default A.ImportDirective. - openModule_ TopOpenModule (C.QName name) $ - defaultImportDir { publicOpen = p == PublicAccess } + openModule TopOpenModule (Just aname) (C.QName name) $ + defaultImportDir { publicOpen = boolToMaybe (p == PublicAccess) noRange } return ds -- | Check whether a telescope has open declarations or module macros. @@ -1079,22 +1106,29 @@ class EnsureNoLetStms a where ensureNoLetStms :: a -> ScopeM () -{- From ghc 7.2, there is LANGUAGE DefaultSignatures - default ensureNoLetStms :: Foldable t => t a -> ScopeM () + default ensureNoLetStms :: (Foldable t, EnsureNoLetStms b, t b ~ a) => a -> ScopeM () ensureNoLetStms = traverse_ ensureNoLetStms --} +instance EnsureNoLetStms C.Binder where + ensureNoLetStms arg@(C.Binder p n) = + when (isJust p) $ typeError $ IllegalPatternInTelescope arg + instance EnsureNoLetStms C.TypedBinding where - ensureNoLetStms tb = - case tb of - C.TLet{} -> typeError $ IllegalLetInTelescope tb - C.TBind{} -> return () + ensureNoLetStms = \case + tb@C.TLet{} -> typeError $ IllegalLetInTelescope tb + C.TBind _ xs _ -> traverse_ (ensureNoLetStms . namedArg) xs instance EnsureNoLetStms a => EnsureNoLetStms (LamBinding' a) where - ensureNoLetStms = traverse_ ensureNoLetStms + ensureNoLetStms = \case + -- GA: DO NOT use traverse here: `LamBinding'` only uses its parameter in + -- the DomainFull constructor so we would miss out on some potentially + -- illegal lets! Cf. #4402 + C.DomainFree a -> ensureNoLetStms a + C.DomainFull a -> ensureNoLetStms a +instance EnsureNoLetStms a => EnsureNoLetStms (Named_ a) where +instance EnsureNoLetStms a => EnsureNoLetStms (NamedArg a) where instance EnsureNoLetStms a => EnsureNoLetStms [a] where - ensureNoLetStms = traverse_ ensureNoLetStms -- | Returns the scope inside the checked module. @@ -1146,7 +1180,7 @@ -- | The top-level module name. topLevelModuleName :: TopLevelInfo -> A.ModuleName -topLevelModuleName = scopeCurrent . topLevelScope +topLevelModuleName = (^. scopeCurrent) . topLevelScope -- | Top-level declarations are always -- @ @@ -1205,7 +1239,7 @@ -- We need to check the module name against the file name here. -- Otherwise one could sneak in a lie and confuse the scope -- checker. - checkModuleName (C.toTopLevelModuleName m0) file $ Just expectedMName + checkModuleName (C.toTopLevelModuleName m0) (SourceFile file) $ Just expectedMName return m0 setTopLevelModule m am <- toAbstract (NewModuleQName m) @@ -1213,7 +1247,7 @@ outsideDecls <- toAbstract outsideDecls (insideScope, insideDecls) <- scopeCheckModule r m am tel $ toAbstract insideDecls - let scope = mapScopeInfo (restrictLocalPrivate am) insideScope + let scope = over scopeModules (fmap $ restrictLocalPrivate am) insideScope setScope scope return $ TopLevelInfo (outsideDecls ++ insideDecls) scope @@ -1225,7 +1259,7 @@ -- | runs Syntax.Concrete.Definitions.niceDeclarations on main module niceDecls :: DoWarn -> [C.Declaration] -> ([NiceDeclaration] -> ScopeM a) -> ScopeM a niceDecls warn ds ret = setCurrentRange ds $ computeFixitiesAndPolarities warn ds $ do - fixs <- scopeFixities <$> getScope -- We need to pass the fixities to the nicifier for clause grouping + fixs <- useScope scopeFixities -- We need to pass the fixities to the nicifier for clause grouping let (result, warns') = runNice $ niceDeclarations fixs ds -- COMPILED pragmas are not allowed in safe mode unless we are in a builtin module. @@ -1235,16 +1269,13 @@ isBuiltin <- Lens.isBuiltinModule . filePath =<< getCurrentPath let warns = if isSafe && not isBuiltin then warns' else filter notOnlyInSafeMode warns' - unless (null warns) $ do + -- Respect the @DoWarn@ directive. For this to be sound, we need to know for + -- sure that each @Declaration@ is checked at least once with @DoWarn@. + unless (warn == NoWarn || null warns) $ do -- If there are some warnings and the --safe flag is set, -- we check that none of the NiceWarnings are fatal when isSafe $ do - let isUnsafe w = declarationWarningName w `elem` - [ PragmaNoTerminationCheck_ - , PragmaCompiled_ - , MissingDefinitions_ - ] - let (errs, ws) = List.partition isUnsafe warns + let (errs, ws) = List.partition unsafeDeclarationWarning warns -- If some of them are, we fail unless (null errs) $ do warnings $ NicifierIssue <$> ws @@ -1260,39 +1291,73 @@ instance {-# OVERLAPPING #-} ToAbstract [C.Declaration] [A.Declaration] where toAbstract ds = do - -- When --safe is active the termination checker (Issue 586) and - -- positivity checker (Issue 1614) may not be switched off, and - -- polarities may not be assigned. - ds <- ifM (Lens.getSafeMode <$> commandLineOptions) - (mapM (noNoTermCheck >=> noNoPositivityCheck >=> noPolarity >=> noNoUniverseCheck) ds) - (return ds) + -- When --safe is active the termination checker (Issue 586), + -- positivity checker (Issue 1614) and the coverage checker + -- may not be switched off, and polarities may not be assigned. + ds <- ifM (Lens.getSafeMode <$> pragmaOptions) + {- then -} (mapM noUnsafePragma ds) + {- else -} (return ds) + niceDecls DoWarn ds toAbstract where - -- ASR (31 December 2015). We don't pattern-match on - -- @NoTerminationCheck@ because the @NO_TERMINATION_CHECK@ pragma - -- was removed. See Issue 1763. - noNoTermCheck :: C.Declaration -> TCM C.Declaration - noNoTermCheck d@(C.Pragma (C.TerminationCheckPragma r NonTerminating)) = - d <$ (setCurrentRange d $ warning SafeFlagNonTerminating) - noNoTermCheck d@(C.Pragma (C.TerminationCheckPragma r Terminating)) = - d <$ (setCurrentRange d $ warning SafeFlagTerminating) - noNoTermCheck d = return d - noNoPositivityCheck :: C.Declaration -> TCM C.Declaration - noNoPositivityCheck d@(C.Pragma (C.NoPositivityCheckPragma _)) = - d <$ (setCurrentRange d $ warning SafeFlagNoPositivityCheck) - noNoPositivityCheck d = return d + -- We need to dig deep into a declaration, otherwise it is possible + -- to hide an illegal pragma in a block. Cf. Issue #3983 + noUnsafePragma :: C.Declaration -> TCM C.Declaration + noUnsafePragma = \case + C.Pragma pr -> warnUnsafePragma pr + C.RecordDef r n ind eta ins lams ds -> C.RecordDef r n ind eta ins lams <$> mapM noUnsafePragma ds + C.Record r n ind eta ins lams e ds -> C.Record r n ind eta ins lams e <$> mapM noUnsafePragma ds + C.Mutual r ds -> C.Mutual r <$> mapM noUnsafePragma ds + C.Abstract r ds -> C.Abstract r <$> mapM noUnsafePragma ds + C.Private r o ds -> C.Private r o <$> mapM noUnsafePragma ds + C.InstanceB r ds -> C.InstanceB r <$> mapM noUnsafePragma ds + C.Macro r ds -> C.Macro r <$> mapM noUnsafePragma ds + d -> pure d - noPolarity :: C.Declaration -> TCM C.Declaration - noPolarity d@(C.Pragma C.PolarityPragma{}) = - d <$ (setCurrentRange d $ warning SafeFlagPolarity) - noPolarity d = return d + warnUnsafePragma :: C.Pragma -> TCM C.Declaration + warnUnsafePragma pr = C.Pragma pr <$ do + ifM (Lens.isBuiltinModuleWithSafePostulates . filePath =<< getCurrentPath) + {- then -} (pure ()) + {- else -} $ case unsafePragma pr of + Nothing -> pure () + Just w -> setCurrentRange pr $ warning w - noNoUniverseCheck :: C.Declaration -> TCM C.Declaration - noNoUniverseCheck d@(C.Pragma (C.NoUniverseCheckPragma _)) = - d <$ (setCurrentRange d $ warning SafeFlagNoUniverseCheck) - noNoUniverseCheck d = return d + unsafePragma :: C.Pragma -> Maybe Warning + unsafePragma = \case + C.NoCoverageCheckPragma{} -> Just SafeFlagNoCoverageCheck + C.NoPositivityCheckPragma{} -> Just SafeFlagNoPositivityCheck + C.PolarityPragma{} -> Just SafeFlagPolarity + C.NoUniverseCheckPragma{} -> Just SafeFlagNoUniverseCheck + C.InjectivePragma{} -> Just SafeFlagInjective + C.TerminationCheckPragma _ m -> case m of + NonTerminating -> Just SafeFlagNonTerminating + Terminating -> Just SafeFlagTerminating + TerminationCheck -> Nothing + TerminationMeasure{} -> Nothing + -- ASR (31 December 2015). We don't pattern-match on + -- @NoTerminationCheck@ because the @NO_TERMINATION_CHECK@ pragma + -- was removed. See Issue #1763. + NoTerminationCheck -> Nothing + -- exhaustive match to get told by ghc we should have a look at this + -- when we add new pragmas. + C.OptionsPragma{} -> Nothing + C.BuiltinPragma{} -> Nothing + C.ForeignPragma{} -> Nothing + C.StaticPragma{} -> Nothing + C.InlinePragma{} -> Nothing + C.ImpossiblePragma{} -> Nothing + C.EtaPragma{} -> Just SafeFlagEta + C.WarningOnUsage{} -> Nothing + C.WarningOnImport{} -> Nothing + C.DisplayPragma{} -> Nothing + C.CatchallPragma{} -> Nothing + -- @RewritePragma@ already requires --rewriting which is incompatible with --safe + C.RewritePragma{} -> Nothing + -- @CompilePragma@ already handled in the nicifier + C.CompilePragma{} -> Nothing + newtype LetDefs = LetDefs [C.Declaration] newtype LetDef = LetDef NiceDeclaration @@ -1303,7 +1368,7 @@ instance ToAbstract LetDef [A.LetBinding] where toAbstract (LetDef d) = case d of - NiceMutual _ _ _ d@[C.FunSig _ _ _ instanc macro info _ x t, C.FunDef _ _ abstract _ _ _ [cl]] -> + NiceMutual _ _ _ _ d@[C.FunSig _ _ _ instanc macro info _ _ x t, C.FunDef _ _ abstract _ _ _ _ [cl]] -> do when (abstract == AbstractDef) $ do genericError $ "abstract not allowed in let expressions" when (macro == MacroDef) $ do @@ -1315,19 +1380,20 @@ x <- A.unBind <$> toAbstract (NewName LetBound $ mkBoundName x fx) (x', e) <- letToAbstract cl -- If InstanceDef set info to Instance - let info' | instanc == InstanceDef = makeInstance info - | otherwise = info + let info' = case instanc of + InstanceDef _ -> makeInstance info + NotInstanceDef -> info -- There are sometimes two instances of the -- let-bound variable, one declaration and one -- definition. The first list element below is -- used to highlight the declared instance in the -- right way (see Issue 1618). - return [ A.LetDeclaredVariable (A.BindName (setRange (getRange x') x)) - , A.LetBind (LetRange $ getRange d) info' (A.BindName x) t e + return [ A.LetDeclaredVariable (A.mkBindName (setRange (getRange x') x)) + , A.LetBind (LetRange $ getRange d) info' (A.mkBindName x) t e ] -- irrefutable let binding, like (x , y) = rhs - NiceFunClause r PublicAccess ConcreteDef termCheck catchall d@(C.FunClause lhs@(C.LHS p [] []) (C.RHS rhs) NoWhere ca) -> do + NiceFunClause r PublicAccess ConcreteDef tc cc catchall d@(C.FunClause lhs@(C.LHS p [] [] NoEllipsis) (C.RHS rhs) NoWhere ca) -> do mp <- setCurrentRange p $ (Right <$> parsePattern p) `catchError` @@ -1345,9 +1411,9 @@ Left err -> case definedName p of Nothing -> throwError err - Just x -> toAbstract $ LetDef $ NiceMutual r termCheck True - [ C.FunSig r PublicAccess ConcreteDef NotInstanceDef NotMacroDef defaultArgInfo termCheck x (C.Underscore (getRange x) Nothing) - , C.FunDef r __IMPOSSIBLE__ ConcreteDef NotInstanceDef __IMPOSSIBLE__ __IMPOSSIBLE__ + Just x -> toAbstract $ LetDef $ NiceMutual r tc cc YesPositivityCheck + [ C.FunSig r PublicAccess ConcreteDef NotInstanceDef NotMacroDef defaultArgInfo tc cc x (C.Underscore (getRange x) Nothing) + , C.FunDef r __IMPOSSIBLE__ ConcreteDef NotInstanceDef __IMPOSSIBLE__ __IMPOSSIBLE__ __IMPOSSIBLE__ [C.Clause x (ca || catchall) lhs (C.RHS rhs) NoWhere []] ] where @@ -1366,14 +1432,14 @@ definedName C.HiddenP{} = Nothing -- Not impossible, see issue #2291 definedName C.InstanceP{} = Nothing definedName C.WithP{} = Nothing - definedName C.RawAppP{} = __IMPOSSIBLE__ + definedName (C.RawAppP _ []) = __IMPOSSIBLE__ definedName C.AppP{} = __IMPOSSIBLE__ definedName C.OpAppP{} = __IMPOSSIBLE__ - definedName C.EllipsisP{} = __IMPOSSIBLE__ + definedName C.EllipsisP{} = Nothing -- Not impossible, see issue #3937 -- You can't open public in a let NiceOpen r x dirs -> do - when (publicOpen dirs) $ warning UselessPublic + whenJust (publicOpen dirs) $ \r -> setCurrentRange r $ warning UselessPublic m <- toAbstract (OldModuleName x) adir <- openModule_ LetOpenModule x dirs let minfo = ModuleInfo @@ -1386,14 +1452,14 @@ return [A.LetOpen minfo m adir] NiceModuleMacro r p x modapp open dir -> do - when (publicOpen dir) $ warning UselessPublic + whenJust (publicOpen dir) $ \ r -> setCurrentRange r $ warning UselessPublic -- Andreas, 2014-10-09, Issue 1299: module macros in lets need -- to be private checkModuleMacro LetApply LetOpenModule r (PrivateAccess Inserted) x modapp open dir _ -> notAValidLetBinding d where - letToAbstract (C.Clause top catchall clhs@(C.LHS p [] []) (C.RHS rhs) NoWhere []) = do + letToAbstract (C.Clause top catchall clhs@(C.LHS p [] [] NoEllipsis) (C.RHS rhs) NoWhere []) = do {- p <- parseLHS top p localToAbstract (snd $ lhsArgs p) $ \args -> @@ -1415,28 +1481,31 @@ -- Named patterns not allowed in let definitions lambda e (Arg info (Named Nothing (A.VarP x))) = - return $ A.Lam i (A.DomainFree $ unnamedArg info x) e + return $ A.Lam i (A.mkDomainFree $ unnamedArg info $ A.mkBinder x) e where i = ExprRange (fuseRange x e) lambda e (Arg info (Named Nothing (A.WildP i))) = do x <- freshNoName (getRange i) - return $ A.Lam i' (A.DomainFree $ unnamedArg info $ A.BindName x) e + return $ A.Lam i' (A.mkDomainFree $ unnamedArg info $ A.mkBinder_ x) e where i' = ExprRange (fuseRange i e) lambda _ _ = notAValidLetBinding d -newtype Blind a = Blind { unBlind :: a } - -instance ToAbstract (Blind a) (Blind a) where - toAbstract = return +--UNUSED Liang-Ting Chen 2019-07-16 +--newtype Blind a = Blind { unBlind :: a } +-- +--instance ToAbstract (Blind a) (Blind a) where +-- toAbstract = return --- The only reason why we return a list is that open declarations disappears. --- For every other declaration we get a singleton list. instance ToAbstract NiceDeclaration A.Declaration where toAbstract d = annotateDecls $ - traceSLn "scope.decl.trace" 50 (unlines + traceS "scope.decl.trace" 50 [ "scope checking declaration" , " " ++ prettyShow d - ]) $ + ] $ + traceS "scope.decl.trace" 80 -- keep this debug message for testing issue #4016 + [ "scope checking declaration (raw)" + , " " ++ show d + ] $ traceCall (ScopeCheckDeclaration d) $ -- Andreas, 2015-10-05, Issue 1677: -- We record in the environment whether we are scope checking an @@ -1455,18 +1524,20 @@ -- check the postulate toAbstractNiceAxiom A.NoFunSig NotMacroDef d - C.NiceGeneralize r p i x t -> do + C.NiceGeneralize r p i tac x t -> do reportSLn "scope.decl" 10 $ "found nice generalize: " ++ prettyShow x + tac <- traverse (toAbstractCtx TopCtx) tac t_ <- toAbstractCtx TopCtx t let (s, t) = unGeneralized t_ reportSLn "scope.decl" 50 $ "generalizations: " ++ show (Set.toList s, t) f <- getConcreteFixity x y <- freshAbstractQName f x bindName p GeneralizeName x y - return [A.Generalize s (mkDefInfoInstance x f p ConcreteDef NotInstanceDef NotMacroDef r) i y t] + let info = (mkDefInfo x f p ConcreteDef r) { defTactic = tac } + return [A.Generalize s info i y t] -- Fields - C.NiceField r p a i x t -> do + C.NiceField r p a i tac x t -> do unless (p == PublicAccess) $ genericError "Record fields can not be private" -- Interaction points for record fields have already been introduced -- when checking the type of the record constructor. @@ -1474,6 +1545,7 @@ -- all question marks to underscores. (See issue 1138.) let maskIP (C.QuestionMark r _) = C.Underscore r Nothing maskIP e = e + tac <- traverse (toAbstractCtx TopCtx) tac t' <- toAbstractCtx TopCtx $ mapExpr maskIP t f <- getConcreteFixity x y <- freshAbstractQName f x @@ -1485,54 +1557,56 @@ -- -- Andreas, 2010-09-24: irrelevant fields are not in scope -- -- this ensures that projections out of irrelevant fields cannot occur -- -- Ulf: unless you turn on --irrelevant-projections - do - bindName p FldName x y - return [ A.Field (mkDefInfoInstance x f p a i NotMacroDef r) y t' ] + bindName p FldName x y + let info = (mkDefInfoInstance x f p a i NotMacroDef r) { defTactic = tac } + return [ A.Field info y t' ] -- Primitive function PrimitiveFunction r p a x t -> do t' <- toAbstractCtx TopCtx t f <- getConcreteFixity x y <- freshAbstractQName f x - bindName p DefName x y + bindName p PrimName x y return [ A.Primitive (mkDefInfo x f p a r) y t' ] -- Definitions (possibly mutual) - NiceMutual r termCheck pc ds -> do + NiceMutual r tc cc pc ds -> do ds' <- toAbstract ds -- We only termination check blocks that do not have a measure. - return [ A.Mutual (MutualInfo termCheck pc r) ds' ] + return [ A.Mutual (MutualInfo tc cc pc r) ds' ] C.NiceRecSig r p a _pc _uc x ls t -> do ensureNoLetStms ls withLocalVars $ do - -- Minor hack: record types don't have indices so we include t when - -- computing generalised parameters, but in the type checker any named - -- generalizable arguments in the sort should be bound variables. - (ls', _) <- toAbstract (GenTelAndType (map makeDomainFull ls) t) - t' <- toAbstract t - f <- getConcreteFixity x - x' <- freshAbstractQName f x - bindName' p DefName (GeneralizedVarsMetadata $ generalizeTelVars ls') x x' + (ls', _) <- withCheckNoShadowing $ + -- Minor hack: record types don't have indices so we include t when + -- computing generalised parameters, but in the type checker any named + -- generalizable arguments in the sort should be bound variables. + toAbstract (GenTelAndType (map makeDomainFull ls) t) + t' <- toAbstract t + f <- getConcreteFixity x + x' <- freshAbstractQName f x + bindName' p RecName (GeneralizedVarsMetadata $ generalizeTelVars ls') x x' return [ A.RecSig (mkDefInfo x f p a r) x' ls' t' ] - C.NiceDataSig r p a _pc _uc x ls t -> withLocalVars $ do + C.NiceDataSig r p a _pc _uc x ls t -> do reportSLn "scope.data.sig" 20 ("checking DataSig for " ++ prettyShow x) ensureNoLetStms ls withLocalVars $ do - ls' <- toAbstract $ GenTel $ map makeDomainFull ls + ls' <- withCheckNoShadowing $ + toAbstract $ GenTel $ map makeDomainFull ls t' <- toAbstract $ C.Generalized t f <- getConcreteFixity x x' <- freshAbstractQName f x - bindName' p DefName (GeneralizedVarsMetadata $ generalizeTelVars ls') x x' + bindName' p DataName (GeneralizedVarsMetadata $ generalizeTelVars ls') x x' return [ A.DataSig (mkDefInfo x f p a r) x' ls' t' ] -- Type signatures - C.FunSig r p a i m rel tc x t -> + C.FunSig r p a i m rel _ _ x t -> toAbstractNiceAxiom A.FunSig m (C.Axiom r p a i rel x t) -- Function definitions - C.FunDef r ds a i tc x cs -> do + C.FunDef r ds a i _ _ x cs -> do printLocals 10 $ "checking def " ++ prettyShow x (x',cs) <- toAbstract (OldName x,cs) -- Andreas, 2017-12-04 the name must reside in the current module @@ -1544,17 +1618,19 @@ return [ A.FunDef (mkDefInfoInstance x f PublicAccess a i NotMacroDef r) x' delayed cs ] -- Uncategorized function clauses - C.NiceFunClause r acc abs termCheck catchall (C.FunClause lhs rhs wcls ca) -> + C.NiceFunClause _ _ _ _ _ _ (C.FunClause lhs _ _ _) -> genericError $ "Missing type signature for left hand side " ++ prettyShow lhs C.NiceFunClause{} -> __IMPOSSIBLE__ -- Data definitions - C.NiceDataDef r o a _ uc x pars cons -> withLocalVars $ do + C.NiceDataDef r o a _ uc x pars cons -> do reportSLn "scope.data.def" 20 ("checking " ++ show o ++ " DataDef for " ++ prettyShow x) (p, ax) <- resolveName (C.QName x) >>= \case DefinedName p ax -> do + clashUnless x DataName ax -- Andreas 2019-07-07, issue #3892 livesInCurrentModule ax -- Andreas, 2017-12-04, issue #2862 + clashIfModuleAlreadyDefinedInCurrentModule x ax return (p, ax) _ -> genericError $ "Missing type signature for data definition " ++ prettyShow x ensureNoLetStms pars @@ -1562,9 +1638,8 @@ gvars <- bindGeneralizablesIfInserted o ax -- Check for duplicate constructors do cs <- mapM conName cons - let dups = nub $ cs \\ nub cs - bad = filter (`elem` dups) cs - unless (distinct cs) $ + unlessNull (duplicates cs) $ \ dups -> do + let bad = filter (`elem` dups) cs setCurrentRange bad $ typeError $ DuplicateConstructors dups @@ -1575,7 +1650,7 @@ let m = mnameFromList $ qnameToList x' createModule (Just IsData) m bindModule p x m -- make it a proper module - cons <- toAbstract (map (ConstrDecl NoRec m a p) cons) + cons <- toAbstract (map (ConstrDecl m a p) cons) printScope "data" 20 $ "Checked data " ++ prettyShow x f <- getConcreteFixity x return [ A.DataDef (mkDefInfo x f PublicAccess a r) x' uc (DataDefParams gvars pars) cons ] @@ -1588,7 +1663,9 @@ reportSLn "scope.rec.def" 20 ("checking " ++ show o ++ " RecDef for " ++ prettyShow x) (p, ax) <- resolveName (C.QName x) >>= \case DefinedName p ax -> do + clashUnless x RecName ax -- Andreas 2019-07-07, issue #3892 livesInCurrentModule ax -- Andreas, 2017-12-04, issue #2862 + clashIfModuleAlreadyDefinedInCurrentModule x ax return (p, ax) _ -> genericError $ "Missing type signature for record definition " ++ prettyShow x ensureNoLetStms pars @@ -1613,16 +1690,20 @@ return afields -- Andreas, 2017-07-13 issue #2642 disallow duplicate fields -- Check for duplicate fields. (See "Check for duplicate constructors") - do let fs = forMaybe fields $ \case - C.Field _ f _ -> Just f + do let fs :: [C.Name] + fs = concat $ forMaybe fields $ \case + C.Field _ fs -> Just $ fs <&> \case + -- a Field block only contains field signatures + C.FieldSig _ _ f _ -> f + _ -> __IMPOSSIBLE__ _ -> Nothing - let dups = nub $ fs \\ nub fs - bad = filter (`elem` dups) fs - unless (distinct fs) $ + unlessNull (duplicates fs) $ \ dups -> do + let bad = filter (`elem` dups) fs setCurrentRange bad $ typeError $ DuplicateFields dups bindModule p x m - cm' <- mapM (\(c, _) -> bindConstructorName m c a p YesRec) cm + -- Andreas, 2019-11-11, issue #4189, no longer add record constructor to record module. + cm' <- forM cm $ \ (c, _) -> bindRecordConstructorName c a p let inst = caseMaybe cm NotInstanceDef snd printScope "rec" 15 "record complete" f <- getConcreteFixity x @@ -1658,7 +1739,7 @@ return adecls NiceOpen r x dir -> do - (minfo, m, adir) <- checkOpen r x dir + (minfo, m, adir) <- checkOpen r Nothing x dir return [A.Open minfo m adir] NicePragma r p -> do @@ -1666,7 +1747,7 @@ return $ map (A.Pragma r) ps NiceImport r x as open dir -> setCurrentRange r $ do - notPublicWithoutOpen open dir + dir <- notPublicWithoutOpen open dir -- Andreas, 2018-11-03, issue #3364, parse expression in as-clause as Name. let illformedAs s = traceCall (SetRange $ getRange as) $ do @@ -1678,8 +1759,8 @@ Nothing -> return Nothing Just (AsName (Right asName) r) -> return $ Just $ AsName asName r Just (AsName (Left (C.Ident (C.QName asName))) r) -> return $ Just $ AsName asName r + Just (AsName (Left C.Underscore{}) r) -> return $ Just $ AsName underscore r Just (AsName (Left (C.Ident C.Qual{})) r) -> illformedAs "; a qualified name is not allowed here" - Just (AsName (Left C.Underscore{}) r) -> illformedAs "; an underscore is not allowed here" Just (AsName (Left e) r) -> illformedAs "" -- First scope check the imported module and return its name and @@ -1703,17 +1784,43 @@ -- Bind the desired module name to the right abstract name. case as of Nothing -> bindQModule (PrivateAccess Inserted) x m - Just y -> bindModule (PrivateAccess Inserted) (asName y) m + Just y -> (unless . isNoName) (asName y) $ + bindModule (PrivateAccess Inserted) (asName y) m printScope "import" 10 "merged imported sig:" -- Open if specified, otherwise apply import directives let (name, theAsSymbol, theAsName) = case as of - Nothing -> (x, noRange, Nothing) - Just a -> (C.QName (asName a), asRange a, Just (asName a)) + Just a | (not . isNoName) (asName a) -> (C.QName (asName a), asRange a, Just (asName a)) + _ -> (x, noRange, Nothing) adir <- case open of DoOpen -> do - (_minfo, _m, adir) <- checkOpen r name dir + -- Andreas, 2019-05-29, issue #3818. + -- Pass the resolved name to open instead triggering another resolution. + -- This helps in situations like + -- @ + -- module Top where + -- module M where + -- open import M + -- @ + -- It is clear than in @open import M@, name @M@ must refer to a file + -- rather than the above defined local module @M@. + -- This already worked in the situation + -- @ + -- module Top where + -- module M where + -- import M + -- @ + -- Note that the manual desugaring of @open import@ as + -- @ + -- module Top where + -- module M where + -- import M + -- open M + -- @ + -- will not work, as @M@ is now ambiguous in @open M@; + -- the information that @M@ is external is lost here. + (_minfo, _m, adir) <- checkOpen r (Just m) name dir return adir -- If not opening, import directives are applied to the original scope. DontOpen -> modifyNamedScopeM m $ applyImportDirectiveM x dir @@ -1726,24 +1833,24 @@ } return [ A.Import minfo m adir ] - NiceUnquoteDecl r p a i tc xs e -> do + NiceUnquoteDecl r p a i tc cc xs e -> do fxs <- mapM getConcreteFixity xs ys <- zipWithM freshAbstractQName fxs xs zipWithM_ (bindName p QuotableName) xs ys e <- toAbstract e - zipWithM_ (rebindName p DefName) xs ys - let mi = MutualInfo tc True r + zipWithM_ (rebindName p OtherDefName) xs ys + let mi = MutualInfo tc cc YesPositivityCheck r return [ A.Mutual mi [A.UnquoteDecl mi [ mkDefInfoInstance x fx p a i NotMacroDef r | (fx, x) <- zip fxs xs ] ys e] ] - NiceUnquoteDef r p a tc xs e -> do + NiceUnquoteDef r p a _ _ xs e -> do fxs <- mapM getConcreteFixity xs ys <- mapM (toAbstract . OldName) xs zipWithM_ (rebindName p QuotableName) xs ys e <- toAbstract e - zipWithM_ (rebindName p DefName) xs ys + zipWithM_ (rebindName p OtherDefName) xs ys return [ A.UnquoteDef [ mkDefInfo x fx PublicAccess a r | (fx, x) <- zip fxs xs ] ys e ] - NicePatternSyn r n as p -> do + NicePatternSyn r a n as p -> do reportSLn "scope.pat" 10 $ "found nice pattern syn: " ++ prettyShow n (as, p) <- withLocalVars $ do p <- toAbstract =<< parsePatternSyn p @@ -1753,13 +1860,13 @@ let err = "Dot or equality patterns are not allowed in pattern synonyms. Maybe use '_' instead." p <- noDotorEqPattern err p as <- (traverse . mapM) (unVarName <=< resolveName . C.QName) as - unlessNull (patternVars p \\ map unArg as) $ \ xs -> do + unlessNull (patternVars p List.\\ map unArg as) $ \ xs -> do typeError . GenericDocError =<< do "Unbound variables in pattern synonym: " <+> sep (map prettyA xs) return (as, p) y <- freshAbstractQName' n - bindName PublicAccess PatternSynName n y + bindName a PatternSynName n y -- Expanding pattern synonyms already at definition makes it easier to -- fold them back when printing (issue #2762). ep <- expandPatternSynonyms p @@ -1776,7 +1883,7 @@ mp <- getConcretePolarity x y <- freshAbstractQName f x let kind | isMacro == MacroDef = MacroName - | otherwise = DefName + | otherwise = OtherDefName -- could be a type signature bindName p kind x y return [ A.Axiom funSig (mkDefInfoInstance x f p a i isMacro r) info mp y t' ] toAbstractNiceAxiom _ _ _ = __IMPOSSIBLE__ @@ -1809,10 +1916,13 @@ collectAndBindGeneralizables :: ScopeM a -> ScopeM (Map I.QName I.Name, a) collectAndBindGeneralizables m = do + fvBefore <- length <$> getLocalVars (s, res) <- collectGeneralizables m + fvAfter <- length <$> getLocalVars -- We should bind the named generalizable variables as fresh variables binds <- createBoundNamesForGeneralizables s - bindGeneralizables binds + -- Issue #3735: We need to bind the generalizable variables outside any variables bound by `m`. + outsideLocalVars (fvAfter - fvBefore) $ bindGeneralizables binds return (binds, res) bindGeneralizables :: Map A.QName A.Name -> ScopeM () @@ -1854,19 +1964,41 @@ instance LivesInCurrentModule A.QName where livesInCurrentModule x = do m <- getCurrentModule - reportSLn "scope.data.def" 30 $ unlines + reportS "scope.data.def" 30 [ " A.QName of data type: " ++ show x , " current module: " ++ show m ] unless (A.qnameModule x == m) $ genericError $ "Definition in different module than its type signature" -data IsRecordCon = YesRec | NoRec -data ConstrDecl = ConstrDecl IsRecordCon A.ModuleName IsAbstract Access C.NiceDeclaration +-- | Unless the resolved 'AbstractName' has the given 'KindOfName', +-- report a 'ClashingDefinition' for the 'C.Name'. +clashUnless :: C.Name -> KindOfName -> AbstractName -> ScopeM () +clashUnless x k ax = unless (anameKind ax == k) $ + typeError $ ClashingDefinition (C.QName x) (anameName ax) -bindConstructorName :: ModuleName -> C.Name -> IsAbstract -> - Access -> IsRecordCon -> ScopeM A.QName -bindConstructorName m x a p record = do +-- | If a (data/record) module with the given name is already present in the current module, +-- we take this as evidence that a data/record with that name is already defined. +clashIfModuleAlreadyDefinedInCurrentModule :: C.Name -> AbstractName -> ScopeM () +clashIfModuleAlreadyDefinedInCurrentModule x ax = do + datRecMods <- catMaybes <$> do + mapM (isDatatypeModule . amodName) =<< lookupModuleInCurrentModule x + unlessNull datRecMods $ const $ + typeError $ ClashingDefinition (C.QName x) (anameName ax) + +lookupModuleInCurrentModule :: C.Name -> ScopeM [AbstractModule] +lookupModuleInCurrentModule x = + fromMaybe [] . Map.lookup x . nsModules . thingsInScope [PublicNS, PrivateNS] <$> getCurrentScope + +data ConstrDecl = ConstrDecl A.ModuleName IsAbstract Access C.NiceDeclaration + +bindConstructorName + :: ModuleName -- ^ Name of @data@/@record@ module. + -> C.Name -- ^ Constructor name. + -> IsAbstract + -> Access + -> ScopeM A.QName +bindConstructorName m x a p = do f <- getConcreteFixity x -- The abstract name is the qualified one y <- withCurrentModule m $ freshAbstractQName f x @@ -1880,13 +2012,26 @@ p' = case a of AbstractDef -> PrivateAccess Inserted _ -> p - p'' = case (a, record) of - (AbstractDef, _) -> PrivateAccess Inserted - (_, YesRec) -> OnlyQualified -- record constructors aren't really in the record module - _ -> PublicAccess + p'' = case a of + AbstractDef -> PrivateAccess Inserted + _ -> PublicAccess +-- | Record constructors do not live in the record module (as it is parameterized). +-- Abstract constructors are bound privately, so that they are not exported. +bindRecordConstructorName :: C.Name -> IsAbstract -> Access -> ScopeM A.QName +bindRecordConstructorName x a p = do + y <- freshAbstractQName' x + bindName p' ConName x y + return y + where + -- An abstract constructor is private (abstract constructor means + -- abstract datatype, so the constructor should not be exported). + p' = case a of + AbstractDef -> PrivateAccess Inserted + _ -> p + instance ToAbstract ConstrDecl A.Declaration where - toAbstract (ConstrDecl record m a p d) = do + toAbstract (ConstrDecl m a p d) = do case d of C.Axiom r p1 a1 i info x t -> do -- rel==Relevant -- unless (p1 == p) __IMPOSSIBLE__ -- This invariant is currently violated by test/Succeed/Issue282.agda @@ -1895,7 +2040,7 @@ -- The abstract name is the qualified one -- Bind it twice, once unqualified and once qualified f <- getConcreteFixity x - y <- bindConstructorName m x a p record + y <- bindConstructorName m x a p printScope "con" 15 "bound constructor" return $ A.Axiom NoFunSig (mkDefInfoInstance x f p a i NotMacroDef r) info Nothing y t' @@ -1909,23 +2054,27 @@ instance ToAbstract C.Pragma [A.Pragma] where toAbstract (C.ImpossiblePragma _) = impossibleTest toAbstract (C.OptionsPragma _ opts) = return [ A.OptionsPragma opts ] - toAbstract (C.RewritePragma _ []) = [] <$ warning EmptyRewritePragma - toAbstract (C.RewritePragma _ xs) = concat <$> do + toAbstract (C.RewritePragma _ _ []) = [] <$ warning EmptyRewritePragma + toAbstract (C.RewritePragma _ r xs) = singleton . A.RewritePragma r . concat <$> do forM xs $ \ x -> do e <- toAbstract $ OldQName x Nothing case e of - A.Def x -> return [ A.RewritePragma x ] - A.Proj _ p | Just x <- getUnambiguous p -> return [ A.RewritePragma x ] + A.Def x -> return [ x ] + A.Proj _ p | Just x <- getUnambiguous p -> return [ x ] A.Proj _ x -> genericError $ "REWRITE used on ambiguous name " ++ prettyShow x - A.Con c | Just x <- getUnambiguous c -> return [ A.RewritePragma x ] + A.Con c | Just x <- getUnambiguous c -> return [ x ] A.Con x -> genericError $ "REWRITE used on ambiguous name " ++ prettyShow x A.Var x -> genericError $ "REWRITE used on parameter " ++ prettyShow x ++ " instead of on a defined symbol" _ -> __IMPOSSIBLE__ - toAbstract (C.ForeignPragma _ b s) = [] <$ addForeignCode b s - toAbstract (C.CompilePragma _ b x s) = do - e <- toAbstract $ OldQName x Nothing - let err what = genericError $ "Cannot COMPILE " ++ what ++ " " ++ prettyShow x - y <- case e of + toAbstract (C.ForeignPragma _ rb s) = [] <$ addForeignCode (rangedThing rb) s + toAbstract (C.CompilePragma _ rb x s) = do + let b = rangedThing rb + me <- toAbstract $ MaybeOldQName $ OldQName x Nothing + case me of + Nothing -> [] <$ notInScopeWarning x + Just e -> do + let err what = genericError $ "Cannot COMPILE " ++ what ++ " " ++ prettyShow x + y <- case e of A.Def x -> return x A.Proj _ p | Just x <- getUnambiguous p -> return x A.Proj _ x -> err "ambiguous projection" @@ -1934,7 +2083,7 @@ A.PatternSyn{} -> err "pattern synonym" A.Var{} -> err "local variable" _ -> __IMPOSSIBLE__ - return [ A.CompilePragma b y s ] + return [ A.CompilePragma rb y s ] toAbstract (C.StaticPragma _ x) = do e <- toAbstract $ OldQName x Nothing @@ -1964,34 +2113,36 @@ sINLINE ++ " used on ambiguous name " ++ prettyShow x _ -> genericError $ "Target of " ++ sINLINE ++ " pragma should be a function" return [ A.InlinePragma b y ] - toAbstract (C.BuiltinPragma _ b q) | isUntypedBuiltin b = do - bindUntypedBuiltin b =<< toAbstract (ResolveQName q) - return [] - toAbstract (C.BuiltinPragma _ b q) = do - -- Andreas, 2015-02-14 - -- Some builtins cannot be given a valid Agda type, - -- thus, they do not come with accompanying postulate or definition. - if b `elem` builtinsNoDef then do - case q of - C.QName x -> do - -- The name shouldn't exist yet. If it does, we raise a warning - -- and drop the existing definition. - unlessM ((UnknownName ==) <$> resolveName q) $ do - genericWarning $ P.text $ - "BUILTIN " ++ b ++ " declares an identifier " ++ - "(no longer expects an already defined identifier)" - modifyCurrentScope $ removeNameFromScope PublicNS x - -- We then happily bind the name - y <- freshAbstractQName' x - kind <- fromMaybe __IMPOSSIBLE__ <$> builtinKindOfName b - bindName PublicAccess kind x y - return [ A.BuiltinNoDefPragma b y ] - _ -> genericError $ - "Pragma BUILTIN " ++ b ++ ": expected unqualified identifier, " ++ - "but found " ++ prettyShow q - else do - q <- toAbstract $ ResolveQName q - return [ A.BuiltinPragma b q ] + toAbstract (C.BuiltinPragma _ rb q) + | isUntypedBuiltin b = do + bindUntypedBuiltin b =<< toAbstract (ResolveQName q) + return [] + | otherwise = do + -- Andreas, 2015-02-14 + -- Some builtins cannot be given a valid Agda type, + -- thus, they do not come with accompanying postulate or definition. + if b `elem` builtinsNoDef then do + case q of + C.QName x -> do + -- The name shouldn't exist yet. If it does, we raise a warning + -- and drop the existing definition. + unlessM ((UnknownName ==) <$> resolveName q) $ do + genericWarning $ P.text $ + "BUILTIN " ++ b ++ " declares an identifier " ++ + "(no longer expects an already defined identifier)" + modifyCurrentScope $ removeNameFromScope PublicNS x + -- We then happily bind the name + y <- freshAbstractQName' x + let kind = fromMaybe __IMPOSSIBLE__ $ builtinKindOfName b + bindName PublicAccess kind x y + return [ A.BuiltinNoDefPragma rb y ] + _ -> genericError $ + "Pragma BUILTIN " ++ b ++ ": expected unqualified identifier, " ++ + "but found " ++ prettyShow q + else do + q <- toAbstract $ ResolveQName q + return [ A.BuiltinPragma rb q ] + where b = rangedThing rb toAbstract (C.EtaPragma _ x) = do e <- toAbstract $ OldQName x Nothing case e of @@ -2013,15 +2164,15 @@ case qx of VarName x' _ -> return . (False,) $ A.qnameFromList [x'] DefinedName _ d -> return . (False,) $ anameName d - FieldName (d :! []) -> return . (False,) $ anameName d + FieldName (d :| []) -> return . (False,) $ anameName d FieldName ds -> genericError $ "Ambiguous projection " ++ prettyShow top ++ ": " ++ prettyShow (fmap anameName ds) - ConstructorName (d :! []) -> return . (False,) $ anameName d + ConstructorName (d :| []) -> return . (False,) $ anameName d ConstructorName ds -> genericError $ "Ambiguous constructor " ++ prettyShow top ++ ": " ++ prettyShow (fmap anameName ds) - UnknownName -> notInScope top - PatternSynResName (d :! []) -> return . (True,) $ anameName d + UnknownName -> notInScopeError top + PatternSynResName (d :| []) -> return . (True,) $ anameName d PatternSynResName ds -> genericError $ "Ambiguous pattern synonym" ++ prettyShow top ++ ": " ++ prettyShow (fmap anameName ds) - lhs <- toAbstract $ LeftHandSide top lhs + lhs <- toAbstract $ LeftHandSide top lhs NoEllipsis ps <- case lhs of A.LHS _ (A.LHSHead _ ps) -> return ps _ -> err @@ -2046,30 +2197,35 @@ stLocalUserWarnings `modifyTCLens` Map.insert qn str pure [] - -- Termination checking pragmes are handled by the nicifier - toAbstract C.TerminationCheckPragma{} = __IMPOSSIBLE__ - - toAbstract C.CatchallPragma{} = __IMPOSSIBLE__ + toAbstract (C.WarningOnImport _ str) = do + stWarningOnImport `setTCLens` Just str + pure [] - -- No positivity checking pragmas are handled by the nicifier. + -- Termination, Coverage, Positivity, Universe, and Catchall + -- pragmes are handled by the nicifier + toAbstract C.TerminationCheckPragma{} = __IMPOSSIBLE__ + toAbstract C.NoCoverageCheckPragma{} = __IMPOSSIBLE__ toAbstract C.NoPositivityCheckPragma{} = __IMPOSSIBLE__ + toAbstract C.NoUniverseCheckPragma{} = __IMPOSSIBLE__ + toAbstract C.CatchallPragma{} = __IMPOSSIBLE__ -- Polarity pragmas are handled by the niceifier. toAbstract C.PolarityPragma{} = __IMPOSSIBLE__ - -- No universe checking pragmas are handled by the niceifier. - toAbstract C.NoUniverseCheckPragma{} = __IMPOSSIBLE__ - instance ToAbstract C.Clause A.Clause where - toAbstract (C.Clause top catchall lhs@(C.LHS p eqs with) rhs wh wcs) = withLocalVars $ do + toAbstract (C.Clause top catchall lhs@(C.LHS p eqs with ell) rhs wh wcs) = withLocalVars $ do -- Jesper, 2018-12-10, #3095: pattern variables bound outside the -- module are locally treated as module parameters modifyScope_ $ updateScopeLocals $ map $ second patternToModuleBound -- Andreas, 2012-02-14: need to reset local vars before checking subclauses - vars <- getLocalVars - let wcs' = for wcs $ \ c -> setLocalVars vars $> c - lhs' <- toAbstract $ LeftHandSide (C.QName top) p + vars0 <- getLocalVars + lhs' <- toAbstract $ LeftHandSide (C.QName top) p ell printLocals 10 "after lhs:" + vars1 <- getLocalVars + eqs <- mapM (toAbstractCtx TopCtx) eqs + vars2 <- getLocalVars + let vars = dropEnd (length vars1) vars2 ++ vars0 + let wcs' = for wcs $ \ c -> setLocalVars vars $> c let (whname, whds) = case wh of NoWhere -> (Nothing, []) -- Andreas, 2016-07-17 issues #2081 and #2101 @@ -2086,7 +2242,7 @@ if not (null eqs) then do - rhs <- toAbstract =<< toAbstractCtx TopCtx (RightHandSide eqs with wcs' rhs whds) + rhs <- toAbstract =<< toAbstractCtx TopCtx (RightHandSide eqs with wcs' rhs whname whds) return $ A.Clause lhs' [] rhs A.noWhereDecls catchall else do -- ASR (16 November 2015) Issue 1137: We ban termination @@ -2094,15 +2250,20 @@ when (any isTerminationPragma whds) $ genericError "Termination pragmas are not allowed inside where clauses" - -- the right hand side is checked inside the module of the local definitions + -- the right hand side is checked with the module of the local definitions opened (rhs, ds) <- whereToAbstract (getRange wh) whname whds $ - toAbstractCtx TopCtx (RightHandSide eqs with wcs' rhs []) + toAbstractCtx TopCtx (RightHandSide eqs with wcs' rhs Nothing []) rhs <- toAbstract rhs -- #2897: we need to restrict named where modules in refined contexts, -- so remember whether it was named here return $ A.Clause lhs' [] rhs ds catchall -whereToAbstract :: Range -> Maybe (C.Name, Access) -> [C.Declaration] -> ScopeM a -> ScopeM (a, A.WhereDeclarations) +whereToAbstract + :: Range -- ^ The range of the @where@-block. + -> Maybe (C.Name, Access) -- ^ The name of the @where@ module (if any). + -> [C.Declaration] -- ^ The contents of the @where@ module. + -> ScopeM a -- ^ The scope-checking task to be run in the context of the @where@ module. + -> ScopeM (a, A.WhereDeclarations) -- ^ Additionally return the scope-checked contents of the @where@ module. whereToAbstract _ whname [] inner = (, A.noWhereDecls) <$> inner whereToAbstract r whname whds inner = do -- Create a fresh concrete name if there isn't (a proper) one. @@ -2123,23 +2284,30 @@ let anonymousSomeWhere = maybe False (isNoName . fst) whname when anonymousSomeWhere $ void $ -- We can ignore the returned default A.ImportDirective. - openModule_ TopOpenModule (C.QName m) $ - defaultImportDir { publicOpen = True } + openModule TopOpenModule (Just am) (C.QName m) $ + defaultImportDir { publicOpen = Just noRange } return (x, A.WhereDecls (am <$ whname) ds) data RightHandSide = RightHandSide - { rhsRewriteEqn :: [C.RewriteEqn] -- ^ @rewrite e@ (many) - , rhsWithExpr :: [C.WithExpr] -- ^ @with e@ (many) - , rhsSubclauses :: [ScopeM C.Clause] -- ^ the subclauses spawned by a with (monadic because we need to reset the local vars before checking these clauses) - , rhs :: C.RHS - , rhsWhereDecls :: [C.Declaration] + { _rhsRewriteEqn :: [RewriteEqn' () A.Pattern A.Expr] + -- ^ @rewrite e | with p <- e@ (many) + , _rhsWithExpr :: [WithHiding C.WithExpr] + -- ^ @with e@ (many) + , _rhsSubclauses :: [ScopeM C.Clause] + -- ^ the subclauses spawned by a with (monadic because we need to reset the local vars before checking these clauses) + , _rhs :: C.RHS + , _rhsWhereName :: Maybe (C.Name, Access) + -- ^ The name of the @where@ module (if any). + , _rhsWhereDecls :: [C.Declaration] + -- ^ The contents of the @where@ module. } data AbstractRHS = AbsurdRHS' - | WithRHS' [A.Expr] [ScopeM C.Clause] -- ^ The with clauses haven't been translated yet + | WithRHS' [WithHiding A.Expr] [ScopeM C.Clause] + -- ^ The with clauses haven't been translated yet | RHS' A.Expr C.Expr - | RewriteRHS' [A.Expr] AbstractRHS A.WhereDeclarations + | RewriteRHS' [RewriteEqn' () A.Pattern A.Expr] AbstractRHS A.WhereDeclarations qualifyName_ :: A.Name -> ScopeM A.QName qualifyName_ x = do @@ -2151,43 +2319,69 @@ NameId i _ <- fresh qualifyName_ =<< freshName_ (s ++ show i) +instance ToAbstract (RewriteEqn' () A.Pattern A.Expr) A.RewriteEqn where + toAbstract = \case + Rewrite es -> fmap Rewrite $ forM es $ \ (_, e) -> do + qn <- withFunctionName "-rewrite" + pure (qn, e) + Invert _ pes -> do + qn <- withFunctionName "-invert" + pure $ Invert qn pes + +instance ToAbstract C.RewriteEqn (RewriteEqn' () A.Pattern A.Expr) where + toAbstract = \case + Rewrite es -> Rewrite <$> mapM toAbstract es + Invert _ pes -> Invert () <$> do + let (ps, es) = unzip pes + -- first check the expressions: the patterns may shadow some of the variables + -- mentioned in them! + es <- toAbstract es + -- then parse the patterns and go through the motions of converting them, + -- checking them for linearity, binding the variable introduced in them + -- and finally producing an abstract pattern. + ps <- forM ps $ \ p -> do + p <- parsePattern p + p <- toAbstract p + checkPatternLinearity p (typeError . RepeatedVariablesInPattern) + bindVarsToBind + toAbstract p + pure $ zip ps es + instance ToAbstract AbstractRHS A.RHS where toAbstract AbsurdRHS' = return A.AbsurdRHS toAbstract (RHS' e c) = return $ A.RHS e $ Just c toAbstract (RewriteRHS' eqs rhs wh) = do - auxs <- replicateM (length eqs) $ withFunctionName "rewrite-" - rhs <- toAbstract rhs - return $ RewriteRHS (zip auxs eqs) [] rhs wh + eqs <- toAbstract eqs + rhs <- toAbstract rhs + return $ RewriteRHS eqs [] rhs wh toAbstract (WithRHS' es cs) = do aux <- withFunctionName "with-" A.WithRHS aux es <$> do toAbstract =<< sequence cs instance ToAbstract RightHandSide AbstractRHS where - toAbstract (RightHandSide eqs@(_:_) es cs rhs wh) = do - eqs <- toAbstractCtx TopCtx eqs - -- TODO: remember named where - (rhs, ds) <- whereToAbstract (getRange wh) Nothing wh $ - toAbstract (RightHandSide [] es cs rhs []) + toAbstract (RightHandSide eqs@(_:_) es cs rhs whname wh) = do + (rhs, ds) <- whereToAbstract (getRange wh) whname wh $ + toAbstract (RightHandSide [] es cs rhs Nothing []) return $ RewriteRHS' eqs rhs ds - toAbstract (RightHandSide [] [] (_ : _) _ _) = __IMPOSSIBLE__ - toAbstract (RightHandSide [] (_ : _) _ (C.RHS _) _) = typeError $ BothWithAndRHS - toAbstract (RightHandSide [] [] [] rhs []) = toAbstract rhs - toAbstract (RightHandSide [] es cs C.AbsurdRHS []) = do + toAbstract (RightHandSide [] [] (_ : _) _ _ _) = __IMPOSSIBLE__ + toAbstract (RightHandSide [] (_ : _) _ (C.RHS _) _ _) = typeError $ BothWithAndRHS + toAbstract (RightHandSide [] [] [] rhs _ []) = toAbstract rhs + toAbstract (RightHandSide [] es cs C.AbsurdRHS _ []) = do es <- toAbstractCtx TopCtx es return $ WithRHS' es cs -- TODO: some of these might be possible - toAbstract (RightHandSide [] (_ : _) _ C.AbsurdRHS (_ : _)) = __IMPOSSIBLE__ - toAbstract (RightHandSide [] [] [] (C.RHS _) (_ : _)) = __IMPOSSIBLE__ - toAbstract (RightHandSide [] [] [] C.AbsurdRHS (_ : _)) = __IMPOSSIBLE__ + toAbstract (RightHandSide [] (_ : _) _ C.AbsurdRHS _ (_ : _)) = __IMPOSSIBLE__ + toAbstract (RightHandSide [] [] [] (C.RHS _) _ (_ : _)) = __IMPOSSIBLE__ + toAbstract (RightHandSide [] [] [] C.AbsurdRHS _ (_ : _)) = __IMPOSSIBLE__ instance ToAbstract C.RHS AbstractRHS where toAbstract C.AbsurdRHS = return $ AbsurdRHS' toAbstract (C.RHS e) = RHS' <$> toAbstract e <*> pure e -data LeftHandSide = LeftHandSide C.QName C.Pattern +data LeftHandSide = LeftHandSide C.QName C.Pattern ExpandedEllipsis instance ToAbstract LeftHandSide A.LHS where - toAbstract (LeftHandSide top lhs) = + toAbstract (LeftHandSide top lhs ell) = traceCall (ScopeCheckLHS top lhs) $ do lhscore <- parseLHS top lhs reportSLn "scope.lhs" 5 $ "parsed lhs: " ++ show lhscore @@ -2205,7 +2399,7 @@ lhscore <- toAbstract lhscore reportSLn "scope.lhs" 5 $ "parsed lhs dot patterns: " ++ show lhscore printLocals 10 "checked dots:" - return $ A.LHS (LHSRange $ getRange lhs) lhscore + return $ A.LHS (LHSInfo (getRange lhs) ell) lhscore -- Merges adjacent EqualP patterns into one: typecheking expects only one pattern for each domain in the telescope. mergeEqualPs :: [NamedArg (Pattern' e)] -> [NamedArg (Pattern' e)] @@ -2232,7 +2426,7 @@ qx <- resolveName d ds <- case qx of FieldName ds -> return $ fmap anameName ds - UnknownName -> notInScope d + UnknownName -> notInScopeError d _ -> genericError $ "head of copattern needs to be a field identifier, but " ++ prettyShow d ++ " isn't one" @@ -2278,7 +2472,7 @@ case px of VarPatName y -> do reportSLn "scope.pat" 60 $ " resolved to VarPatName " ++ show y ++ " with range " ++ show (getRange y) - return $ VarP $ A.BindName y + return $ VarP $ A.mkBindName y ConPatName ds -> return $ ConP (ConPatInfo ConOCon (PatRange r) ConPatEager) (AmbQ $ fmap anameName ds) [] PatternSynPatName ds -> return $ PatternSynP (PatRange r) @@ -2399,7 +2593,7 @@ -- x <- toAbstract (NewName PatternBound x) x <- bindPatternVariable x p <- toAbstract p - return $ A.AsP (PatRange r) (A.BindName x) p + return $ A.AsP (PatRange r) (A.mkBindName x) p toAbstract p0@(C.EqualP r es) = return $ A.EqualP (PatRange r) es -- We have to do dot patterns at the end since they can @@ -2447,7 +2641,7 @@ op <- toAbstract (OldQName op (Just ns)) es <- left (notaFixity nota) nonBindingParts es -- Prepend the generated section binders (if any). - let body = foldl' app op es + let body = List.foldl' app op es return $ foldr (A.Lam (ExprRange (getRange body))) body binders where -- Build an application in the abstract syntax, with correct Range. @@ -2509,7 +2703,7 @@ x <- freshName noRange "section" let i = setOrigin Inserted $ argInfo a (ls, ns) <- replacePlaceholders as - return ( A.DomainFree (unnamedArg i $ A.BindName x) : ls + return ( A.mkDomainFree (unnamedArg i $ A.mkBinder_ x) : ls , set (Left (Var x)) a : ns ) where @@ -2524,4 +2718,6 @@ -- | Content of interaction hole. instance ToAbstract C.HoleContent A.HoleContent where - toAbstract = mapM toAbstract + toAbstract = \case + HoleContentExpr e -> HoleContentExpr <$> toAbstract e + HoleContentRewrite es -> HoleContentRewrite <$> toAbstract es diff --git a/src/full/Agda/Syntax/Translation/InternalToAbstract.hs b/src/full/Agda/Syntax/Translation/InternalToAbstract.hs --- a/src/full/Agda/Syntax/Translation/InternalToAbstract.hs +++ b/src/full/Agda/Syntax/Translation/InternalToAbstract.hs @@ -1,5 +1,3 @@ -{-# LANGUAGE CPP #-} -{-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE NondecreasingIndentation #-} {-# LANGUAGE TypeFamilies #-} -- for type equality ~ {-# LANGUAGE UndecidableInstances #-} @@ -17,14 +15,19 @@ -} module Agda.Syntax.Translation.InternalToAbstract ( Reify(..) + , MonadReify , NamedClause(..) , reifyPatterns + , reifyUnblocked + , blankNotInScope + , reifyDisplayFormP ) where import Prelude hiding (mapM_, mapM, null) + +import Control.Applicative (liftA2) import Control.Arrow ((&&&)) import Control.Monad.State hiding (mapM_, mapM) -import Control.Monad.Reader hiding (mapM_, mapM) import Data.Foldable (Foldable, foldMap) import qualified Data.List as List @@ -34,22 +37,22 @@ import Data.Semigroup ( Semigroup, (<>) ) import Data.Set (Set) import qualified Data.Set as Set -import Data.Traversable (Traversable, traverse, mapM) -import qualified Data.Traversable as Trav +import Data.Traversable (traverse, mapM) import Agda.Syntax.Literal import Agda.Syntax.Position import Agda.Syntax.Common import Agda.Syntax.Fixity import qualified Agda.Syntax.Concrete.Name as C -import Agda.Syntax.Concrete (FieldAssignment'(..), exprFieldA) +import Agda.Syntax.Concrete (FieldAssignment'(..)) import Agda.Syntax.Info as Info -import Agda.Syntax.Abstract as A +import Agda.Syntax.Abstract as A hiding (Binder) +import qualified Agda.Syntax.Abstract as A import Agda.Syntax.Abstract.Pattern import Agda.Syntax.Abstract.Pretty import Agda.Syntax.Internal as I import Agda.Syntax.Internal.Pattern as I -import Agda.Syntax.Scope.Base (isNameInScope, inverseScopeLookupName) +import Agda.Syntax.Scope.Base (inverseScopeLookupName) import Agda.TypeChecking.Monad import Agda.TypeChecking.Monad.Builtin @@ -62,42 +65,45 @@ import Agda.TypeChecking.Free import Agda.TypeChecking.Substitute import Agda.TypeChecking.Telescope -import Agda.TypeChecking.DropArgs -import Agda.Interaction.Options ( optPostfixProjections ) +import Agda.Interaction.Options import Agda.Utils.Either -import Agda.Utils.Except ( MonadError(catchError) ) -import Agda.Utils.Function import Agda.Utils.Functor import Agda.Utils.Lens import Agda.Utils.List +import qualified Agda.Utils.Maybe.Strict as Strict import Agda.Utils.Maybe import Agda.Utils.Monad import Agda.Utils.Null import Agda.Utils.Permutation -import Agda.Utils.Pretty hiding ((<>)) +import Agda.Utils.Pretty import Agda.Utils.Singleton import Agda.Utils.Size import Agda.Utils.Tuple -#include "undefined.h" import Agda.Utils.Impossible --- Composition of reified applications ------------------------------------ --- | Drops hidden arguments unless --show-implicit. -napps :: Expr -> [NamedArg Expr] -> TCM Expr -napps e = nelims e . map I.Apply +-- | Like @reify@ but instantiates blocking metas, useful for reporting. +reifyUnblocked :: Reify i a => i -> TCM a +reifyUnblocked t = locallyTCState stInstantiateBlocking (const True) $ reify t + +-- Composition of reified applications ------------------------------------ +--UNUSED Liang-Ting 2019-07-16 +---- | Drops hidden arguments unless --show-implicit. +--napps :: Expr -> [NamedArg Expr] -> TCM Expr +--napps e = nelims e . map I.Apply + -- | Drops hidden arguments unless --show-implicit. -apps :: Expr -> [Arg Expr] -> TCM Expr +apps :: MonadReify m => Expr -> [Arg Expr] -> m Expr apps e = elims e . map I.Apply -- Composition of reified eliminations ------------------------------------ -- | Drops hidden arguments unless --show-implicit. -nelims :: Expr -> [I.Elim' (Named_ Expr)] -> TCM Expr +nelims :: MonadReify m => Expr -> [I.Elim' (Named_ Expr)] -> m Expr nelims e [] = return e nelims e (I.IApply x y r : es) = nelims (A.App defaultAppInfo_ e $ defaultArg r) es @@ -112,7 +118,7 @@ | otherwise = nelims (A.App defaultAppInfo_ e (defaultNamedArg $ A.Proj o $ unambiguous d)) es -nelimsProjPrefix :: Expr -> QName -> [I.Elim' (Named_ Expr)] -> TCM Expr +nelimsProjPrefix :: MonadReify m => Expr -> QName -> [I.Elim' (Named_ Expr)] -> m Expr nelimsProjPrefix e d es = nelims (A.App defaultAppInfo_ (A.Proj ProjPrefix $ unambiguous d) $ defaultNamedArg e) es @@ -124,7 +130,7 @@ _ -> False -- | Drops hidden arguments unless --show-implicit. -elims :: Expr -> [I.Elim' Expr] -> TCM Expr +elims :: MonadReify m => Expr -> [I.Elim' Expr] -> m Expr elims e = nelims e . map (fmap unnamed) -- Omitting information --------------------------------------------------- @@ -134,20 +140,34 @@ -- Conditional reification to omit terms that are not shown -------------- -reifyWhenE :: Reify i Expr => Bool -> i -> TCM Expr +reifyWhenE :: (Reify i Expr, MonadReify m) => Bool -> i -> m Expr reifyWhenE True i = reify i reifyWhenE False t = return underscore -- Reification ------------------------------------------------------------ +type MonadReify m = + ( MonadReduce m + , MonadAddContext m + , MonadInteractionPoints m + , MonadFresh NameId m + , HasConstInfo m + , HasOptions m + , HasBuiltins m + , MonadDebug m + ) + class Reify i a | i -> a where - reify :: i -> TCM a + reify :: MonadReify m => i -> m a -- @reifyWhen False@ should produce an 'underscore'. -- This function serves to reify hidden/irrelevant things. - reifyWhen :: Bool -> i -> TCM a + reifyWhen :: MonadReify m => Bool -> i -> m a reifyWhen _ = reify +instance Reify Bool Bool where + reify = return + instance Reify Name Name where reify = return @@ -157,7 +177,7 @@ instance Reify MetaId Expr where reifyWhen = reifyWhenE - reify x@(MetaId n) = liftTCM $ do + reify x@(MetaId n) = do b <- asksTC envPrintMetasBare mi <- mvInfo <$> lookupMeta x let mi' = Info.MetaInfo @@ -199,20 +219,21 @@ -- tries to rewrite @f vs@ with a display form for @f@. -- If successful, reifies the resulting display term, -- otherwise, does @fallback@. -reifyDisplayForm :: QName -> I.Elims -> TCM A.Expr -> TCM A.Expr -reifyDisplayForm f es fallback = do - ifNotM displayFormsEnabled fallback $ {- else -} do - caseMaybeM (liftTCM $ displayForm f es) fallback reify +reifyDisplayForm :: MonadReify m => QName -> I.Elims -> m A.Expr -> m A.Expr +reifyDisplayForm f es fallback = + ifNotM displayFormsEnabled fallback $ {- else -} + caseMaybeM (displayForm f es) fallback reify -- | @reifyDisplayFormP@ tries to recursively -- rewrite a lhs with a display form. -- -- Note: we are not necessarily in the empty context upon entry! reifyDisplayFormP - :: QName -- ^ LHS head symbol + :: MonadReify m + => QName -- ^ LHS head symbol -> A.Patterns -- ^ Patterns to be taken into account to find display form. -> A.Patterns -- ^ Remaining trailing patterns ("with patterns"). - -> TCM (QName, A.Patterns) -- ^ New head symbol and new patterns. + -> m (QName, A.Patterns) -- ^ New head symbol and new patterns. reifyDisplayFormP f ps wps = do let fallback = return (f, ps ++ wps) ifNotM displayFormsEnabled fallback $ {- else -} do @@ -223,7 +244,7 @@ -- and we will have variable clashes. -- But apparently, it has no influence... -- Ulf, can you add an explanation? - md <- liftTCM $ -- addContext (replicate (length ps) "x") $ + md <- -- addContext (replicate (length ps) "x") $ displayForm f $ zipWith (\ p i -> I.Apply $ p $> I.var i) ps [0..] reportSLn "reify.display" 60 $ "display form of " ++ prettyShow f ++ " " ++ show ps ++ " " ++ show wps ++ ":\n " ++ show md @@ -292,7 +313,7 @@ okElim :: Elim' I.Term -> Bool okElim (I.IApply x y r) = okTerm r okElim (I.Apply a) = okArg a - okElim (I.Proj{}) = True + okElim I.Proj{} = True okTerm :: I.Term -> Bool okTerm (I.Var _ []) = True @@ -310,25 +331,26 @@ flattenWith _ = __IMPOSSIBLE__ displayLHS - :: A.Patterns -- ^ Patterns to substituted into display term. + :: MonadReify m + => A.Patterns -- ^ Patterns to substituted into display term. -> DisplayTerm -- ^ Display term. - -> TCM (QName, A.Patterns, A.Patterns) -- ^ New head, patterns, with-patterns. + -> m (QName, A.Patterns, A.Patterns) -- ^ New head, patterns, with-patterns. displayLHS ps d = do let (f, vs, es) = flattenWith d ps <- mapM elimToPat vs wps <- mapM (updateNamedArg (A.WithP empty) <.> elimToPat) es return (f, ps, wps) where - argToPat :: Arg DisplayTerm -> TCM (NamedArg A.Pattern) + argToPat :: MonadReify m => Arg DisplayTerm -> m (NamedArg A.Pattern) argToPat arg = traverse termToPat arg - elimToPat :: I.Elim' DisplayTerm -> TCM (NamedArg A.Pattern) + elimToPat :: MonadReify m => I.Elim' DisplayTerm -> m (NamedArg A.Pattern) elimToPat (I.IApply _ _ r) = argToPat (Arg defaultArgInfo r) elimToPat (I.Apply arg) = argToPat arg elimToPat (I.Proj o d) = return $ defaultNamedArg $ A.ProjP patNoRange o $ unambiguous d -- | Substitute variables in display term by patterns. - termToPat :: DisplayTerm -> TCM (Named_ A.Pattern) + termToPat :: MonadReify m => DisplayTerm -> m (Named_ A.Pattern) -- Main action HERE: termToPat (DTerm (I.Var n [])) = return $ unArg $ fromMaybe __IMPOSSIBLE__ $ ps !!! n @@ -349,11 +371,11 @@ len = length ps - argsToExpr :: I.Args -> TCM [Arg A.Expr] + argsToExpr :: MonadReify m => I.Args -> m [Arg A.Expr] argsToExpr = mapM (traverse termToExpr) -- TODO: restructure this to avoid having to repeat the code for reify - termToExpr :: Term -> TCM A.Expr + termToExpr :: MonadReify m => Term -> m A.Expr termToExpr v = do reportSLn "reify.display" 60 $ "termToExpr " ++ show v -- After unSpine, a Proj elimination is __IMPOSSIBLE__! @@ -384,7 +406,7 @@ reifyWhen = reifyWhenE reify v = reifyTerm True v -reifyPathPConstAsPath :: QName -> Elims -> TCM (QName, Elims) +reifyPathPConstAsPath :: MonadReify m => QName -> Elims -> m (QName, Elims) reifyPathPConstAsPath x es@[I.Apply l, I.Apply t, I.Apply lhs, I.Apply rhs] = do reportSLn "reify.def" 100 $ "reifying def path " ++ show (x,es) mpath <- getBuiltinName' builtinPath @@ -403,7 +425,7 @@ _ -> fallback reifyPathPConstAsPath x es = return (x,es) -reifyTerm :: Bool -> Term -> TCM Expr +reifyTerm :: MonadReify m => Bool -> Term -> m Expr reifyTerm expandAnonDefs0 v0 = do -- Jesper 2018-11-02: If 'PrintMetasBare', drop all meta eliminations. metasBare <- asksTC envPrintMetasBare @@ -425,7 +447,7 @@ let fakeName = (qnameName p) { nameConcrete = C.Name noRange C.InScope [C.Id name] } -- TODO: infix names!? elims (A.Var fakeName) =<< reify es I.Var n es -> do - x <- liftTCM $ nameOfBV n `catchError` \_ -> freshName_ ("@" ++ show n) + x <- fromMaybeM (freshName_ $ "@" ++ show n) $ nameOfBV' n elims (A.Var x) =<< reify es I.Def x es -> do reportSLn "reify.def" 100 $ "reifying def " ++ prettyShow x @@ -439,9 +461,9 @@ showImp <- showImplicitArguments let keep (a, v) = showImp || visible a r <- getConstructorData x - xs <- getRecordFieldNames r + xs <- fromMaybe __IMPOSSIBLE__ <$> getRecordFieldNames_ r vs <- map unArg <$> reify (fromMaybe __IMPOSSIBLE__ $ allApplyElims vs) - return $ A.Rec noExprInfo $ map (Left . uncurry FieldAssignment . mapFst unArg) $ filter keep $ zip xs vs + return $ A.Rec noExprInfo $ map (Left . uncurry FieldAssignment . mapFst unDom) $ filter keep $ zip xs vs False -> reifyDisplayForm x vs $ do def <- getConstInfo x let Constructor{conPars = np} = theDef def @@ -486,7 +508,7 @@ -- I.Lam info b | isAbsurdBody b -> return $ A. AbsurdLam noExprInfo $ getHiding info I.Lam info b -> do (x,e) <- reify b - return $ A.Lam exprNoRange (DomainFree $ unnamedArg info $ BindName x) e + return $ A.Lam exprNoRange (mkDomainFree $ unnamedArg info $ mkBinder_ x) e -- Andreas, 2011-04-07 we do not need relevance information at internal Lambda I.Lit l -> reify l I.Level l -> reify l @@ -504,8 +526,9 @@ {- else -} (reify a) where mkPi b (Arg info a') = do + tac <- traverse reify $ domTactic a (x, b) <- reify b - return $ A.Pi noExprInfo [TBind noRange [Arg info $ Named (domName a) $ BindName x] a'] b + return $ A.Pi noExprInfo [TBind noRange tac [Arg info $ Named (domName a) $ mkBinder_ x] a'] b -- We can omit the domain type if it doesn't have any free variables -- and it's mentioned in the target type. domainFree a b = do @@ -521,7 +544,7 @@ mv <- lookupMeta x (msub1,meta_tel,msub2) <- do local_chkpt <- viewTC eCurrentCheckpoint - (chkpt, tel, msub2) <- enterClosure (getMetaInfo mv) $ \ _ -> + (chkpt, tel, msub2) <- enterClosure mv $ \ _ -> (,,) <$> viewTC eCurrentCheckpoint <*> getContextTelescope <*> viewTC (eCheckpoints . key local_chkpt) @@ -539,7 +562,7 @@ p = mvPermutation mv applyPerm p vs = permute (takeP (size vs) p) vs - names = map unranged $ p `applyPerm` teleNames meta_tel + names = map (WithOrigin Inserted . unranged) $ p `applyPerm` teleNames meta_tel named_es' = addNames names es' dropIdentitySubs sub_local2G sub_tel2G = @@ -562,27 +585,39 @@ nelims x' simpl_named_es' - I.DontCare v -> A.DontCare <$> reifyTerm expandAnonDefs v - I.Dummy s -> return $ A.Lit $ LitString noRange s + I.DontCare v -> do + showIrr <- optShowIrrelevant <$> pragmaOptions + if | showIrr -> reifyTerm expandAnonDefs v + | otherwise -> return underscore + I.Dummy s [] -> return $ A.Lit $ LitString noRange s + I.Dummy "applyE" es | I.Apply (Arg _ h) : es' <- es -> do + h <- reify h + es' <- reify es' + elims h es' + | otherwise -> __IMPOSSIBLE__ + I.Dummy s es -> do + s <- reify (I.Dummy s []) + es <- reify es + elims s es where -- Andreas, 2012-10-20 expand a copy if not in scope -- to improve error messages. -- Don't do this if we have just expanded into a display form, -- otherwise we loop! - reifyDef :: Bool -> QName -> I.Elims -> TCM Expr + reifyDef :: MonadReify m => Bool -> QName -> I.Elims -> m Expr reifyDef True x es = ifM (not . null . inverseScopeLookupName x <$> getScope) (reifyDef' x es) $ do r <- reduceDefCopy x es case r of YesReduction _ v -> do - reportSLn "reify.anon" 60 $ unlines + reportS "reify.anon" 60 [ "reduction on defined ident. in anonymous module" , "x = " ++ prettyShow x , "v = " ++ show v ] reify v NoReduction () -> do - reportSLn "reify.anon" 60 $ unlines + reportS "reify.anon" 60 [ "no reduction on defined ident. in anonymous module" , "x = " ++ prettyShow x , "es = " ++ show es @@ -590,7 +625,7 @@ reifyDef' x es reifyDef _ x es = reifyDef' x es - reifyDef' :: QName -> I.Elims -> TCM Expr + reifyDef' :: MonadReify m => QName -> I.Elims -> m Expr reifyDef' x es = do reportSLn "reify.def" 60 $ "reifying call to " ++ prettyShow x -- We should drop this many arguments from the local context. @@ -616,7 +651,7 @@ vars = map (getArgInfo &&& name . namedArg) $ drop (length es) $ init $ namedClausePats cl lam (i, s) = do x <- freshName_ s - return $ A.Lam exprNoRange (A.DomainFree $ unnamedArg i $ A.BindName x) + return $ A.Lam exprNoRange (A.mkDomainFree $ unnamedArg i $ A.mkBinder_ x) foldr ($) absLam <$> mapM lam vars | otherwise -> elims absLam =<< reify (drop n es) @@ -636,7 +671,8 @@ extLam <- case def of Function{ funExtLam = Just{}, funProjection = Just{} } -> __IMPOSSIBLE__ - Function{ funExtLam = Just (ExtLamInfo m sys) } -> Just . (,sys) . size <$> lookupSection m + Function{ funExtLam = Just (ExtLamInfo m sys) } -> + Just . (,Strict.toLazy sys) . size <$> lookupSection m _ -> return Nothing case extLam of Just (pars, sys) | df, notElem x alreadyPrinting -> @@ -660,13 +696,15 @@ TelV tel _ <- telViewUpTo np (defType defn) let (as, rest) = splitAt (np - 1) $ telToList tel - dom = fromMaybe __IMPOSSIBLE__ $ headMaybe rest + dom = headWithDefault __IMPOSSIBLE__ rest -- These are the dropped projection arguments scope <- getScope let underscore = A.Underscore $ Info.emptyMetaInfo { metaScope = scope } - let pad = for as $ \ (Dom{domInfo = ai, unDom = (x, _)}) -> - Arg ai $ Named (Just $ unranged x) underscore + let pad :: [NamedArg Expr] + pad = for as $ \ (Dom{domInfo = ai, unDom = (x, _)}) -> + Arg ai $ Named (Just $ WithOrigin Inserted $ unranged x) underscore + -- TODO #3353 Origin from Dom? -- Now pad' ++ es' = drop n (pad ++ es) let pad' = drop n pad @@ -690,13 +728,13 @@ let (padVisNamed, padRest) = filterAndRest visible pad' -- Remove the names from the visible arguments. - let padVis = map (fmap (unnamed . namedThing)) padVisNamed + let padVis = map (fmap $ unnamed . namedThing) padVisNamed -- Keep only the rest with the same visibility of @dom@... let padTail = filter (sameHiding dom) padRest -- ... and even the same name. - let padSame = filter ((Just (fst (unDom dom)) ==) . fmap rangedThing . nameOf . unArg) padTail + let padSame = filter ((Just (fst $ unDom dom) ==) . bareNameOf) padTail return $ if null padTail || not showImp then (padVis , map (fmap unnamed) es') @@ -705,7 +743,7 @@ -- If it is not a projection(-like) function, we need no padding. _ -> return ([], map (fmap unnamed) $ drop n es) - reportSLn "reify.def" 70 $ unlines + reportS "reify.def" 70 [ " pad = " ++ show pad , " nes = " ++ show nes ] @@ -733,7 +771,7 @@ -- patterns, we fall back to printing the internal function created for the -- extended lambda, instead trying to construct the nice syntax. - reifyExtLam :: QName -> Int -> Maybe System -> [I.Clause] -> I.Elims -> TCM Expr + reifyExtLam :: MonadReify m => QName -> Int -> Maybe System -> [I.Clause] -> I.Elims -> m Expr reifyExtLam x npars msys cls es = do reportSLn "reify.def" 10 $ "reifying extended lambda " ++ prettyShow x reportSLn "reify.def" 50 $ render $ nest 2 $ vcat @@ -758,7 +796,7 @@ -- | @nameFirstIfHidden (x:a) ({e} es) = {x = e} es@ nameFirstIfHidden :: Dom (ArgName, t) -> [Elim' a] -> [Elim' (Named_ a)] nameFirstIfHidden dom (I.Apply (Arg info e) : es) | notVisible info = - I.Apply (Arg info (Named (Just $ unranged $ fst $ unDom dom) e)) : + I.Apply (Arg info (Named (Just $ WithOrigin Inserted $ unranged $ fst $ unDom dom) e)) : map (fmap unnamed) es nameFirstIfHidden _ es = map (fmap unnamed) es @@ -789,7 +827,7 @@ -- The Monoid instance for Data.Map doesn't require that the values are a -- monoid. -newtype MonoidMap k v = MonoidMap { unMonoidMap :: Map.Map k v } +newtype MonoidMap k v = MonoidMap { _unMonoidMap :: Map.Map k v } instance (Ord k, Monoid v) => Semigroup (MonoidMap k v) where MonoidMap m1 <> MonoidMap m2 = MonoidMap (Map.unionWith mappend m1 m2) @@ -798,19 +836,26 @@ mempty = MonoidMap Map.empty mappend = (<>) +-- | Removes argument names. Preserves names present in the source. +removeNameUnlessUserWritten :: (LensNamed n a, LensOrigin n) => a -> a +removeNameUnlessUserWritten a + | (getOrigin <$> getNameOf a) == Just UserWritten = a + | otherwise = setNameOf Nothing a + + -- | Removes implicit arguments that are not needed, that is, that don't bind -- any variables that are actually used and doesn't do pattern matching. -- Doesn't strip any arguments that were written explicitly by the user. -stripImplicits :: A.Patterns -> A.Patterns -> TCM A.Patterns +stripImplicits :: MonadReify m => A.Patterns -> A.Patterns -> m A.Patterns stripImplicits params ps = do -- if --show-implicit we don't need the names - ifM showImplicitArguments (return $ map (unnamed . namedThing <$>) ps) $ do - reportSLn "reify.implicit" 30 $ unlines + ifM showImplicitArguments (return $ map (fmap removeNameUnlessUserWritten) ps) $ do + reportS "reify.implicit" 30 [ "stripping implicits" , " ps = " ++ show ps ] let ps' = blankDots $ strip ps - reportSLn "reify.implicit" 30 $ unlines + reportS "reify.implicit" 30 [ " ps' = " ++ show ps' ] return ps' @@ -835,17 +880,18 @@ a' = setNamedArg a $ A.WildP $ Info.PatRange $ getRange a goWild = stripName fixedPos a' : stripArgs True as - stripName True = fmap (unnamed . namedThing) + stripName True = fmap removeNameUnlessUserWritten stripName False = id -- TODO: vars appearing in EqualPs shouldn't be stripped. canStrip a = and [ notVisible a , getOrigin a `notElem` [ UserWritten , CaseSplit ] + , (getOrigin <$> getNameOf a) /= Just UserWritten , varOrDot (namedArg a) ] - isUnnamedHidden x = notVisible x && nameOf (unArg x) == Nothing && isNothing (isProjP x) + isUnnamedHidden x = notVisible x && isNothing (getNameOf x) && isNothing (isProjP x) stripArg a = fmap (fmap stripPat) a @@ -867,10 +913,18 @@ varOrDot A.VarP{} = True varOrDot A.WildP{} = True varOrDot A.DotP{} = True - varOrDot (A.ConP cpi _ ps) | patOrigin cpi == ConOSystem - = all varOrDot $ map namedArg ps + varOrDot (A.ConP cpi _ ps) | conPatOrigin cpi == ConOSystem + = conPatLazy cpi == ConPatLazy || all (varOrDot . namedArg) ps varOrDot _ = False +-- | @blankNotInScope e@ replaces variables in expression @e@ with @_@ +-- if they are currently not in scope. +blankNotInScope :: (MonadTCEnv m, BlankVars a) => a -> m a +blankNotInScope e = do + names <- Set.fromList . filter ((== C.InScope) . C.isInScope) <$> getContextNames + return $ blank names e + + -- | @blank bound e@ replaces all variables in expression @e@ that are not in @bound@ by -- an underscore @_@. It is used for printing dot patterns: we don't want to -- make implicit variables explicit, so we blank them out in the dot patterns @@ -958,8 +1012,6 @@ A.Rec i es -> A.Rec i $ blank bound es A.RecUpdate i e es -> uncurry (A.RecUpdate i) $ blank bound (e, es) A.ETel _ -> __IMPOSSIBLE__ - A.QuoteGoal {} -> __IMPOSSIBLE__ - A.QuoteContext {} -> __IMPOSSIBLE__ A.Quote {} -> __IMPOSSIBLE__ A.QuoteTerm {} -> __IMPOSSIBLE__ A.Unquote {} -> __IMPOSSIBLE__ @@ -982,7 +1034,7 @@ blank bound (A.DomainFull bs) = A.DomainFull $ blank bound bs instance BlankVars TypedBinding where - blank bound (TBind r n e) = TBind r n $ blank bound e + blank bound (TBind r t n e) = TBind r t n $ blank bound e blank bound (TLet _ _) = __IMPOSSIBLE__ -- Since the internal syntax has no let bindings left @@ -1018,13 +1070,16 @@ A.EqualP{} -> empty A.WithP _ _ -> empty +instance Binder a => Binder (A.Binder' a) where + varsBoundIn (A.Binder p n) = varsBoundIn (p, n) + instance Binder A.LamBinding where - varsBoundIn (A.DomainFree x) = varsBoundIn x - varsBoundIn (A.DomainFull b) = varsBoundIn b + varsBoundIn (A.DomainFree _ x) = varsBoundIn x + varsBoundIn (A.DomainFull b) = varsBoundIn b instance Binder TypedBinding where - varsBoundIn (TBind _ xs _) = varsBoundIn xs - varsBoundIn (TLet _ bs) = varsBoundIn bs + varsBoundIn (TBind _ _ xs _) = varsBoundIn xs + varsBoundIn (TLet _ bs) = varsBoundIn bs instance Binder BindName where varsBoundIn x = singleton (unBind x) @@ -1040,6 +1095,7 @@ instance Binder a => Binder (Arg a) where instance Binder a => Binder (Named x a) where instance Binder a => Binder [a] where +instance Binder a => Binder (Maybe a) where instance (Binder a, Binder b) => Binder (a, b) where varsBoundIn (x, y) = varsBoundIn x `Set.union` varsBoundIn y @@ -1047,13 +1103,15 @@ -- | Assumes that pattern variables have been added to the context already. -- Picks pattern variable names from context. -reifyPatterns :: MonadTCM tcm => [NamedArg I.DeBruijnPattern] -> tcm [NamedArg A.Pattern] +reifyPatterns :: MonadReify m => [NamedArg I.DeBruijnPattern] -> m [NamedArg A.Pattern] reifyPatterns = mapM $ (stripNameFromExplicit . stripHidingFromPostfixProj) <.> traverse (traverse reifyPat) where + -- #4399 strip also empty names stripNameFromExplicit :: NamedArg p -> NamedArg p stripNameFromExplicit a - | visible a = fmap (unnamed . namedThing) a + | visible a || maybe True (liftA2 (||) null isNoName) (bareNameOf a) = + fmap (unnamed . namedThing) a | otherwise = a stripHidingFromPostfixProj :: IsProjP p => NamedArg p -> NamedArg p @@ -1061,85 +1119,106 @@ Just (o, _) | o /= ProjPrefix -> setHiding NotHidden a _ -> a - reifyPat :: MonadTCM tcm => I.DeBruijnPattern -> tcm A.Pattern + reifyPat :: MonadReify m => I.DeBruijnPattern -> m A.Pattern reifyPat p = do - liftTCM $ reportSLn "reify.pat" 80 $ "reifying pattern " ++ show p + reportSLn "reify.pat" 80 $ "reifying pattern " ++ show p + keepVars <- optKeepPatternVariables <$> pragmaOptions case p of - I.VarP PatODot x -> reifyDotP $ var $ dbPatVarIndex x - I.VarP PatOWild _ -> return $ A.WildP patNoRange - I.VarP PatOAbsurd _ -> return $ A.AbsurdP patNoRange - I.VarP _ x -> reifyVarP x - I.DotP PatOWild _ -> return $ A.WildP patNoRange - I.DotP PatOAbsurd _ -> return $ A.AbsurdP patNoRange - -- If Agda turned a user variable @x@ into @.x@, print it back as @x@. - I.DotP (PatOVar x) v@(I.Var i []) -> do - x' <- nameOfBV i - if nameConcrete x == nameConcrete x' then - return $ A.VarP $ BindName x' - else - reifyDotP v - I.DotP o v -> reifyDotP v - I.LitP l -> return $ A.LitP l - I.ProjP o d -> return $ A.ProjP patNoRange o $ unambiguous d - I.ConP c cpi ps -> case conPRecord cpi of - Just PatOWild -> return $ A.WildP patNoRange - Just PatOAbsurd -> return $ A.AbsurdP patNoRange - _ -> reifyConP c cpi ps - I.DefP o f ps -> case o of + -- Possibly expanded literal pattern (see #4215) + p | Just (PatternInfo PatOLit asB) <- patternInfo p -> do + reduce (I.patternToTerm p) >>= \case + I.Lit l -> addAsBindings asB $ return $ A.LitP l + _ -> __IMPOSSIBLE__ + I.VarP i x -> addAsBindings (patAsNames i) $ case patOrigin i of + o@PatODot -> reifyDotP o $ var $ dbPatVarIndex x PatOWild -> return $ A.WildP patNoRange PatOAbsurd -> return $ A.AbsurdP patNoRange + _ -> reifyVarP x + I.DotP i v -> addAsBindings (patAsNames i) $ case patOrigin i of + PatOWild -> return $ A.WildP patNoRange + PatOAbsurd -> return $ A.AbsurdP patNoRange + -- If Agda turned a user variable @x@ into @.x@, print it back as @x@. + o@(PatOVar x) | I.Var i [] <- v -> do + x' <- nameOfBV i + if nameConcrete x == nameConcrete x' then + return $ A.VarP $ mkBindName x' + else + reifyDotP o v + o -> reifyDotP o v + I.LitP i l -> addAsBindings (patAsNames i) $ return $ A.LitP l + I.ProjP o d -> return $ A.ProjP patNoRange o $ unambiguous d + I.ConP c cpi ps | conPRecord cpi -> addAsBindings (patAsNames $ conPInfo cpi) $ + case patOrigin (conPInfo cpi) of + PatOWild -> return $ A.WildP patNoRange + PatOAbsurd -> return $ A.AbsurdP patNoRange + PatOVar x | keepVars -> return $ A.VarP $ mkBindName x + _ -> reifyConP c cpi ps + I.ConP c cpi ps -> addAsBindings (patAsNames $ conPInfo cpi) $ reifyConP c cpi ps + I.DefP i f ps -> addAsBindings (patAsNames i) $ case patOrigin i of + PatOWild -> return $ A.WildP patNoRange + PatOAbsurd -> return $ A.AbsurdP patNoRange + PatOVar x | keepVars -> return $ A.VarP $ mkBindName x _ -> A.DefP patNoRange (unambiguous f) <$> reifyPatterns ps - I.IApplyP PatODot _ _ x -> reifyDotP $ var $ dbPatVarIndex x - I.IApplyP PatOWild _ _ x -> return $ A.WildP patNoRange - I.IApplyP PatOAbsurd _ _ x -> return $ A.AbsurdP patNoRange - I.IApplyP _ _ _ x -> reifyVarP x + I.IApplyP i _ _ x -> addAsBindings (patAsNames i) $ case patOrigin i of + o@PatODot -> reifyDotP o $ var $ dbPatVarIndex x + PatOWild -> return $ A.WildP patNoRange + PatOAbsurd -> return $ A.AbsurdP patNoRange + _ -> reifyVarP x - reifyVarP :: MonadTCM tcm => DBPatVar -> tcm A.Pattern + reifyVarP :: MonadReify m => DBPatVar -> m A.Pattern reifyVarP x = do - n <- liftTCM $ nameOfBV $ dbPatVarIndex x - case dbPatVarName x of - "_" -> return $ A.VarP $ BindName n - -- Andreas, 2017-09-03: TODO for #2580 - -- Patterns @VarP "()"@ should have been replaced by @AbsurdP@, but the - -- case splitter still produces them. - y -> if prettyShow (nameConcrete n) == "()" then return $ A.VarP (BindName n) else - -- Andreas, 2017-09-03, issue #2729 - -- Restore original pattern name. AbstractToConcrete picks unique names. - return $ A.VarP $ BindName n { nameConcrete = C.Name noRange C.InScope [ C.Id y ] } + n <- nameOfBV $ dbPatVarIndex x + let y = dbPatVarName x + if | y == "_" -> return $ A.VarP $ mkBindName n + -- Andreas, 2017-09-03: TODO for #2580 + -- Patterns @VarP "()"@ should have been replaced by @AbsurdP@, but the + -- case splitter still produces them. + | prettyShow (nameConcrete n) == "()" -> return $ A.VarP (mkBindName n) + -- Andreas, 2017-09-03, issue #2729 + -- Restore original pattern name. AbstractToConcrete picks unique names. + | otherwise -> return $ A.VarP $ + mkBindName n { nameConcrete = C.Name noRange C.InScope [ C.Id y ] } - reifyDotP :: MonadTCM tcm => Term -> tcm A.Pattern - reifyDotP v = do - t <- liftTCM $ reify v - return $ A.DotP patNoRange t + reifyDotP :: MonadReify m => PatOrigin -> Term -> m A.Pattern + reifyDotP o v = do + keepVars <- optKeepPatternVariables <$> pragmaOptions + if | PatOVar x <- o + , keepVars -> return $ A.VarP $ mkBindName x + | otherwise -> A.DotP patNoRange <$> reify v - reifyConP :: MonadTCM tcm + reifyConP :: MonadReify m => ConHead -> ConPatternInfo -> [NamedArg DeBruijnPattern] - -> tcm A.Pattern + -> m A.Pattern reifyConP c cpi ps = do tryRecPFromConP =<< do A.ConP ci (unambiguous (conName c)) <$> reifyPatterns ps where - ci = ConPatInfo origin patNoRange ConPatEager + ci = ConPatInfo origin patNoRange lazy + lazy | conPLazy cpi = ConPatLazy + | otherwise = ConPatEager origin = fromConPatternInfo cpi + addAsBindings :: Functor m => [A.Name] -> m A.Pattern -> m A.Pattern + addAsBindings xs p = foldr (fmap . AsP patNoRange . mkBindName) p xs + -- | If the record constructor is generated or the user wrote a record pattern, -- turn constructor pattern into record pattern. -- Otherwise, keep constructor pattern. -tryRecPFromConP :: MonadTCM tcm => A.Pattern -> tcm A.Pattern +tryRecPFromConP :: MonadReify m => A.Pattern -> m A.Pattern tryRecPFromConP p = do let fallback = return p case p of A.ConP ci c ps -> do - caseMaybeM (liftTCM $ isRecordConstructor $ headAmbQ c) fallback $ \ (r, def) -> do + caseMaybeM (isRecordConstructor $ headAmbQ c) fallback $ \ (r, def) -> do -- If the record constructor is generated or the user wrote a record pattern, -- print record pattern. -- Otherwise, print constructor pattern. - if recNamedCon def && patOrigin ci /= ConORec then fallback else do - fs <- liftTCM $ getRecordFieldNames r + if recNamedCon def && conPatOrigin ci /= ConORec then fallback else do + fs <- fromMaybe __IMPOSSIBLE__ <$> getRecordFieldNames_ r unless (length fs == length ps) __IMPOSSIBLE__ return $ A.RecP patNoRange $ zipWith mkFA fs ps where - mkFA ax nap = FieldAssignment (unArg ax) (namedArg nap) + mkFA ax nap = FieldAssignment (unDom ax) (namedArg nap) _ -> __IMPOSSIBLE__ instance Reify (QNamed I.Clause) A.Clause where @@ -1151,19 +1230,22 @@ ++ "\n f = " ++ prettyShow f ++ "\n toDrop = " ++ show toDrop ++ "\n cl = " ++ show cl + let ell = clauseEllipsis cl ps <- reifyPatterns $ namedClausePats cl - lhs <- uncurry (SpineLHS empty) <$> reifyDisplayFormP f ps [] + lhs <- uncurry (SpineLHS $ empty { lhsEllipsis = ell }) <$> reifyDisplayFormP f ps [] -- Unless @toDrop@ we have already dropped the module patterns from the clauses -- (e.g. for extended lambdas). We still get here with toDrop = True and -- pattern lambdas when doing make-case, so take care to drop the right -- number of parameters. (params , lhs) <- if not toDrop then return ([] , lhs) else do - nfv <- (size <.> lookupSection =<< getDefModule f) `catchError` \_ -> return 0 + nfv <- getDefModule f >>= \case + Left _ -> return 0 + Right m -> size <$> lookupSection m return $ splitParams nfv lhs lhs <- stripImps params lhs reportSLn "reify.clause" 60 $ "reifying NamedClause, lhs = " ++ show lhs - rhs <- caseMaybe (clauseBody cl) (return AbsurdRHS) $ \ e -> do - RHS <$> reify e <*> pure Nothing + rhs <- caseMaybe (clauseBody cl) (return AbsurdRHS) $ \ e -> + RHS <$> reify e <*> pure Nothing reportSLn "reify.clause" 60 $ "reifying NamedClause, rhs = " ++ show rhs let result = A.Clause (spineToLhs lhs) [] rhs A.noWhereDecls (I.clauseCatchall cl) reportSLn "reify.clause" 60 $ "reified NamedClause, result = " ++ show result @@ -1172,13 +1254,21 @@ splitParams n (SpineLHS i f ps) = let (params , pats) = splitAt n ps in (params , SpineLHS i f pats) - stripImps :: [NamedArg A.Pattern] -> SpineLHS -> TCM SpineLHS + stripImps :: MonadReify m => [NamedArg A.Pattern] -> SpineLHS -> m SpineLHS stripImps params (SpineLHS i f ps) = SpineLHS i f <$> stripImplicits params ps instance Reify (QNamed System) [A.Clause] where reify (QNamed f (System tel sys)) = addContext tel $ do - reportSLn "reify.system" 40 $ unlines $ show tel : map show sys + reportS "reify.system" 40 $ show tel : map show sys + view <- intervalView' unview <- intervalUnview' + sys <- flip filterM sys $ \ (phi,t) -> do + allM phi $ \ (u,b) -> do + u <- reduce u + return $ case (view u, b) of + (IZero, True) -> False + (IOne, False) -> False + _ -> True forM sys $ \ (alpha,u) -> do rhs <- RHS <$> reify u <*> pure Nothing ep <- fmap (A.EqualP patNoRange) . forM alpha $ \ (phi,b) -> do @@ -1190,7 +1280,7 @@ ps <- reifyPatterns $ teleNamedArgs tel ps <- stripImplicits [] $ ps ++ [defaultNamedArg ep] let - lhs = SpineLHS (LHSRange noRange) f ps + lhs = SpineLHS empty f ps result = A.Clause (spineToLhs lhs) [] rhs A.noWhereDecls False return result @@ -1203,27 +1293,30 @@ reify s = do s <- instantiateFull s case s of - I.Type (I.Max []) -> return $ A.Set noExprInfo 0 - I.Type (I.Max [I.ClosedLevel n]) -> return $ A.Set noExprInfo n + I.Type (I.ClosedLevel n) -> return $ A.Set noExprInfo n I.Type a -> do a <- reify a return $ A.App defaultAppInfo_ (A.Set noExprInfo 0) (defaultNamedArg a) - I.Prop (I.Max []) -> return $ A.Prop noExprInfo 0 - I.Prop (I.Max [I.ClosedLevel n]) -> return $ A.Prop noExprInfo n + I.Prop (I.ClosedLevel n) -> return $ A.Prop noExprInfo n I.Prop a -> do a <- reify a return $ A.App defaultAppInfo_ (A.Prop noExprInfo 0) (defaultNamedArg a) I.Inf -> do - I.Def inf [] <- primSetOmega + I.Def inf [] <- fromMaybe __IMPOSSIBLE__ <$> getBuiltin' builtinSetOmega return $ A.Def inf I.SizeUniv -> do - I.Def sizeU [] <- primSizeUniv + I.Def sizeU [] <- fromMaybe __IMPOSSIBLE__ <$> getBuiltin' builtinSizeUniv return $ A.Def sizeU - I.PiSort s1 s2 -> do + I.PiSort a s -> do pis <- freshName_ ("piSort" :: String) -- TODO: hack - (e1,e2) <- reify (s1, I.Lam defaultArgInfo $ fmap Sort s2) + (e1,e2) <- reify (getSort a, I.Lam defaultArgInfo $ fmap Sort s) let app x y = A.App defaultAppInfo_ x (defaultNamedArg y) return $ A.Var pis `app` e1 `app` e2 + I.FunSort s1 s2 -> do + funs <- freshName_ ("funSort" :: String) -- TODO: hack + (e1,e2) <- reify (s1 , s2) + let app x y = A.App defaultAppInfo_ x (defaultNamedArg y) + return $ A.Var funs `app` e1 `app` e2 I.UnivSort s -> do univs <- freshName_ ("univSort" :: String) -- TODO: hack e <- reify s @@ -1238,17 +1331,18 @@ -- Andreas, 2017-09-18, issue #2754 -- While type checking the level builtins, they are not -- available for debug printing. Thus, print some garbage instead. - A.Var <$> freshName_ (".#Lacking_Level_Builtins#" :: String) + name <- freshName_ (".#Lacking_Level_Builtins#" :: String) + return $ A.Var name instance (Free i, Reify i a) => Reify (Abs i) (Name, a) where - reify (NoAbs x v) = (,) <$> freshName_ x <*> reify v + reify (NoAbs x v) = freshName_ x >>= \name -> (name,) <$> reify v reify (Abs s v) = do -- If the bound variable is free in the body, then the name "_" is -- replaced by "z". s <- return $ if isUnderscore s && 0 `freeIn` v then "z" else s - x <- freshName_ s + x <- C.setNotInScope <$> freshName_ s e <- addContext x -- type doesn't matter $ reify v return (x,e) @@ -1260,7 +1354,8 @@ (x, bs) <- reify tel let r = getRange e name = domName arg - return $ TBind r [Arg info $ Named name $ BindName x] e : bs + tac <- traverse reify $ domTactic arg + return $ TBind r tac [Arg info $ Named name $ A.mkBinder_ x] e : bs instance Reify i a => Reify (Dom i) (Arg a) where reify (Dom{domInfo = info, unDom = i}) = Arg info <$> reify i diff --git a/src/full/Agda/Syntax/Translation/ReflectedToAbstract.hs b/src/full/Agda/Syntax/Translation/ReflectedToAbstract.hs --- a/src/full/Agda/Syntax/Translation/ReflectedToAbstract.hs +++ b/src/full/Agda/Syntax/Translation/ReflectedToAbstract.hs @@ -6,8 +6,6 @@ import Control.Monad.Reader -import Data.Traversable as Trav hiding (mapM) - import Agda.Syntax.Fixity import Agda.Syntax.Literal import Agda.Syntax.Position @@ -16,23 +14,32 @@ import Agda.Syntax.Abstract as A hiding (Apply) import Agda.Syntax.Abstract.Pattern import Agda.Syntax.Reflected as R +import Agda.Syntax.Internal (Dom,Dom'(..)) import Agda.TypeChecking.Monad as M hiding (MetaInfo) import Agda.Syntax.Scope.Monad (getCurrentModule) -import Agda.Utils.Maybe +import Agda.Utils.Except import Agda.Utils.Monad import Agda.Utils.List +import Agda.Utils.Null import Agda.Utils.Functor import Agda.Utils.Size type Names = [Name] -type WithNames a = ReaderT Names TCM a --- Note: we only need the TCM for fresh names +type MonadReflectedToAbstract m = + ( MonadReader Names m + , MonadFresh NameId m + , MonadError TCErr m + , MonadTCEnv m + , ReadTCState m + , HasOptions m + , HasConstInfo m + ) -- | Adds a new unique name to the current context. -withName :: String -> (Name -> WithNames a) -> WithNames a +withName :: MonadReflectedToAbstract m => String -> (Name -> m a) -> m a withName s f = do name <- freshName_ s ctx <- asks $ map nameConcrete @@ -42,18 +49,34 @@ notTaken xs x = isNoName x || nameConcrete x `notElem` xs -- | Returns the name of the variable with the given de Bruijn index. -askName :: Int -> WithNames (Maybe Name) +askName :: MonadReflectedToAbstract m => Int -> m (Maybe Name) askName i = reader (!!! i) class ToAbstract r a | r -> a where - toAbstract :: r -> WithNames a + toAbstract :: MonadReflectedToAbstract m => r -> m a -- | Translate reflected syntax to abstract, using the names from the current typechecking context. -toAbstract_ :: ToAbstract r a => r -> TCM a +toAbstract_ :: + (ToAbstract r a + , MonadFresh NameId m + , MonadError TCErr m + , MonadTCEnv m + , ReadTCState m + , HasOptions m + , HasConstInfo m + ) => r -> m a toAbstract_ = withShowAllArguments . toAbstractWithoutImplicit -- | Drop implicit arguments unless --show-implicit is on. -toAbstractWithoutImplicit :: ToAbstract r a => r -> TCM a +toAbstractWithoutImplicit :: + (ToAbstract r a + , MonadFresh NameId m + , MonadError TCErr m + , MonadTCEnv m + , ReadTCState m + , HasOptions m + , HasConstInfo m + ) => r -> m a toAbstractWithoutImplicit x = runReaderT (toAbstract x) =<< getContextNames instance ToAbstract r a => ToAbstract (Named name r) (Named name a) where @@ -66,14 +89,14 @@ toAbstract = traverse toAbstract instance ToAbstract r Expr => ToAbstract (Dom r, Name) (A.TypedBinding) where - toAbstract (Dom{domInfo = i,unDom = x}, name) = do + toAbstract (Dom{domInfo = i,unDom = x, domTactic = tac}, name) = do dom <- toAbstract x - return $ TBind noRange [unnamedArg i $ BindName name] dom + return $ mkTBind noRange [unnamedArg i $ mkBinder_ name] dom instance ToAbstract (Expr, Elim) Expr where toAbstract (f, Apply arg) = do arg <- toAbstract arg - showImp <- lift showImplicitArguments + showImp <- showImplicitArguments return $ if showImp || visible arg then App (setOrigin Reflected defaultAppInfo_) f arg else f @@ -94,21 +117,21 @@ mname <- askName i case mname of Nothing -> do - cxt <- lift $ getContextTelescope + cxt <- getContextTelescope names <- asks $ drop (size cxt) . reverse - lift $ withShowAllArguments' False $ typeError $ DeBruijnIndexOutOfScope i cxt names + withShowAllArguments' False $ typeError $ DeBruijnIndexOutOfScope i cxt names Just name -> toAbstract (A.Var name, es) R.Con c es -> toAbstract (A.Con (unambiguous $ killRange c), es) R.Def f es -> do - af <- lift $ mkDef (killRange f) + af <- mkDef (killRange f) toAbstract (af, es) R.Lam h t -> do (e, name) <- toAbstract t let info = setHiding h $ setOrigin Reflected defaultArgInfo - return $ A.Lam exprNoRange (DomainFree $ unnamedArg info $ BindName name) e + return $ A.Lam exprNoRange (mkDomainFree $ unnamedArg info $ mkBinder_ name) e R.ExtLam cs es -> do name <- freshName_ extendedLambdaName - m <- lift $ getCurrentModule + m <- getCurrentModule let qname = qualify m name cname = nameConcrete name defInfo = mkDefInfo cname noFixity' PublicAccess ConcreteDef noRange @@ -124,7 +147,7 @@ where info = emptyMetaInfo{ metaNumber = Just x } R.Unknown -> return $ Underscore emptyMetaInfo -mkDef :: QName -> TCM A.Expr +mkDef :: HasConstInfo m => QName -> m A.Expr mkDef f = ifM (isMacro . theDef <$> getConstInfo f) (return $ A.Macro f) @@ -144,16 +167,16 @@ (names, args) <- toAbstractPats args return (names, A.ConP (ConPatInfo ConOCon patNoRange ConPatEager) (unambiguous $ killRange c) args) R.DotP -> return ([], A.WildP patNoRange) - R.VarP s | isNoName s -> withName "z" $ \ name -> return ([name], A.VarP $ BindName name) + R.VarP s | isNoName s -> withName "z" $ \ name -> return ([name], A.VarP $ mkBindName name) -- Ulf, 2016-08-09: Also bind noNames (#2129). This to make the -- behaviour consistent with lambda and pi. -- return ([], A.WildP patNoRange) - R.VarP s -> withName s $ \ name -> return ([name], A.VarP $ BindName name) + R.VarP s -> withName s $ \ name -> return ([name], A.VarP $ mkBindName name) R.LitP l -> return ([], A.LitP l) R.AbsurdP -> return ([], A.AbsurdP patNoRange) R.ProjP d -> return ([], A.ProjP patNoRange ProjSystem $ unambiguous $ killRange d) -toAbstractPats :: [Arg R.Pattern] -> WithNames (Names, [NamedArg A.Pattern]) +toAbstractPats :: MonadReflectedToAbstract m => [Arg R.Pattern] -> m (Names, [NamedArg A.Pattern]) toAbstractPats pats = case pats of [] -> return ([], []) p:ps -> do @@ -165,11 +188,11 @@ toAbstract (QNamed name (R.Clause pats rhs)) = do (names, pats) <- toAbstractPats pats rhs <- local (names++) $ toAbstract rhs - let lhs = spineToLhs $ SpineLHS (LHSRange noRange) name pats + let lhs = spineToLhs $ SpineLHS empty name pats return $ A.Clause lhs [] (RHS rhs Nothing) noWhereDecls False toAbstract (QNamed name (R.AbsurdClause pats)) = do (_, pats) <- toAbstractPats pats - let lhs = spineToLhs $ SpineLHS (LHSRange noRange) name pats + let lhs = spineToLhs $ SpineLHS empty name pats return $ A.Clause lhs [] AbsurdRHS noWhereDecls False instance ToAbstract [QNamed R.Clause] [A.Clause] where diff --git a/src/full/Agda/Syntax/Treeless.hs b/src/full/Agda/Syntax/Treeless.hs --- a/src/full/Agda/Syntax/Treeless.hs +++ b/src/full/Agda/Syntax/Treeless.hs @@ -14,7 +14,6 @@ import Control.Arrow (first, second) -import Data.Map (Map) import Data.Data (Data) import Data.Word @@ -95,18 +94,35 @@ isPrimEq :: TPrim -> Bool isPrimEq p = p `elem` [PEqI, PEqF, PEqS, PEqC, PEqQ, PEq64] +-- | Strip leading coercions and indicate whether there were some. +coerceView :: TTerm -> (Bool, TTerm) +coerceView = \case + TCoerce t -> (True,) $ snd $ coerceView t + t -> (False, t) + mkTApp :: TTerm -> Args -> TTerm mkTApp x [] = x mkTApp (TApp x as) bs = TApp x (as ++ bs) mkTApp x as = TApp x as -tAppView :: TTerm -> [TTerm] -tAppView = view - where - view t = case t of - TApp a bs -> view a ++ bs - _ -> [t] +tAppView :: TTerm -> (TTerm, [TTerm]) +tAppView = \case + TApp a bs -> second (++ bs) $ tAppView a + t -> (t, []) +-- | Expose the format @coerce f args@. +-- +-- We fuse coercions, even if interleaving with applications. +-- We assume that coercion is powerful enough to satisfy +-- @ +-- coerce (coerce f a) b = coerce f a b +-- @ +coerceAppView :: TTerm -> ((Bool, TTerm), [TTerm]) +coerceAppView = \case + TCoerce t -> first ((True,) . snd) $ coerceAppView t + TApp a bs -> second (++ bs) $ coerceAppView a + t -> ((False, t), []) + tLetView :: TTerm -> ([TTerm], TTerm) tLetView (TLet e b) = first (e :) $ tLetView b tLetView e = ([], e) @@ -215,4 +231,3 @@ instance KillRange Compiled where killRange c = c -- bogus, but not used anyway - diff --git a/src/full/Agda/Termination/CallGraph.hs b/src/full/Agda/Termination/CallGraph.hs --- a/src/full/Agda/Termination/CallGraph.hs +++ b/src/full/Agda/Termination/CallGraph.hs @@ -1,5 +1,5 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE CPP #-} {-# LANGUAGE ImplicitParams #-} -- | Call graphs and related concepts, more or less as defined in @@ -27,13 +27,14 @@ import Prelude hiding (null) import qualified Data.List as List +#if __GLASGOW_HASKELL__ < 804 import Data.Semigroup +#endif import Data.Set (Set) import Agda.Termination.CallMatrix (CallMatrix, CallMatrixAug(..), CMSet(..), CallComb(..)) import qualified Agda.Termination.CallMatrix as CMSet import Agda.Termination.CutOff -import Agda.Termination.SparseMatrix as Matrix import Agda.Utils.Favorites (Favorites) import qualified Agda.Utils.Favorites as Fav @@ -41,10 +42,10 @@ import qualified Agda.Utils.Graph.AdjacencyMap.Unidirectional as Graph import Agda.Utils.Function -import Agda.Utils.Monad + import Agda.Utils.Null import Agda.Utils.PartialOrd -import Agda.Utils.Pretty hiding ((<>)) +import Agda.Utils.Pretty import Agda.Utils.Singleton import Agda.Utils.Tuple diff --git a/src/full/Agda/Termination/CallMatrix.hs b/src/full/Agda/Termination/CallMatrix.hs --- a/src/full/Agda/Termination/CallMatrix.hs +++ b/src/full/Agda/Termination/CallMatrix.hs @@ -1,6 +1,6 @@ --- {-# LANGUAGE CPP #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE ImplicitParams #-} +{-# LANGUAGE CPP #-} module Agda.Termination.CallMatrix where @@ -11,7 +11,9 @@ -- , tests -- ) where +#if __GLASGOW_HASKELL__ < 804 import Data.Semigroup +#endif import Data.Foldable (Foldable) import Data.Traversable (Traversable) @@ -22,10 +24,10 @@ import Agda.Utils.Favorites (Favorites) import qualified Agda.Utils.Favorites as Fav -import Agda.Utils.Monad + import Agda.Utils.Null import Agda.Utils.PartialOrd -import Agda.Utils.Pretty hiding ((<>)) +import Agda.Utils.Pretty import Agda.Utils.Singleton ------------------------------------------------------------------------ diff --git a/src/full/Agda/Termination/CutOff.hs b/src/full/Agda/Termination/CutOff.hs --- a/src/full/Agda/Termination/CutOff.hs +++ b/src/full/Agda/Termination/CutOff.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} -- | Defines 'CutOff' type which is used in "Agda.Interaction.Options". -- This module's purpose is to eliminate the dependency of diff --git a/src/full/Agda/Termination/Inlining.hs b/src/full/Agda/Termination/Inlining.hs deleted file mode 100644 --- a/src/full/Agda/Termination/Inlining.hs +++ /dev/null @@ -1,268 +0,0 @@ -{-# LANGUAGE CPP #-} -{-# LANGUAGE NondecreasingIndentation #-} - --- Author: Ulf Norell --- Created: 2013-11-09 - -{-| - This module defines an inlining transformation on clauses that's run before - termination checking. The purpose is to improve termination checking of with - clauses (issue 59). The transformation inlines generated with-functions - expanding the clauses of the parent function in such a way that termination - checking the expanded clauses guarantees termination of the original function, - while allowing more terminating functions to be accepted. It does in no way - pretend to preserve the semantics of the original function. - - Roughly, the source program - -> f ps with as -> {f ps₁i qsi = bi} - - is represented internally as - -> f ps = f-aux xs as where xs = vars(ps) -> {f-aux ps₂i qsi = bi} where ps₁i = ps[ps₂i/xs] - - The inlining transformation turns this into - -> {f ps = aj} for aj ∈ as -> {f ps₁i qsi = bi} - - The first set of clauses, called 'withExprClauses', ensure that we - don't forget any recursive calls in @as@. - The second set of clauses, henceforth called 'inlinedClauses', - are the surface-level clauses the user sees (and probably reasons about). - - The reason this works is that there is a single call site for each - with-function. - - Note that the lhss of the inlined clauses are not type-correct, - neither with the type of @f@ (since there are additional patterns @qsi@) - nor with the type of @f-aux@ (since there are the surface-level patterns - @ps₁i@ instead of the actual patterns @ps₂i@). - -} -module Agda.Termination.Inlining - ( inlineWithClauses - , isWithFunction - , expandWithFunctionCall ) where - -import Control.Monad.State - -import qualified Data.List as List -import Data.Maybe -import Data.Traversable (traverse) - -import Agda.Syntax.Common -import Agda.Syntax.Internal -import Agda.Syntax.Internal.Pattern -import Agda.TypeChecking.Monad -import Agda.TypeChecking.Pretty -import Agda.TypeChecking.Substitute -import Agda.TypeChecking.Reduce -import Agda.TypeChecking.DisplayForm -import Agda.TypeChecking.Telescope - -import Agda.Utils.List (downFrom) -import Agda.Utils.Maybe -import Agda.Utils.Monad -import Agda.Utils.Permutation -import Agda.Utils.Size - -import Agda.Utils.Impossible -#include "undefined.h" - --- | Returns 'Nothing' if no inlining happened, otherwise, the new clauses. - -inlineWithClauses :: QName -> Clause -> TCM (Maybe [Clause]) -inlineWithClauses f cl = inTopContext $ do - -- Clauses are relative to the empty context, so we operate @inTopContext@. - let noInline = return Nothing - -- The de Bruijn indices of @body@ are relative to the @clauseTel cl@. - body <- fmap stripDontCare <$> instantiate (clauseBody cl) - case body of - Just (Def wf els) -> do - isWith <- isWithFunction wf - reportSDoc "term.with.inline" 20 $ sep - [ "inlineWithClauses: isWithFunction =" - , maybe "" prettyTCM isWith - ] - caseMaybe isWith noInline $ \ f' -> do - if f /= f' then noInline else do - -- The clause body is a with-function call @wf args@. - -- @f@ is the function the with-function belongs to. - let args = fromMaybe __IMPOSSIBLE__ . allApplyElims $ els - - reportSDoc "term.with.inline" 70 $ sep - [ "Found with (raw):", nest 2 $ text $ show cl ] - reportSDoc "term.with.inline" 20 $ sep - [ "Found with:", nest 2 $ prettyTCM $ QNamed f cl ] - - t <- defType <$> getConstInfo wf - cs1 <- withExprClauses cl t args - - reportSDoc "term.with.inline" 70 $ vcat $ - "withExprClauses (raw)" : map (nest 2 . text . show) cs1 - reportSDoc "term.with.inline" 20 $ vcat $ - "withExprClauses" : map (nest 2 . prettyTCM . QNamed f) cs1 - - cs2 <- inlinedClauses f cl t wf - - reportSDoc "term.with.inline" 70 $ vcat $ - "inlinedClauses (raw)" : map (nest 2 . text . show) cs2 - reportSDoc "term.with.inline" 20 $ vcat $ - "inlinedClauses" : map (nest 2 . prettyTCM . QNamed f) cs2 - - return $ Just $ cs1 ++ cs2 - - Just d -> do - reportSLn "term.with.inline" 20 $ "inlineWithClauses: clause body is not a Def" - reportSDoc "term.with.inline" 70 $ sep - [ "inlineWithClauses: clause body is not a Def but " - , (text . show) d - ] - noInline - - Nothing -> do - reportSLn "term.with.inline" 20 $ "inlineWithClauses: no clause body" - noInline - --- | Returns the original clause if no inlining happened, otherwise, --- the new clauses. - -inlineWithClauses' :: QName -> Clause -> TCM [Clause] -inlineWithClauses' f cl = fromMaybe [cl] <$> inlineWithClauses f cl - --- | @withExprClauses cl t as@ generates a clause containing a fake --- call to with-expression @a@ for each @a@ in @as@ that is not --- a variable (and thus cannot contain a recursive call). --- --- Andreas, 2013-11-11: I guess "not a variable" could be generalized --- to "not containing a call to a mutually defined function". --- --- Note that the @as@ stem from the *unraised* clause body of @cl@ --- and thus can be simply 'fmap'ped back there (under all the 'Bind' --- abstractions). --- --- Precondition: we are 'inTopContext'. -withExprClauses :: Clause -> Type -> Args -> TCM [Clause] -withExprClauses cl t args = {- addContext (clauseTel cl) $ -} loop t args where - -- Note: for the following code, it does not matter which context we are in. - -- Restore the @addContext (clauseTel cl)@ if that should become necessary - -- (like when debug printing @args@ etc). - loop t [] = return [] - loop t (a:as) = - case unArg a of - Var i [] -> rest -- TODO: smarter criterion when to skip withExprClause - v -> - (cl { clauseBody = Just v - , clauseType = Just $ defaultArg dom - } :) <$> rest - where - rest = loop (piApply t [a]) as - dom = case unEl t of -- The type is the generated with-function type so we know it - Pi a _ -> unDom a -- doesn't contain anything funny - _ -> __IMPOSSIBLE__ - --- | @inlinedClauses f cl t wf@ inlines the clauses of with-function @wf@ --- of type @t@ into the clause @cl@. The original function name is @f@. --- --- Precondition: we are 'inTopContext'. -inlinedClauses :: QName -> Clause -> Type -> QName -> TCM [Clause] -inlinedClauses f cl t wf = do - -- @wf@ might define a with-function itself, so we first construct - -- the with-inlined clauses @wcs@ of @wf@ recursively. - wcs <- concat <$> (mapM (inlineWithClauses' wf) =<< defClauses <$> getConstInfo wf) - reportSDoc "term.with.inline" 30 $ vcat $ "With-clauses to inline" : - map (nest 2 . prettyTCM . QNamed wf) wcs - mapM (inline f cl t wf) wcs - --- | The actual work horse. --- @inline f pcl t wf wcl@ inlines with-clause @wcl@ of with-function @wf@ --- (of type @t@) into parent clause @pcl@ (original function being @f@). -inline :: QName -> Clause -> Type -> QName -> Clause -> TCM Clause -inline f pcl t wf wcl = inTopContext $ addContext (clauseTel wcl) $ do - -- The tricky part here is to get the variables to line up properly. The - -- order of the arguments to the with-function is not the same as the order - -- of the arguments to the parent function. Fortunately we have already - -- figured out how to turn an application of the with-function into an - -- application of the parent function in the display form. - reportSDoc "term.with.inline" 70 $ "inlining (raw) =" <+> text (show wcl) - Just disp <- displayForm wf $ clauseElims wcl - reportSDoc "term.with.inline" 70 $ "display form (raw) =" <+> text (show disp) - reportSDoc "term.with.inline" 40 $ "display form =" <+> prettyTCM disp - (pats, perm) <- dispToPats disp - - -- Jesper, 2016-07-28: Since the with-clause and the inlined clause both - -- have the same clause telescope and the clause body is now relative to the - -- clause telescope, there is no more need to change the clause body. - return wcl { namedClausePats = numberPatVars __IMPOSSIBLE__ perm pats } - where - numVars = size (clauseTel wcl) - - dispToPats :: DisplayTerm -> TCM ([NamedArg Pattern], Permutation) - dispToPats (DWithApp (DDef _ es) ws zs) = do - let es' = es ++ map (Apply . defaultArg) ws ++ map (fmap DTerm) zs - (ps, (j, ren)) <- (`runStateT` (0, [])) $ mapM (traverse dtermToPat) es' - let perm = Perm j (map snd $ List.sort ren) - return (map ePatToPat ps, perm) - dispToPats t = __IMPOSSIBLE__ - - bindVar i = do - (j, is) <- get - let i' = numVars - i - 1 - case lookup i' is of - Nothing -> True <$ put (j + 1, (i', j) : is) - Just{} -> False <$ put (j + 1, is) - - skip = modify $ \(j, is) -> (j + 1, is) - - ePatToPat :: Elim' Pattern -> NamedArg Pattern - ePatToPat (Apply p) = fmap unnamed p - ePatToPat (IApply x y p) = defaultNamedArg p - ePatToPat (Proj o d) = defaultNamedArg $ ProjP o d - - dtermToPat :: DisplayTerm -> StateT (Int, [(Int, Int)]) TCM Pattern - dtermToPat v = - case v of - DWithApp{} -> __IMPOSSIBLE__ -- I believe - DCon c ci vs -> ConP c (toConPatternInfo ci) . map (fmap unnamed) - <$> mapM (traverse dtermToPat) vs - DDef d es -> do - ifM (return (null es) `and2M` do isJust <$> lift (isProjection d)) - {-then-} (return $ ProjP ProjPrefix d) - {-else-} (dotP (dtermToTerm v) <$ skip) - DDot v -> dotP v <$ skip - DTerm (Var i []) -> - ifM (bindVar i) (varP . nameToPatVarName <$> lift (nameOfBV i)) - (pure $ dotP (Var i [])) - DTerm (Con c ci vs) -> ConP c (toConPatternInfo ci) . map (fmap unnamed) <$> - mapM (traverse (dtermToPat . DTerm)) (fromMaybe __IMPOSSIBLE__ $ allApplyElims vs) - DTerm v -> dotP v <$ skip - -isWithFunction :: MonadTCM tcm => QName -> tcm (Maybe QName) -isWithFunction x = liftTCM $ do - def <- getConstInfo x - return $ case theDef def of - Function{ funWith = w } -> w - _ -> Nothing - -expandWithFunctionCall :: QName -> Elims -> TCM Term -expandWithFunctionCall f es = do - as <- displayFormArities f - case as of - [a] | length es >= a -> do - Just disp <- displayForm f es - return $ dtermToTerm disp - - -- We might get an underapplied with function application (issue1598), in - -- which case we have to eta expand. The resulting term is only used for - -- termination checking, so we don't have to worry about getting hiding - -- information right. - -- Andreas, 2016-07-20 let's pray that there no copatterns needed... - [a] -> do - let pad = a - length es - es' = raise pad es ++ map (Apply . defaultArg . var) (downFrom pad) - Just disp <- displayForm f es' - let info = setOrigin Inserted defaultArgInfo - return $ foldr (\_ -> Lam info . Abs "") (dtermToTerm disp) (replicate pad ()) - _ -> __IMPOSSIBLE__ diff --git a/src/full/Agda/Termination/Monad.hs b/src/full/Agda/Termination/Monad.hs --- a/src/full/Agda/Termination/Monad.hs +++ b/src/full/Agda/Termination/Monad.hs @@ -1,5 +1,3 @@ -{-# LANGUAGE CPP #-} -{-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} -- | The monad for the termination checker. @@ -14,21 +12,19 @@ import Control.Applicative hiding (empty) -#if __GLASGOW_HASKELL__ >= 800 import qualified Control.Monad.Fail as Fail -#endif import Control.Monad.Reader -import Control.Monad.State import Data.Foldable (Foldable) import Data.Traversable (Traversable) import Data.Monoid ( Monoid(..) ) import Data.Semigroup ( Semigroup(..) ) +import qualified Data.Set as Set import Agda.Interaction.Options -import Agda.Syntax.Abstract (IsProjP(..), AllNames) +import Agda.Syntax.Abstract (AllNames) import Agda.Syntax.Common import Agda.Syntax.Internal import Agda.Syntax.Internal.Pattern @@ -42,15 +38,16 @@ import Agda.TypeChecking.Monad import Agda.TypeChecking.Monad.Benchmark import Agda.TypeChecking.Monad.Builtin -import Agda.TypeChecking.Pretty hiding ((<>)) +import Agda.TypeChecking.Pretty import Agda.TypeChecking.Records import Agda.TypeChecking.Reduce import Agda.TypeChecking.Substitute -import Agda.Utils.Except ( MonadError(catchError, throwError) ) +import Agda.Utils.Except ( MonadError ) import Agda.Utils.Function import Agda.Utils.Functor import Agda.Utils.Lens +import Agda.Utils.List ( hasElem ) import Agda.Utils.Maybe import Agda.Utils.Monad import Agda.Utils.Monoid @@ -60,7 +57,6 @@ import Agda.Utils.VarSet (VarSet) import qualified Agda.Utils.VarSet as VarSet -#include "undefined.h" import Agda.Utils.Impossible -- | The mutual block we are checking. @@ -86,8 +82,6 @@ { terUseDotPatterns :: Bool -- ^ Are we mining dot patterns to find evindence of structal descent? - , terInlineWithFunctions :: Bool - -- ^ Do we inline with functions to enhance termination checking of with? , terSizeSuc :: Maybe QName -- ^ The name of size successor, if any. , terSharp :: Maybe QName @@ -150,15 +144,11 @@ -- of these values. -- -- Values that do not have a safe default are set to --- @IMPOSSIBLE@. - --- Note: Do not write @__IMPOSSIBLE__@ in the haddock comment above --- since it will be expanded by the CPP, leading to a haddock parse error. +-- @__IMPOSSIBLE__@. defaultTerEnv :: TerEnv defaultTerEnv = TerEnv { terUseDotPatterns = False -- must be False initially! - , terInlineWithFunctions = True , terSizeSuc = Nothing , terSharp = Nothing , terCutOff = defaultCutOff @@ -193,12 +183,12 @@ deriving ( Functor , Applicative , Monad -#if __GLASGOW_HASKELL__ >= 800 , Fail.MonadFail -#endif , MonadError TCErr , MonadBench Phase + , MonadStatistics , HasOptions + , HasBuiltins , MonadDebug , HasConstInfo , MonadIO @@ -207,6 +197,7 @@ , MonadTCM , ReadTCState , MonadReduce + , MonadAddContext ) instance MonadTer TerM where @@ -232,13 +223,8 @@ -- The name of sharp (if available). sharp <- fmap nameOfSharp <$> coinductionKit - -- Andreas, 2014-08-28 - -- We do not inline with functions if --without-K. - inlineWithFunctions <- not <$> withoutKOption - let tenv = defaultTerEnv - { terInlineWithFunctions = inlineWithFunctions - , terSizeSuc = suc + { terSizeSuc = suc , terSharp = sharp , terCutOff = cutoff } @@ -262,9 +248,6 @@ -- * Modifiers and accessors for the termination environment in the monad. -terGetInlineWithFunctions :: TerM Bool -terGetInlineWithFunctions = terAsks terInlineWithFunctions - terGetUseDotPatterns :: TerM Bool terGetUseDotPatterns = terAsks terUseDotPatterns @@ -386,9 +369,9 @@ -- | Set 'terUseSizeLt' when going under constructor @c@. conUseSizeLt :: QName -> TerM a -> TerM a conUseSizeLt c m = do - caseMaybeM (liftTCM $ isRecordConstructor c) + ifM (liftTCM $ isEtaOrCoinductiveRecordConstructor c) -- Non-eta inductive records are the same as datatypes + (terSetUseSizeLt False m) (terSetUseSizeLt True m) - (const $ terSetUseSizeLt False m) -- | Set 'terUseSizeLt' for arguments following projection @q@. -- We disregard j if null names then "none" else sep (map prettyTCM names) + "found" <+> if null names then "none" else sep (map prettyTCM $ Set.toList names) return $ not $ null names _ -> do reportSLn "term.guardedness" 40 $ prettyShow q ++ " is not a proper projection" @@ -510,7 +493,7 @@ -- for structural descent. unusedVar :: DeBruijnPattern -unusedVar = LitP (LitString noRange "term.unused.pat.var") +unusedVar = litP (LitString noRange "term.unused.pat.var") -- | Extract variables from 'DeBruijnPattern's that could witness a decrease -- via a SIZELT constraint. diff --git a/src/full/Agda/Termination/Order.hs b/src/full/Agda/Termination/Order.hs --- a/src/full/Agda/Termination/Order.hs +++ b/src/full/Agda/Termination/Order.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE ImplicitParams #-} -- | An Abstract domain of relative sizes, i.e., differences @@ -29,7 +28,6 @@ import Agda.Utils.PartialOrd import Agda.Utils.Pretty -#include "undefined.h" import Agda.Utils.Impossible ------------------------------------------------------------------------ diff --git a/src/full/Agda/Termination/RecCheck.hs b/src/full/Agda/Termination/RecCheck.hs --- a/src/full/Agda/Termination/RecCheck.hs +++ b/src/full/Agda/Termination/RecCheck.hs @@ -1,6 +1,5 @@ -{-# LANGUAGE CPP #-} -{- Checking for recursion: +{- | Checking for recursion: - We detect truly (co)recursive definitions by computing the dependency graph and checking for cycles. @@ -12,72 +11,137 @@ This implementation by Andreas. -} +{-# LANGUAGE CPP #-} + module Agda.Termination.RecCheck ( recursive , anyDefs ) where -import Control.Applicative - +import Control.Monad (forM, forM_) import Data.Graph -import Data.List (nub) -import qualified Data.Map as Map +import Data.IntMap (IntMap) import qualified Data.IntMap as IntMap +import Data.Map (Map) +import qualified Data.Map as Map +import Data.Maybe +import Data.Set (Set) +import qualified Data.Set as Set import Agda.Syntax.Internal import Agda.Syntax.Internal.Defs import Agda.TypeChecking.Monad -import Agda.Utils.Pretty (prettyShow) +import Agda.Utils.Functor ((<.>)) +import Agda.Utils.List (hasElem) +import Agda.Utils.Pretty (prettyShow) -#include "undefined.h" import Agda.Utils.Impossible -recursive :: [QName] -> TCM Bool +-- | We compute for each clause the set of potentially recursive names. +type NamesPerClause = IntMap (Set QName) + +-- | Given a list of formally mutually recursive functions, +-- check for actual recursive calls in the bodies of these functions. +-- Returns the actually recursive functions as strongly connected components. +-- +-- As a side effect, update the 'clauseRecursive' field in the +-- clauses belonging to the given functions. +recursive :: [QName] -> TCM [[QName]] recursive names = do - graph <- zip names <$> mapM (\ d -> nub <$> recDef names d) names + -- For each function, get names per clause and total. + (perClauses, nss) <- unzip <$> mapM (recDef (names `hasElem`)) names + -- Create graph suitable for stronglyConnComp. + -- Nodes are identical to node keys. + let graph = zipWith (\ x ns -> (x, x, Set.toList ns)) names nss + let sccs = stronglyConnComp graph + let nonRec = mapMaybe (\case{ AcyclicSCC x -> Just x ; _ -> Nothing}) sccs + let recs = mapMaybe (\case{ CyclicSCC xs -> Just xs; _ -> Nothing}) sccs + reportSLn "rec.graph" 20 $ show graph - return $ cyclic graph --- | A graph is cyclic if it has any strongly connected component. -cyclic :: [(QName, [QName])] -> Bool -cyclic g = or [ True | CyclicSCC _ <- stronglyConnComp g' ] - where g' = map (\ (n, ns) -> ((), n, ns)) g + -- Mark all non-recursive functions and their clauses as such. + mapM_ markNonRecursive nonRec + -- Mark individual clauses of recursive functions: + -------------------------------------------------- + -- Map names to clause numbers to sets of mentioned names. + let clMap = Map.fromList $ zip names perClauses + -- Walk through SCCs. + forM_ recs $ \ scc -> do + -- Does a set of names have an overlap with the current scc? + let overlap s = any (`Set.member` s) scc + -- Walk through members of SCC. + forM_ scc $ \ x -> do + -- Get the NamesPerClause for the current function x. + let perClause = Map.findWithDefault __IMPOSSIBLE__ x clMap + -- A clause is recursive if its calls overlap with its scc. + let recClause i = overlap $ IntMap.findWithDefault __IMPOSSIBLE__ i perClause + markRecursive recClause x + + -- Return recursive SCCs. + return recs + +-- | Mark a function as terminating and all its clauses as non-recursive. +markNonRecursive :: QName -> TCM () +markNonRecursive q = modifySignature $ updateDefinition q $ updateTheDef $ \case + def@Function{} -> def + { funTerminates = Just True + , funClauses = map (\ cl -> cl { clauseRecursive = Just False }) $ funClauses def + } + def -> def + +-- | Mark all clauses of a function as recursive or non-recursive. +markRecursive + :: (Int -> Bool) -- ^ Which clauses are recursive? + -> QName -> TCM () +markRecursive f q = modifySignature $ updateDefinition q $ updateTheDef $ \case + def@Function{} -> def + { funClauses = zipWith (\ i cl -> cl { clauseRecursive = Just (f i) }) [0..] $ funClauses def + } + def -> def + -- | @recDef names name@ returns all definitions from @names@ -- that are used in the type and body of @name@. -recDef :: [QName] -> QName -> TCM [QName] -recDef names name = do +recDef :: (QName -> Bool) -> QName -> TCM (NamesPerClause, Set QName) +recDef include name = do -- Retrieve definition def <- getConstInfo name -- Get names in type - ns1 <- anyDefs names (defType def) + ns1 <- anyDefs include (defType def) -- Get names in body - ns2 <- case theDef def of - Function{ funClauses = cls } -> anyDefs names cls - _ -> return [] + (perClause, ns2) <- case theDef def of + Function{ funClauses = cls } -> do + perClause <- do + forM (zip [0..] cls) $ \ (i, cl) -> + (i,) <$> anyDefs include cl + return (IntMap.fromList perClause, mconcat $ map snd perClause) + _ -> return (mempty, mempty) - reportSLn "rec.graph" 20 $ unlines + reportS "rec.graph" 20 [ "recDef " ++ prettyShow name , " names in the type: " ++ show ns1 , " names in the def: " ++ show ns2 ] - return $ ns1 `mappend` ns2 + return (perClause, ns1 `mappend` ns2) -- | @anysDef names a@ returns all definitions from @names@ -- that are used in @a@. -anyDefs :: GetDefs a => [QName] -> a -> TCM [QName] -anyDefs names a = do +anyDefs :: GetDefs a => (QName -> Bool) -> a -> TCM (Set QName) +anyDefs include a = do -- Prepare function to lookup metas outside of TCM st <- getMetaStore - let lookup (MetaId x) = case mvInstantiation <$> IntMap.lookup x st of - Just (InstV _ v) -> Just v -- TODO: ignoring the lambdas might be bad? - _ -> Nothing + let lookup (MetaId x) = (mvInstantiation <$> IntMap.lookup x st) >>= \case + InstV _ v -> Just v -- TODO: ignoring the lambdas might be bad? + Open -> Nothing + OpenInstance -> Nothing + BlockedConst{} -> Nothing + PostponedTypeCheckingProblem{} -> Nothing -- we collect only those used definitions that are in @names@ - emb d = if d `elem` names then [d] else [] + emb d = if include d then Set.singleton d else Set.empty -- get all the Defs that are in names return $ getDefs' lookup emb a diff --git a/src/full/Agda/Termination/Semiring.hs b/src/full/Agda/Termination/Semiring.hs --- a/src/full/Agda/Termination/Semiring.hs +++ b/src/full/Agda/Termination/Semiring.hs @@ -8,7 +8,7 @@ , boolSemiring ) where -import Data.Monoid + -- | @HasZero@ is needed for sparse matrices, to tell which is the element -- that does not have to be stored. diff --git a/src/full/Agda/Termination/SparseMatrix.hs b/src/full/Agda/Termination/SparseMatrix.hs --- a/src/full/Agda/Termination/SparseMatrix.hs +++ b/src/full/Agda/Termination/SparseMatrix.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {- | Sparse matrices. @@ -52,8 +51,8 @@ import Data.Function import qualified Data.List as List import Data.Maybe -import Data.Monoid + import Data.Foldable (Foldable) import qualified Data.Foldable as Fold import Data.Traversable (Traversable) @@ -63,15 +62,14 @@ import Agda.Termination.Semiring (HasZero(..), Semiring) import qualified Agda.Termination.Semiring as Semiring -import Agda.Utils.Functor + import Agda.Utils.List import Agda.Utils.Maybe -import Agda.Utils.Monad + import Agda.Utils.PartialOrd import Agda.Utils.Pretty hiding (isEmpty) import Agda.Utils.Tuple -#include "undefined.h" import Agda.Utils.Impossible ------------------------------------------------------------------------ @@ -94,11 +92,12 @@ } deriving (Eq, Ord, Show, Ix) --- | Convert a 'Size' to a set of bounds suitable for use with --- the matrices in this module. - -toBounds :: Num i => Size i -> (MIx i, MIx i) -toBounds sz = (MIx { row = 1, col = 1 }, MIx { row = rows sz, col = cols sz }) +-- UNUSED Liang-Ting Chen 2019-07-15 +---- | Convert a 'Size' to a set of bounds suitable for use with +---- the matrices in this module. +-- +--toBounds :: Num i => Size i -> (MIx i, MIx i) +--toBounds sz = (MIx { row = 1, col = 1 }, MIx { row = rows sz, col = cols sz }) -- | Type of matrices, parameterised on the type of values. -- @@ -191,16 +190,17 @@ | i == j = b : aux (i + 1) l' | otherwise = zero : aux (i + 1) l --- Older implementation without replicate. -blowUpSparseVec' :: (Ord i, Num i, Enum i) => b -> i -> [(i,b)] -> [b] -blowUpSparseVec' zero n l = aux 1 l - where aux i [] | i > n = [] - | otherwise = zero : aux (i+1) [] - aux i ((j,b):l) | i <= n && j == i = b : aux (succ i) l - aux i ((j,b):l) | i <= n && j >= i = zero : aux (succ i) ((j,b):l) - aux i l = __IMPOSSIBLE__ - -- error $ "blowUpSparseVec (n = " ++ show n ++ ") aux i=" ++ show i ++ " j=" ++ show (fst (head l)) ++ " length l = " ++ show (length l) - +-- UNUSED Liang-Ting Chen 2019-07-15 +---- Older implementation without replicate. +--blowUpSparseVec' :: (Ord i, Num i, Enum i) => b -> i -> [(i,b)] -> [b] +--blowUpSparseVec' zero n l = aux 1 l +-- where aux i [] | i > n = [] +-- | otherwise = zero : aux (i+1) [] +-- aux i ((j,b):l) | i <= n && j == i = b : aux (succ i) l +-- aux i ((j,b):l) | i <= n && j >= i = zero : aux (succ i) ((j,b):l) +-- aux i l = __IMPOSSIBLE__ +-- -- error $ "blowUpSparseVec (n = " ++ show n ++ ") aux i=" ++ show i ++ " j=" ++ show (fst (head l)) ++ " length l = " ++ show (length l) +-- -- | Converts a matrix to a list of row lists. -- @O(size)@ where @size = rows × cols@. diff --git a/src/full/Agda/Termination/TermCheck.hs b/src/full/Agda/Termination/TermCheck.hs --- a/src/full/Agda/Termination/TermCheck.hs +++ b/src/full/Agda/Termination/TermCheck.hs @@ -1,5 +1,4 @@ {-# LANGUAGE BangPatterns #-} -{-# LANGUAGE CPP #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE ImplicitParams #-} @@ -18,15 +17,9 @@ , Result ) where -#if MIN_VERSION_base(4,11,0) -import Prelude hiding ( (<>), null ) -#else import Prelude hiding ( null ) -#endif -import Control.Applicative hiding (empty) import Control.Monad.Reader -import Control.Monad.State import Data.Foldable (toList) import qualified Data.List as List @@ -42,7 +35,7 @@ import qualified Agda.Syntax.Info as Info import Agda.Syntax.Position import Agda.Syntax.Common -import Agda.Syntax.Translation.InternalToAbstract ( reifyPatterns ) +import Agda.Syntax.Translation.InternalToAbstract (NamedClause(..)) import Agda.Termination.CutOff import Agda.Termination.Monad @@ -54,17 +47,14 @@ import Agda.Termination.Termination (endos, idempotent) import qualified Agda.Termination.Termination as Term import Agda.Termination.RecCheck -import Agda.Termination.Inlining import Agda.TypeChecking.Datatypes -import Agda.TypeChecking.EtaContract import Agda.TypeChecking.Functions import Agda.TypeChecking.Monad import Agda.TypeChecking.Monad.Builtin -import Agda.TypeChecking.Positivity.Occurrence import Agda.TypeChecking.Pretty import Agda.TypeChecking.Records -- (isRecordConstructor, isInductiveRecord) -import Agda.TypeChecking.Reduce (reduce, normalise, instantiate, instantiateFull) +import Agda.TypeChecking.Reduce (reduce, normalise, instantiate, instantiateFull, appDefE') import Agda.TypeChecking.SizedTypes import Agda.TypeChecking.Substitute import Agda.TypeChecking.Telescope @@ -82,12 +72,10 @@ import Agda.Utils.Maybe import Agda.Utils.Monad -- (mapM', forM', ifM, or2M, and2M) import Agda.Utils.Null -import Agda.Utils.Permutation import Agda.Utils.Pretty (prettyShow) import Agda.Utils.Singleton import qualified Agda.Utils.VarSet as VarSet -#include "undefined.h" import Agda.Utils.Impossible -- | Call graph with call info for composed calls. @@ -175,20 +163,6 @@ let allNames = filter (not . isAbsurdLambdaName) $ Set.elems $ mutualNames mutualBlock names = if null names0 then allNames else names0 i = mutualInfo mutualBlock - -- Andreas, 2014-03-26 - -- Keeping recursion check after experiments on the standard lib. - -- Seems still to save 1s. - -- skip = return False - -- No need to term-check if the declarations are acyclic! - skip = not <$> do - -- Andreas, 2016-10-01 issue #2231 - -- Recursivity checker has to see through abstract definitions! - ignoreAbstractMode $ do - billTo [Benchmark.Termination, Benchmark.RecCheck] $ recursive allNames - -- -- Andreas, 2017-03-24, use positivity info to skip non-recursive functions - -- skip = ignoreAbstractMode $ allM allNames $ \ x -> do - -- null <$> getMutual x - -- PROBLEMS with test/Succeed/AbstractCoinduction.agda -- We set the range to avoid panics when printing error messages. setCurrentRange i $ do @@ -200,30 +174,43 @@ reportSLn "term.mutual" 10 $ "Termination checking " ++ prettyShow allNames -- NO_TERMINATION_CHECK - if (Info.mutualTermCheck i `elem` [ NoTerminationCheck, Terminating ]) then do + if (Info.mutualTerminationCheck i `elem` [ NoTerminationCheck, Terminating ]) then do reportSLn "term.warn.yes" 10 $ "Skipping termination check for " ++ prettyShow names forM_ allNames $ \ q -> setTerminates q True -- considered terminating! return mempty -- NON_TERMINATING - else if (Info.mutualTermCheck i == NonTerminating) then do + else if (Info.mutualTerminationCheck i == NonTerminating) then do reportSLn "term.warn.yes" 10 $ "Considering as non-terminating: " ++ prettyShow names forM_ allNames $ \ q -> setTerminates q False return mempty - -- Trivially terminating (non-recursive) - else ifM skip (do + else do + sccs <- do + -- Andreas, 2016-10-01 issue #2231 + -- Recursivity checker has to see through abstract definitions! + ignoreAbstractMode $ do + billTo [Benchmark.Termination, Benchmark.RecCheck] $ recursive allNames + -- -- Andreas, 2017-03-24, use positivity info to skip non-recursive functions + -- skip = ignoreAbstractMode $ allM allNames $ \ x -> do + -- null <$> getMutual x + -- PROBLEMS with test/Succeed/AbstractCoinduction.agda + + -- Trivially terminating (non-recursive)? + when (null sccs) $ reportSLn "term.warn.yes" 10 $ "Trivially terminating: " ++ prettyShow names - forM_ allNames $ \ q -> setTerminates q True - return mempty) - $ {- else -} do + -- Actual termination checking needed: go through SCCs. + concat <$> do + forM sccs $ \ allNames -> do + -- Set the mutual names in the termination environment. + let namesSCC = filter (allNames `hasElem`) names let setNames e = e { terMutual = allNames - , terUserNames = names + , terUserNames = namesSCC } runTerm cont = runTerDefault $ do cutoff <- terGetCutOff - reportSLn "term.top" 10 $ "Termination checking " ++ prettyShow names ++ + reportSLn "term.top" 10 $ "Termination checking " ++ prettyShow namesSCC ++ " with cutoff=" ++ show cutoff ++ "..." terLocal setNames cont @@ -303,7 +290,7 @@ -- We work in TCM exclusively. liftTCM $ do - reportS "term.lex" 20 $ unlines + reportS "term.lex" 20 [ "Calls (" ++ no ++ "dot patterns): " ++ prettyShow calls ] @@ -360,8 +347,9 @@ let index = fromMaybe __IMPOSSIBLE__ $ List.elemIndex name allNames -- Retrieve the target type of the function to check. - - target <- liftTCM $ do typeEndsInDef =<< typeOfConst name + -- #4256: Don't use typeOfConst (which instantiates type with module params), since termination + -- checking is running in the empty context, but with the current module unchanged. + target <- liftTCM $ do typeEndsInDef . defType =<< getConstInfo name reportTarget target terSetTarget target $ do @@ -500,7 +488,7 @@ -- create n variable patterns mkPats n = zipWith mkPat (downFrom n) <$> getContextNames - mkPat i x = notMasked $ VarP PatOSystem $ DBPatVar (prettyShow x) i + mkPat i x = notMasked $ VarP defaultPatternInfo $ DBPatVar (prettyShow x) i -- | Mask arguments and result for termination checking -- according to type of function. @@ -585,8 +573,8 @@ DontCare t -> termToPattern t -- OR: __IMPOSSIBLE__ -- removed by stripAllProjections -- Leaves. Var i [] -> varP . (`DBPatVar` i) . prettyShow <$> nameOfBV i - Lit l -> return $ LitP l - Dummy s -> __IMPOSSIBLE_VERBOSE__ s + Lit l -> return $ litP l + Dummy s _ -> __IMPOSSIBLE_VERBOSE__ s t -> return $ dotP t @@ -600,30 +588,8 @@ -- | Extract recursive calls from one clause. - termClause :: Clause -> TerM Calls termClause clause = do - - -- If with-function inlining is disallowed (e.g. --without-K), - -- we check the original clause. - - let fallback = termClause' clause - ifNotM (terGetInlineWithFunctions) fallback $ {- else -} do - - -- Otherwise, we will do inlining, hence, can skip with-generated functions. - - name <- terGetCurrent - ifM (isJust <$> isWithFunction name) (return mempty) $ {- else -} do - - -- With inlining, the termination check for all subordinated - -- with-functions is included in the parent function. - - (liftTCM $ inlineWithClauses name clause) >>= \case - Nothing -> fallback - Just cls -> terSetHaveInlinedWith $ mapM' termClause' cls - -termClause' :: Clause -> TerM Calls -termClause' clause = do Clause{ clauseTel = tel, namedClausePats = ps, clauseBody = body } <- etaExpandClause clause liftTCM $ reportSDoc "term.check.clause" 25 $ vcat [ "termClause" @@ -711,7 +677,8 @@ SizeUniv -> return empty Type t -> terUnguarded $ extract t -- no guarded levels Prop t -> terUnguarded $ extract t - PiSort s1 s2 -> extract (s1, s2) + PiSort a s -> extract (a, s) + FunSort s1 s2 -> extract (s1, s2) UnivSort s -> extract s MetaS x es -> return empty DefS d es -> return empty @@ -744,21 +711,10 @@ (False, _) -> const Order.unknown terModifyGuarded g' $ extract arg --- | Extract calls from with function application. - -withFunction :: QName -> Elims -> TerM Calls -withFunction g es = do - v <- liftTCM $ -- billTo [Benchmark.Termination, Benchmark.With] $ -- 0ms - expandWithFunctionCall g es - liftTCM $ reportSDoc "term.with.call" 30 $ - "termination checking expanded with-function call:" <+> prettyTCM v - extract v - -- | Handles function applications @g es@. function :: QName -> Elims -> TerM Calls -function g es0 = ifM (terGetInlineWithFunctions `and2M` do isJust <$> isWithFunction g) (withFunction g es0) - $ {-else, no with function-} do +function g es0 = do f <- terGetCurrent names <- terGetMutual @@ -893,6 +849,46 @@ ] return $ CallGraph.insert src tgt cm info calls +-- | Try to get rid of a function call targeting the current SCC +-- using a non-recursive clause. +-- +-- This can help copattern definitions of dependent records. +tryReduceNonRecursiveClause + :: QName -- ^ Function + -> Elims -- ^ Arguments + -> (Term -> TerM Calls) -- ^ Continue here if we managed to reduce. + -> TerM Calls -- ^ Otherwise, continue here. + -> TerM Calls +tryReduceNonRecursiveClause g es continue fallback = do + -- Andreas, 2020-02-06, re: issue #906 + let v0 = Def g es + reportSDoc "term.reduce" 40 $ "Trying to reduce away call: " <+> prettyTCM v0 + + -- First, make sure the function is in the current SCC. + ifM (notElem g <$> terGetMutual) fallback {-else-} $ do + reportSLn "term.reduce" 40 $ "This call is in the current SCC!" + + -- Then, collect its non-recursive clauses. + cls <- liftTCM $ getNonRecursiveClauses g + reportSLn "term.reduce" 40 $ unwords [ "Function has", show (length cls), "non-recursive clauses"] + reportSDoc "term.reduce" 80 $ vcat $ map (prettyTCM . NamedClause g True) cls + + -- Finally, try to reduce with the non-recursive clauses (and no rewrite rules). + r <- liftTCM $ runReduceM $ appDefE' v0 cls [] (map notReduced es) + case r of + NoReduction{} -> fallback + YesReduction _ v -> do + reportSDoc "term.reduce" 30 $ vcat + [ "Termination checker: Successfully reduced away call:" + , nest 2 $ prettyTCM v0 + ] + verboseS "term.reduce" 5 $ tick "termination-checker-reduced-nonrecursive-call" + continue v + +getNonRecursiveClauses :: QName -> TCM [Clause] +getNonRecursiveClauses q = filter nonrec . defClauses <$> getConstInfo q + where nonrec = maybe False not . clauseRecursive + -- | Extract recursive calls from a term. instance ExtractCalls Term where @@ -923,7 +919,7 @@ constructor c ind argsg -- Function, data, or record type. - Def g es -> function g es + Def g es -> tryReduceNonRecursiveClause g es extract $ function g es -- Abstraction. Preserves guardedness. Lam h b -> extract b @@ -966,11 +962,11 @@ -- | Extract recursive calls from level expressions. -deriving instance ExtractCalls Level +instance ExtractCalls Level where + extract (Max n as) = extract as instance ExtractCalls PlusLevel where - extract (ClosedLevel n) = return $ mempty - extract (Plus n l) = extract l + extract (Plus n l) = extract l instance ExtractCalls LevelAtom where extract (MetaLevel x es) = extract es @@ -1042,11 +1038,11 @@ -- off, if inductive. -- -- UNUSED -annotatePatsWithUseSizeLt :: [DeBruijnPattern] -> TerM [(Bool,DeBruijnPattern)] -annotatePatsWithUseSizeLt = loop where - loop [] = return [] - loop (p@(ProjP _ q) : pats) = ((False,p) :) <$> do projUseSizeLt q $ loop pats - loop (p : pats) = (\ b ps -> (b,p) : ps) <$> terGetUseSizeLt <*> loop pats +--annotatePatsWithUseSizeLt :: [DeBruijnPattern] -> TerM [(Bool,DeBruijnPattern)] +--annotatePatsWithUseSizeLt = loop where +-- loop [] = return [] +-- loop (p@(ProjP _ q) : pats) = ((False,p) :) <$> do projUseSizeLt q $ loop pats +-- loop (p : pats) = (\ b ps -> (b,p) : ps) <$> terGetUseSizeLt <*> loop pats -- | @compareElim e dbpat@ @@ -1103,7 +1099,7 @@ def <- theDef <$> getConstInfo r case def of Record{ recFields = fs } -> do - fs <- return $ map unArg fs + fs <- return $ map unDom fs case (List.find (d==) fs, List.find (d'==) fs) of (Just i, Just i') -- earlier field is smaller @@ -1135,20 +1131,21 @@ -- | Stripping off a record constructor is not counted as decrease, in -- contrast to a data constructor. -- A record constructor increases/decreases by 0, a data constructor by 1. -offsetFromConstructor :: MonadTCM tcm => QName -> tcm Int -offsetFromConstructor c = maybe 1 (const 0) <$> do - liftTCM $ isRecordConstructor c +offsetFromConstructor :: HasConstInfo tcm => QName -> tcm Int +offsetFromConstructor c = + ifM (isEtaOrCoinductiveRecordConstructor c) (return 0) (return 1) --- | Compute the proper subpatterns of a 'DeBruijnPattern'. -subPatterns :: DeBruijnPattern -> [DeBruijnPattern] -subPatterns = foldPattern $ \case - ConP _ _ ps -> map namedArg ps - DefP _ _ ps -> map namedArg ps -- TODO check semantics - VarP _ _ -> mempty - LitP _ -> mempty - DotP _ _ -> mempty - ProjP _ _ -> mempty - IApplyP{} -> mempty +--UNUSED Liang-Ting 2019-07-16 +---- | Compute the proper subpatterns of a 'DeBruijnPattern'. +--subPatterns :: DeBruijnPattern -> [DeBruijnPattern] +--subPatterns = foldPattern $ \case +-- ConP _ _ ps -> map namedArg ps +-- DefP _ _ ps -> map namedArg ps -- TODO check semantics +-- VarP _ _ -> mempty +-- LitP _ -> mempty +-- DotP _ _ -> mempty +-- ProjP _ _ -> mempty +-- IApplyP{} -> mempty compareTerm :: Term -> Masked DeBruijnPattern -> TerM Order @@ -1259,7 +1256,7 @@ _ | m -> return Order.unknown - (Lit l, LitP l') + (Lit l, LitP _ l') | l == l' -> return Order.le | otherwise -> return Order.unknown @@ -1299,7 +1296,7 @@ : (length ts == length ps) : zipWith (\ t p -> equal (unArg t) (namedArg p)) ts ps equal (Var i []) (VarP _ x) = i == dbPatVarIndex x - equal (Lit l) (LitP l') = l == l' + equal (Lit l) (LitP _ l') = l == l' -- Terms. -- Checking for identity here is very fragile. -- However, we cannot do much more, as we are not allowed to normalize t. diff --git a/src/full/Agda/Termination/Termination.hs b/src/full/Agda/Termination/Termination.hs --- a/src/full/Agda/Termination/Termination.hs +++ b/src/full/Agda/Termination/Termination.hs @@ -21,12 +21,10 @@ import Agda.Termination.Order import Agda.Termination.SparseMatrix -import Agda.Utils.Either -import Agda.Utils.List import Agda.Utils.Maybe -import Data.Monoid + -- | TODO: This comment seems to be partly out of date. -- -- @'terminates' cs@ checks if the functions represented by @cs@ @@ -65,13 +63,14 @@ ] checkIdems :: (?cutoff :: CutOff) => [CallMatrixAug cinfo] -> Either cinfo () -checkIdems calls = caseMaybe (headMaybe offending) (Right ()) $ Left . augCallInfo +checkIdems calls = caseMaybe (listToMaybe offending) (Right ()) $ Left . augCallInfo where -- Every idempotent call must have decrease, otherwise it offends us. offending = filter (not . hasDecrease) $ filter idempotent calls -checkIdem :: (?cutoff :: CutOff) => CallMatrixAug cinfo -> Bool -checkIdem c = if idempotent c then hasDecrease c else True +-- UNUSED Liang-Ting 2019-07-15 +--checkIdem :: (?cutoff :: CutOff) => CallMatrixAug cinfo -> Bool +--checkIdem c = if idempotent c then hasDecrease c else True -- | A call @c@ is idempotent if it is an endo (@'source' == 'target'@) -- of order 1. diff --git a/src/full/Agda/TypeChecking/Abstract.hs b/src/full/Agda/TypeChecking/Abstract.hs --- a/src/full/Agda/TypeChecking/Abstract.hs +++ b/src/full/Agda/TypeChecking/Abstract.hs @@ -1,13 +1,11 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE UndecidableInstances #-} -- | Functions for abstracting terms over other terms. module Agda.TypeChecking.Abstract where import Control.Monad -import Control.Monad.State import Data.Function -import Data.Traversable +import qualified Data.HashMap.Strict as HMap import Agda.Syntax.Common import Agda.Syntax.Internal @@ -22,24 +20,19 @@ import Agda.Utils.Functor import Agda.Utils.List (splitExactlyAt) -import Agda.Utils.Size import Agda.Utils.Except -import qualified Agda.Utils.HashMap as HMap import Agda.Utils.Impossible -#include "undefined.h" -typeOf :: Type -> Type -typeOf = sort . getSort - -- | @abstractType a v b[v] = b@ where @a : v@. abstractType :: Type -> Term -> Type -> TCM Type abstractType a v (El s b) = El (absTerm v s) <$> abstractTerm a v (sort s) b --- | @piAbstractTerm v a b[v] = (w : a) -> b[w]@ -piAbstractTerm :: Term -> Type -> Type -> TCM Type -piAbstractTerm v a b = do - fun <- mkPi (defaultDom ("w", a)) <$> abstractType a v b +-- | @piAbstractTerm NotHidden v a b[v] = (w : a) -> b[w]@ +-- @piAbstractTerm Hidden v a b[v] = {w : a} -> b[w]@ +piAbstractTerm :: Hiding -> Term -> Type -> Type -> TCM Type +piAbstractTerm h v a b = do + fun <- mkPi (setHiding h $ defaultDom ("w", a)) <$> abstractType a v b reportSDoc "tc.abstract" 50 $ sep [ "piAbstract" <+> sep [ prettyTCM v <+> ":", nest 2 $ prettyTCM a ] , nest 2 $ "from" <+> prettyTCM b @@ -56,18 +49,18 @@ -- -- @piAbstract (prf, Eq a v v') b[v,prf] = (w : a) (w' : Eq a w v') -> b[w,w']@ -piAbstract :: (Term, EqualityView) -> Type -> TCM Type -piAbstract (v, OtherType a) b = piAbstractTerm v a b -piAbstract (prf, eqt@(EqualityType _ _ _ (Arg _ a) v _)) b = do +piAbstract :: WithHiding (Term, EqualityView) -> Type -> TCM Type +piAbstract (WithHiding h (v, OtherType a)) b = piAbstractTerm h v a b +piAbstract (WithHiding h (prf, eqt@(EqualityType _ _ _ (Arg _ a) v _))) b = do s <- inferSort a let prfTy = equalityUnview eqt vTy = El s a b <- abstractType prfTy prf b b <- addContext ("w" :: String, defaultDom prfTy) $ abstractType (raise 1 vTy) (unArg $ raise 1 v) b - return . funType vTy . funType eqTy' . swap01 $ b + return . funType "lhs" vTy . funType "equality" eqTy' . swap01 $ b where - funType a = mkPi $ defaultDom ("w", a) + funType str a = mkPi $ setHiding h $ defaultDom (str, a) -- Abstract the lhs (@a@) of the equality only. eqt1 = raise 1 eqt eqTy' = equalityUnview $ eqt1 { eqtLhs = eqtLhs eqt1 $> var 0 } @@ -79,13 +72,13 @@ instance IsPrefixOf Elims where isPrefixOf us vs = do (vs1, vs2) <- splitExactlyAt (length us) vs - guard $ us == vs1 + guard $ equalSy us vs1 return vs2 instance IsPrefixOf Args where isPrefixOf us vs = do (vs1, vs2) <- splitExactlyAt (length us) vs - guard $ us == vs1 + guard $ equalSy us vs1 return $ map Apply vs2 instance IsPrefixOf Term where @@ -95,7 +88,7 @@ (Def f us, Def g vs) | f == g -> us `isPrefixOf` vs (Con c _ us, Con d _ vs) | c == d -> us `isPrefixOf` vs (MetaV x us, MetaV y vs) | x == y -> us `isPrefixOf` vs - (u, v) -> guard (u == v) >> return [] + (u, v) -> guard (equalSy u v) >> return [] -- Type-based abstraction. Needed if u is a constructor application (#745). abstractTerm :: Type -> Term -> Type -> Term -> TCM Term @@ -138,7 +131,7 @@ -- abstracting the second component). In this case we skip abstraction -- altogether and let the type check of the final with-function type produce -- the error message. - res <- catchError_ (checkInternal' (defaultAction { preAction = abstr }) v b) $ \ err -> do + res <- catchError_ (checkInternal' (defaultAction { preAction = abstr }) v CmpLeq b) $ \ err -> do reportSDoc "tc.abstract.ill-typed" 40 $ "Skipping typed abstraction over ill-typed term" (prettyTCM v (":" <+> prettyTCM b)) return v @@ -168,7 +161,7 @@ Sort s -> Sort $ absT s MetaV m vs -> MetaV m $ absT vs DontCare mv -> DontCare $ absT mv - Dummy s -> Dummy s + Dummy s es -> Dummy s $ absT es where absT x = absTerm u x @@ -181,7 +174,8 @@ Prop n -> Prop $ absS n Inf -> Inf SizeUniv -> SizeUniv - PiSort s1 s2 -> PiSort (absS s1) (absS s2) + PiSort a s -> PiSort (absS a) (absS s) + FunSort s1 s2 -> FunSort (absS s1) (absS s2) UnivSort s -> UnivSort $ absS s MetaS x es -> MetaS x $ absS es DefS d es -> DefS d $ absS es @@ -189,10 +183,9 @@ where absS x = absTerm u x instance AbsTerm Level where - absTerm u (Max as) = Max $ absTerm u as + absTerm u (Max n as) = Max n $ absTerm u as instance AbsTerm PlusLevel where - absTerm u l@ClosedLevel{} = l absTerm u (Plus n l) = Plus n $ absTerm u l instance AbsTerm LevelAtom where @@ -227,3 +220,102 @@ -- | This swaps @var 0@ and @var 1@. swap01 :: (Subst Term a) => a -> a swap01 = applySubst $ var 1 :# liftS 1 (raiseS 1) + + +-- ** Equality of terms for the sake of with-abstraction. + +-- The following could be parameterized by a record of flags +-- what parts of the syntax tree should be ignored. +-- For now, there is a fixed strategy. + +class EqualSy a where + equalSy :: a -> a -> Bool + +instance EqualSy a => EqualSy [a] where + equalSy us vs = and $ (length us == length vs) : zipWith equalSy us vs + +instance EqualSy Term where + equalSy = curry $ \case + (Var i vs, Var i' vs') -> i == i' && equalSy vs vs' + (Con c _ es, Con c' _ es') -> c == c' && equalSy es es' + (Def f es, Def f' es') -> f == f' && equalSy es es' + (MetaV x es, MetaV x' es') -> x == x' && equalSy es es' + (Lit l , Lit l' ) -> l == l' + (Lam ai b, Lam ai' b') -> equalSy ai ai' && equalSy b b' + (Level l , Level l' ) -> equalSy l l' + (Sort s , Sort s' ) -> equalSy s s' + (Pi a b , Pi a' b' ) -> equalSy a a' && equalSy b b' + (DontCare _, DontCare _ ) -> True + -- Irrelevant things are syntactically equal. + (Dummy{} , _ ) -> __IMPOSSIBLE__ + (_ , Dummy{} ) -> __IMPOSSIBLE__ + _ -> False + +instance EqualSy Level where + equalSy (Max n vs) (Max n' vs') = n == n' && equalSy vs vs' + +instance EqualSy PlusLevel where + equalSy (Plus n v) (Plus n' v') = n == n' && equalSy v v' + +instance EqualSy LevelAtom where + equalSy = equalSy `on` unLevelAtom + +instance EqualSy Sort where + equalSy = curry $ \case + (Type l , Type l' ) -> equalSy l l' + (Prop l , Prop l' ) -> equalSy l l' + (Inf , Inf ) -> True + (SizeUniv , SizeUniv ) -> True + (PiSort a b, PiSort a' b') -> equalSy a a' && equalSy b b' + (FunSort a b, FunSort a' b') -> equalSy a a' && equalSy b b' + (UnivSort a, UnivSort a' ) -> equalSy a a' + (MetaS x es, MetaS x' es') -> x == x' && equalSy es es' + (DefS d es, DefS d' es') -> d == d' && equalSy es es' + (DummyS{} , _ ) -> __IMPOSSIBLE__ + (_ , DummyS{} ) -> __IMPOSSIBLE__ + _ -> False + +-- | Ignores sorts. +instance EqualSy Type where + equalSy = equalSy `on` unEl + +instance EqualSy a => EqualSy (Elim' a) where + equalSy = curry $ \case + (Proj _ f, Proj _ f') -> f == f' + (Apply a , Apply a' ) -> equalSy a a' + (IApply u v r, IApply u' v' r') -> and + [ equalSy u u' + , equalSy v v' + , equalSy r r' + ] + _ -> False + +-- | Ignores 'absName'. +instance (Subst t a, EqualSy a) => EqualSy (Abs a) where + equalSy = curry $ \case + (NoAbs _x b, NoAbs _x' b') -> equalSy b b' -- no need to raise if both are NoAbs + (a , a' ) -> equalSy (absBody a) (absBody a') + +-- | Ignore origin and free variables. +instance EqualSy ArgInfo where + equalSy (ArgInfo h m _o _fv) (ArgInfo h' m' _o' _fv') = + h == h' && m == m' + +-- | Ignore the tactic. +instance EqualSy a => EqualSy (Dom a) where + equalSy d@(Dom ai b x _tac a) d'@(Dom ai' b' x' _tac' a') = and + [ x == x' + , b == b' + , equalSy ai ai' + , equalSy a a' + ] + +-- | Ignores irrelevant arguments and modality. +-- (And, of course, origin and free variables). +instance EqualSy a => EqualSy (Arg a) where + equalSy (Arg (ArgInfo h m _o _fv) v) (Arg (ArgInfo h' m' _o' _fv') v') = + h == h' && (isIrrelevant m || isIrrelevant m' || equalSy v v') + -- Andreas, 2017-10-04, issue #2775, + -- ignore irrelevant arguments during with-abstraction. + -- 2019-07-05, issue #3889, don't ignore quantity during caching + -- this is why we let equalSy replace (==). diff --git a/src/full/Agda/TypeChecking/CheckInternal.hs b/src/full/Agda/TypeChecking/CheckInternal.hs --- a/src/full/Agda/TypeChecking/CheckInternal.hs +++ b/src/full/Agda/TypeChecking/CheckInternal.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} -- Initially authored by Andreas, 2013-10-22. @@ -9,7 +8,8 @@ -- have to be reduced since they break bidirectionality. module Agda.TypeChecking.CheckInternal - ( checkType + ( MonadCheckInternal + , checkType , checkType' , checkSort , checkInternal @@ -20,7 +20,7 @@ , shouldBeSort ) where -import Control.Arrow ((&&&), (***), first, second) +import Control.Arrow (first) import Control.Monad import Agda.Syntax.Common @@ -32,7 +32,6 @@ import Agda.TypeChecking.Monad import Agda.TypeChecking.Monad.Builtin import Agda.TypeChecking.Pretty -import Agda.TypeChecking.Primitive import Agda.TypeChecking.ProjectionLike (elimView) import Agda.TypeChecking.Records (getDefType) import Agda.TypeChecking.Reduce @@ -42,21 +41,21 @@ import Agda.Utils.Functor (($>)) -import Agda.Utils.Monad import Agda.Utils.Size -#include "undefined.h" import Agda.Utils.Impossible -- * Bidirectional rechecker +type MonadCheckInternal m = MonadConversion m + -- -- | Entry point for e.g. checking WithFunctionType. -- checkType :: Type -> TCM () -- checkType t = -- dontAssignMetas $ ignoreSorts $ -- checkInternal (unEl t) (sort Inf) -- | Entry point for e.g. checking WithFunctionType. -checkType :: Type -> TCM () +checkType :: (MonadCheckInternal m) => Type -> m () checkType t = void $ checkType' t -- | Check a type and infer its sort. @@ -68,7 +67,7 @@ -- Abel, Coquand, Dybjer, MPC 08, -- Verifying a Semantic βη-Conversion Test for Martin-Löf Type Theory -- -checkType' :: Type -> TCM Sort +checkType' :: (MonadCheckInternal m) => Type -> m Sort checkType' t = do reportSDoc "tc.check.internal" 20 $ sep [ "checking internal type " @@ -82,7 +81,7 @@ let goInside = case b of Abs{} -> addContext (absName b, a) NoAbs{} -> id goInside $ checkType' $ unAbs b - inferPiSort s1 s2 + inferPiSort a s2 Sort s -> do _ <- checkSort defaultAction s inferUnivSort s @@ -100,18 +99,18 @@ v@Lit{} -> typeError $ InvalidType v v@Level{} -> typeError $ InvalidType v DontCare v -> checkType' $ t $> v - Dummy s -> __IMPOSSIBLE_VERBOSE__ s + Dummy s _ -> __IMPOSSIBLE_VERBOSE__ s -checkTypeSpine :: Type -> Term -> Elims -> TCM Sort +checkTypeSpine :: (MonadCheckInternal m) => Type -> Term -> Elims -> m Sort checkTypeSpine a self es = shouldBeSort =<< do snd <$> inferSpine a self es -- | 'checkInternal' traverses the whole 'Term', and we can use this -- traversal to modify the term. -data Action = Action - { preAction :: Type -> Term -> TCM Term +data Action m = Action + { preAction :: Type -> Term -> m Term -- ^ Called on each subterm before the checker runs. - , postAction :: Type -> Term -> TCM Term + , postAction :: Type -> Term -> m Term -- ^ Called on each subterm after the type checking. , relevanceAction :: Relevance -> Relevance -> Relevance -- ^ Called for each @ArgInfo@. @@ -120,14 +119,14 @@ } -- | The default action is to not change the 'Term' at all. -defaultAction :: Action +defaultAction :: Monad m => Action m defaultAction = Action { preAction = \ _ -> return , postAction = \ _ -> return , relevanceAction = \ _ -> id } -eraseUnusedAction :: Action +eraseUnusedAction :: Action TCM eraseUnusedAction = defaultAction { postAction = eraseUnused } where eraseUnused :: Type -> Term -> TCM Term @@ -140,15 +139,15 @@ eraseIfNonvariant :: [Polarity] -> Elims -> Elims eraseIfNonvariant [] es = es eraseIfNonvariant pols [] = [] - eraseIfNonvariant (Nonvariant : pols) (e : es) = (fmap DontCare e) : eraseIfNonvariant pols es + eraseIfNonvariant (Nonvariant : pols) (e : es) = (fmap dontCare e) : eraseIfNonvariant pols es eraseIfNonvariant (_ : pols) (e : es) = e : eraseIfNonvariant pols es -- | Entry point for term checking. -checkInternal :: Term -> Type -> TCM () -checkInternal v t = void $ checkInternal' defaultAction v t +checkInternal :: (MonadCheckInternal m) => Term -> Comparison -> Type -> m () +checkInternal v cmp t = void $ checkInternal' defaultAction v cmp t -checkInternal' :: Action -> Term -> Type -> TCM Term -checkInternal' action v t = do +checkInternal' :: (MonadCheckInternal m) => Action m -> Term -> Comparison -> Type -> m Term +checkInternal' action v cmp t = verboseBracket "tc.check.internal" 20 "" $ do reportSDoc "tc.check.internal" 20 $ sep [ "checking internal " , nest 2 $ sep [ prettyTCM v <+> ":" @@ -159,57 +158,72 @@ postAction action t =<< case v of Var i es -> do a <- typeOfBV i - checkSpine action a (Var i []) es t + reportSDoc "tc.check.internal" 30 $ fsep + [ "variable" , prettyTCM (var i) , "has type" , prettyTCM a ] + checkSpine action a (Var i []) es cmp t Def f es -> do -- f is not projection(-like)! a <- defType <$> getConstInfo f - checkSpine action a (Def f []) es t + checkSpine action a (Def f []) es cmp t MetaV x es -> do -- we assume meta instantiations to be well-typed a <- metaType x - checkSpine action a (MetaV x []) es t + reportSDoc "tc.check.internal" 30 $ "metavariable" <+> prettyTCM x <+> "has type" <+> prettyTCM a + checkSpine action a (MetaV x []) es cmp t Con c ci vs -> do -- We need to fully apply the constructor to make getConType work! fullyApplyCon c vs t $ \ _d _dt _pars a vs' tel t -> do - Con c ci vs2 <- checkSpine action a (Con c ci []) vs' t + Con c ci vs2 <- checkSpine action a (Con c ci []) vs' cmp t -- Strip away the extra arguments return $ applySubst (strengthenS __IMPOSSIBLE__ (size tel)) $ Con c ci $ take (length vs) vs2 - Lit l -> Lit l <$ ((`subtype` t) =<< litType l) + Lit l -> do + lt <- litType l + cmptype cmp lt t + return $ Lit l Lam ai vb -> do (a, b) <- maybe (shouldBePi t) return =<< isPath t ai <- checkArgInfo action ai $ domInfo a - addContext (suggest vb b, a) $ do - Lam ai . Abs (absName vb) <$> checkInternal' action (absBody vb) (absBody b) + let name = suggests [ Suggestion vb , Suggestion b ] + addContext (name, a) $ do + Lam ai . Abs (absName vb) <$> checkInternal' action (absBody vb) cmp (absBody b) Pi a b -> do s <- shouldBeSort t when (s == SizeUniv) $ typeError $ FunctionTypeInSizeUniv v - let st = sort s - sa = getSort a + let sa = getSort a sb = getSort (unAbs b) mkDom v = El sa v <$ a mkRng v = fmap (v <$) b -- Preserve NoAbs goInside = case b of Abs{} -> addContext (absName b, a) NoAbs{} -> id - a <- mkDom <$> checkInternal' action (unEl $ unDom a) (sort sa) - -- TODO: checkPTS sa sb s - goInside $ Pi a . mkRng <$> checkInternal' action (unEl $ unAbs b) (sort sb) + a <- mkDom <$> checkInternal' action (unEl $ unDom a) CmpLeq (sort sa) + v' <- goInside $ Pi a . mkRng <$> checkInternal' action (unEl $ unAbs b) CmpLeq (sort sb) + s' <- sortOf v' + compareSort cmp s' s + return v' Sort s -> do + reportSDoc "tc.check.internal" 30 $ "checking sort" <+> prettyTCM s s <- checkSort action s - Sort s <$ ((sortFitsIn s) =<< shouldBeSort t) -- sortFitsIn ensures @s /= Inf@ + s' <- inferUnivSort s + s'' <- shouldBeSort t + compareSort cmp s' s'' + return $ Sort s Level l -> do l <- checkLevel action l - Level l <$ ((`subtype` t) =<< levelType) - DontCare v -> DontCare <$> checkInternal' action v t - Dummy s -> __IMPOSSIBLE_VERBOSE__ s + lt <- levelType + cmptype cmp lt t + return $ Level l + DontCare v -> DontCare <$> checkInternal' action v cmp t + Dummy s _ -> __IMPOSSIBLE_VERBOSE__ s -- | Make sure a constructor is fully applied -- and infer the type of the constructor. -- Raises a type error if the constructor does not belong to the given type. fullyApplyCon - :: ConHead -- ^ Constructor. + :: (MonadCheckInternal m) + => ConHead -- ^ Constructor. -> Elims -- ^ Constructor arguments. -> Type -- ^ Type of the constructor application. - -> (QName -> Type -> Args -> Type -> Elims -> Telescope -> Type -> TCM a) + -> (QName -> Type -> Args -> Type -> Elims -> Telescope -> Type -> m a) -- ^ Name of the data/record type, -- type of the data/record type, -- reconstructed parameters, @@ -217,27 +231,29 @@ -- full application arguments, -- types of missing arguments (already added to context), -- type of the full application. - -> TCM a + -> m a fullyApplyCon c vs t0 ret = do - TelV tel t <- telView t0 + (TelV tel t, boundary) <- telViewPathBoundaryP t0 -- The type of the constructor application may still be a function -- type. In this case, we introduce the domains @tel@ into the context -- and apply the constructor to these fresh variables. - addContext tel $ do + addContext tel $ ifBlocked t (\m t -> patternViolation) $ \_ t -> do getFullyAppliedConType c t >>= \case Nothing -> typeError $ DoesNotConstructAnElementOf (conName c) t Just ((d, dt, pars), a) -> - ret d dt pars a (raise (size tel) vs ++ map Apply (teleArgs tel)) tel t + ret d dt pars a (raise (size tel) vs ++ teleElims tel boundary) tel t checkSpine - :: Action - -> Type -- ^ Type of the head @self@. - -> Term -- ^ The head @self@. - -> Elims -- ^ The eliminations @es@. - -> Type -- ^ Expected type of the application @self es@. - -> TCM Term -- ^ The application after modification by the @Action@. -checkSpine action a self es t = do + :: (MonadCheckInternal m) + => Action m + -> Type -- ^ Type of the head @self@. + -> Term -- ^ The head @self@. + -> Elims -- ^ The eliminations @es@. + -> Comparison -- ^ Check (@CmpLeq@) or infer (@CmpEq@) the final type. + -> Type -- ^ Expected type of the application @self es@. + -> m Term -- ^ The application after modification by the @Action@. +checkSpine action a self es cmp t = do reportSDoc "tc.check.internal" 20 $ sep [ "checking spine " , nest 2 $ sep [ parens (sep [ prettyTCM self <+> ":" @@ -246,41 +262,42 @@ , nest 2 $ prettyTCM t ] ] ((v, v'), t') <- inferSpine' action a self self es t' <- reduce t' - v' <$ coerceSize subtype v t' t - -checkArgs - :: Action - -> Type -- ^ Type of the head. - -> Term -- ^ The head. - -> Args -- ^ The arguments. - -> Type -- ^ Expected type of the application. - -> TCM Term -- ^ The application after modification by the @Action@. -checkArgs action a self vs t = checkSpine action a self (map Apply vs) t + v' <$ coerceSize (cmptype cmp) v t' t +--UNUSED Liang-Ting Chen 2019-07-16 +--checkArgs +-- :: (MonadCheckInternal m) +-- => Action m +-- -> Type -- ^ Type of the head. +-- -> Term -- ^ The head. +-- -> Args -- ^ The arguments. +-- -> Type -- ^ Expected type of the application. +-- -> m Term -- ^ The application after modification by the @Action@. +--checkArgs action a self vs t = checkSpine action a self (map Apply vs) t -- | @checkArgInfo actual expected@. -- -- The @expected@ 'ArgInfo' comes from the type. -- The @actual@ 'ArgInfo' comes from the term and can be updated -- by an action. -checkArgInfo :: Action -> ArgInfo -> ArgInfo -> TCM ArgInfo +checkArgInfo :: (MonadCheckInternal m) => Action m -> ArgInfo -> ArgInfo -> m ArgInfo checkArgInfo action ai ai' = do checkHiding (getHiding ai) (getHiding ai') r <- checkRelevance action (getRelevance ai) (getRelevance ai') return $ setRelevance r ai -checkHiding :: Hiding -> Hiding -> TCM () +checkHiding :: (MonadCheckInternal m) => Hiding -> Hiding -> m () checkHiding h h' = unless (sameHiding h h') $ typeError $ HidingMismatch h h' -- | @checkRelevance action term type@. -- -- The @term@ 'Relevance' can be updated by the @action@. -checkRelevance :: Action -> Relevance -> Relevance -> TCM Relevance +checkRelevance :: (MonadCheckInternal m) => Action m -> Relevance -> Relevance -> m Relevance checkRelevance action r r' = do unless (r == r') $ typeError $ RelevanceMismatch r r' return $ relevanceAction action r' r -- Argument order for actions: @type@ @term@ -- | Infer type of a neutral term. -infer :: Term -> TCM Type +infer :: (MonadCheckInternal m) => Term -> m Type infer v = do case v of Var i es -> do @@ -294,13 +311,13 @@ _ -> __IMPOSSIBLE__ -- | Infer ordinary function application. -inferDef :: QName -> Elims -> TCM Type +inferDef :: (MonadCheckInternal m) => QName -> Elims -> m Type inferDef f es = do a <- defType <$> getConstInfo f snd <$> inferSpine a (Def f []) es -- | Infer possibly projection-like function application -inferDef' :: QName -> Arg Term -> Elims -> TCM Type +inferDef' :: (MonadCheckInternal m) => QName -> Arg Term -> Elims -> m Type inferDef' f a es = do isProj <- isProjection f case isProj of @@ -314,13 +331,14 @@ -- | @inferSpine t self es@ checks that spine @es@ eliminates -- value @self@ of type @t@ and returns the remaining type -- (target of elimination) and the final self (has that type). -inferSpine :: Type -> Term -> Elims -> TCM (Term, Type) +inferSpine :: (MonadCheckInternal m) => Type -> Term -> Elims -> m (Term, Type) inferSpine a v es = first fst <$> inferSpine' defaultAction a v v es -- | Returns both the real term (first) and the transformed term (second). The -- transformed term is not necessarily a valid term, so it must not be used -- in types. -inferSpine' :: Action -> Type -> Term -> Term -> Elims -> TCM ((Term, Term), Type) +inferSpine' :: (MonadCheckInternal m) + => Action m -> Type -> Term -> Term -> Elims -> m ((Term, Term), Type) inferSpine' action t self self' [] = return ((self, self'), t) inferSpine' action t self self' (e : es) = do reportSDoc "tc.infer.internal" 30 $ sep @@ -333,16 +351,16 @@ case e of IApply x y r -> do (a, b) <- shouldBePath t - r' <- checkInternal' action r (unDom a) + r' <- checkInternal' action r CmpLeq (unDom a) izero <- primIZero ione <- primIOne - x' <- checkInternal' action x (b `absApp` izero) - y' <- checkInternal' action y (b `absApp` ione) + x' <- checkInternal' action x CmpLeq (b `absApp` izero) + y' <- checkInternal' action y CmpLeq (b `absApp` ione) inferSpine' action (b `absApp` r) (self `applyE` [e]) (self' `applyE` [IApply x' y' r']) es Apply (Arg ai v) -> do (a, b) <- shouldBePi t ai <- checkArgInfo action ai $ domInfo a - v' <- checkInternal' action v $ unDom a + v' <- checkInternal' action v CmpLeq $ unDom a inferSpine' action (b `absApp` v) (self `applyE` [e]) (self' `applyE` [Apply (Arg ai v')]) es -- case: projection or projection-like Proj o f -> do @@ -353,45 +371,49 @@ -- | Type should either be a record type of a type eligible for -- the principal argument of projection-like functions. -shouldBeProjectible :: Type -> QName -> TCM Type +shouldBeProjectible :: (MonadCheckInternal m) => Type -> QName -> m Type -- shouldBeProjectible t f = maybe failure return =<< projectionType t f -shouldBeProjectible t f = maybe failure return =<< getDefType f =<< reduce t +shouldBeProjectible t f = ifBlocked t + (\m t -> patternViolation) + (\_ t -> maybe failure return =<< getDefType f t) where failure = typeError $ ShouldBeRecordType t -- TODO: more accurate error that makes sense also for proj.-like funs. -shouldBePath :: Type -> TCM (Dom Type, Abs Type) -shouldBePath t = do - m <- isPath t - case m of - Just p -> return p - Nothing -> typeError $ ShouldBePath t - -shouldBePi :: Type -> TCM (Dom Type, Abs Type) -shouldBePi t = ifPiType t (\ a b -> return (a, b)) $ const $ typeError $ ShouldBePi t - --- | Result is in reduced form. -shouldBeSort :: Type -> TCM Sort -shouldBeSort t = ifIsSort t return (typeError $ ShouldBeASort t) +shouldBePath :: (MonadCheckInternal m) => Type -> m (Dom Type, Abs Type) +shouldBePath t = ifBlocked t + (\m t -> patternViolation) + (\_ t -> do + m <- isPath t + case m of + Just p -> return p + Nothing -> typeError $ ShouldBePath t) -ifIsSort :: Type -> (Sort -> TCM a) -> TCM a -> TCM a -ifIsSort t yes no = do - t <- reduce t - case unEl t of - Sort s -> yes s - _ -> no +shouldBePi :: (MonadCheckInternal m) => Type -> m (Dom Type, Abs Type) +shouldBePi t = ifBlocked t + (\m t -> patternViolation) + (\_ t -> case unEl t of + Pi a b -> return (a , b) + _ -> typeError $ ShouldBePi t) -- | Check if sort is well-formed. -checkSort :: Action -> Sort -> TCM Sort +checkSort :: (MonadCheckInternal m) => Action m -> Sort -> m Sort checkSort action s = case s of Type l -> Type <$> checkLevel action l Prop l -> Prop <$> checkLevel action l Inf -> return Inf SizeUniv -> return SizeUniv - PiSort a b -> do - a <- checkSort action a - addContext (absName b, defaultDom (sort a) :: Dom Type) $ do - PiSort a . Abs (absName b) <$> checkSort action (absBody b) + PiSort dom s2 -> do + let El s1 a = unDom dom + s1' <- checkSort action s1 + a' <- checkInternal' action a CmpLeq $ sort s1' + let dom' = dom $> El s1' a' + s2' <- mapAbstraction dom' (checkSort action) s2 + return $ PiSort dom' s2' + FunSort s1 s2 -> do + s1' <- checkSort action s1 + s2' <- checkSort action s2 + return $ FunSort s1' s2' UnivSort s -> UnivSort <$> checkSort action s MetaS x es -> do -- we assume sort meta instantiations to be well-formed a <- metaType x @@ -414,35 +436,30 @@ DummyS s -> __IMPOSSIBLE_VERBOSE__ s -- | Check if level is well-formed. -checkLevel :: Action -> Level -> TCM Level -checkLevel action (Max ls) = Max <$> mapM checkPlusLevel ls +checkLevel :: (MonadCheckInternal m) => Action m -> Level -> m Level +checkLevel action (Max n ls) = Max n <$> mapM checkPlusLevel ls where - checkPlusLevel l@ClosedLevel{} = return l checkPlusLevel (Plus k l) = Plus k <$> checkLevelAtom l checkLevelAtom l = do lvl <- levelType UnreducedLevel <$> case l of - MetaLevel x es -> checkInternal' action (MetaV x es) lvl - BlockedLevel _ v -> checkInternal' action v lvl - NeutralLevel _ v -> checkInternal' action v lvl - UnreducedLevel v -> checkInternal' action v lvl - --- | Type of a term or sort meta. -metaType :: MetaId -> TCM Type -metaType x = jMetaType . mvJudgement <$> lookupMeta x + MetaLevel x es -> checkInternal' action (MetaV x es) CmpLeq lvl + BlockedLevel _ v -> checkInternal' action v CmpLeq lvl + NeutralLevel _ v -> checkInternal' action v CmpLeq lvl + UnreducedLevel v -> checkInternal' action v CmpLeq lvl -- | Universe subsumption and type equality (subtyping for sizes, resp.). -subtype :: Type -> Type -> TCM () -subtype t1 t2 = do - ifIsSort t1 (\ s1 -> (s1 `leqSort`) =<< shouldBeSort t2) $ do +cmptype :: (MonadCheckInternal m) => Comparison -> Type -> Type -> m () +cmptype cmp t1 t2 = do + ifIsSort t1 (\ s1 -> (compareSort cmp s1) =<< shouldBeSort t2) $ do -- Andreas, 2017-03-09, issue #2493 -- Only check subtyping, do not solve any metas! - dontAssignMetas $ leqType t1 t2 + dontAssignMetas $ compareType cmp t1 t2 -- | Compute the sort of a type. -inferSort :: Term -> TCM Sort +inferSort :: (MonadCheckInternal m) => Term -> m Sort inferSort t = case t of Var i es -> do a <- typeOfBV i @@ -456,18 +473,18 @@ a <- metaType x (_, s) <- eliminate (MetaV x []) a es shouldBeSort s - Pi a b -> inferPiSort (getSort a) (getSort <$> b) + Pi a b -> inferPiSort a (getSort <$> b) Sort s -> inferUnivSort s Con{} -> __IMPOSSIBLE__ Lit{} -> __IMPOSSIBLE__ Lam{} -> __IMPOSSIBLE__ Level{} -> __IMPOSSIBLE__ DontCare{} -> __IMPOSSIBLE__ - Dummy s -> __IMPOSSIBLE_VERBOSE__ s + Dummy s _ -> __IMPOSSIBLE_VERBOSE__ s -- | @eliminate t self es@ eliminates value @self@ of type @t@ by spine @es@ -- and returns the remaining value and its type. -eliminate :: Term -> Type -> Elims -> TCM (Term, Type) +eliminate :: (MonadCheckInternal m) => Term -> Type -> Elims -> m (Term, Type) eliminate self t [] = return (self, t) eliminate self t (e : es) = case e of Apply (Arg _ v) -> ifNotPiType t __IMPOSSIBLE__ {-else-} $ \ _ b -> diff --git a/src/full/Agda/TypeChecking/CheckInternal.hs-boot b/src/full/Agda/TypeChecking/CheckInternal.hs-boot --- a/src/full/Agda/TypeChecking/CheckInternal.hs-boot +++ b/src/full/Agda/TypeChecking/CheckInternal.hs-boot @@ -1,17 +1,43 @@ +{-# LANGUAGE KindSignatures #-} + module Agda.TypeChecking.CheckInternal where +import qualified Control.Monad.Fail as Fail + +import qualified Data.Kind as Hs + import Agda.Syntax.Internal -import Agda.TypeChecking.Monad.Base (TCM) +import Agda.TypeChecking.Monad +import Agda.TypeChecking.Monad.Builtin (HasBuiltins) +import Agda.TypeChecking.Monad.Statistics (MonadStatistics) +import Agda.TypeChecking.Warnings +import Agda.Utils.Except ( MonadError ) -data Action +type MonadCheckInternal m = + ( MonadReduce m + , MonadAddContext m + , MonadConstraint m + , MonadMetaSolver m + , MonadError TCErr m + , MonadWarning m + , MonadDebug m + , MonadStatistics m + , MonadFresh ProblemId m + , MonadFresh Int m + , HasBuiltins m + , HasConstInfo m + , HasOptions m + , Fail.MonadFail m + ) -defaultAction :: Action -eraseUnusedAction :: Action +data Action (m :: Hs.Type -> Hs.Type) -checkType :: Type -> TCM () -checkType' :: Type -> TCM Sort -checkSort :: Action -> Sort -> TCM Sort -checkInternal :: Term -> Type -> TCM () -checkInternal' :: Action -> Term -> Type -> TCM Term -infer :: Term -> TCM Type -shouldBeSort :: Type -> TCM Sort +defaultAction :: Monad m => Action m +eraseUnusedAction :: Action TCM + +checkType :: (MonadCheckInternal m) => Type -> m () +checkType' :: (MonadCheckInternal m) => Type -> m Sort +checkSort :: (MonadCheckInternal m) => Action m -> Sort -> m Sort +checkInternal :: (MonadCheckInternal m) => Term -> Comparison -> Type -> m () +checkInternal' :: (MonadCheckInternal m) => Action m -> Term -> Comparison -> Type -> m Term +infer :: (MonadCheckInternal m) => Term -> m Type diff --git a/src/full/Agda/TypeChecking/CompiledClause.hs b/src/full/Agda/TypeChecking/CompiledClause.hs --- a/src/full/Agda/TypeChecking/CompiledClause.hs +++ b/src/full/Agda/TypeChecking/CompiledClause.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE DeriveDataTypeable #-} -- | Case trees. @@ -14,10 +13,10 @@ import qualified Data.Map as Map import Data.Map (Map) import Data.Semigroup hiding (Arg(..)) -import Data.Foldable hiding (null) -import Data.Traversable -import Data.Maybe + + + import Data.Data (Data) import Agda.Syntax.Common @@ -27,9 +26,8 @@ import Agda.Syntax.Position import Agda.Utils.Null -import Agda.Utils.Pretty hiding ((<>)) +import Agda.Utils.Pretty -#include "undefined.h" import Agda.Utils.Impossible data WithArity c = WithArity { arity :: Int, content :: c } diff --git a/src/full/Agda/TypeChecking/CompiledClause/Compile.hs b/src/full/Agda/TypeChecking/CompiledClause/Compile.hs --- a/src/full/Agda/TypeChecking/CompiledClause/Compile.hs +++ b/src/full/Agda/TypeChecking/CompiledClause/Compile.hs @@ -1,23 +1,17 @@ -{-# LANGUAGE CPP #-} module Agda.TypeChecking.CompiledClause.Compile where import Prelude hiding (null) import Control.Applicative -import Control.Arrow (first, second) import Control.Monad +import Control.Monad.Trans.Identity import Data.Maybe -import Data.Monoid import qualified Data.Map as Map -import Data.List (nubBy, findIndex) +import Data.List (nubBy) import Data.Function -import qualified Data.IntSet as IntSet -import Data.Traversable (traverse) -import Debug.Trace - import Agda.Syntax.Common import Agda.Syntax.Internal import Agda.Syntax.Internal.Pattern @@ -29,17 +23,15 @@ import Agda.TypeChecking.RecordPatterns import Agda.TypeChecking.Substitute import Agda.TypeChecking.Pretty -import Agda.TypeChecking.Free import Agda.TypeChecking.Free.Precompute import Agda.TypeChecking.Reduce import Agda.Utils.Functor import Agda.Utils.Maybe -import Agda.Utils.Null import Agda.Utils.List import qualified Agda.Utils.Pretty as P +import Agda.Utils.Update -#include "undefined.h" import Agda.Utils.Impossible data RunRecordPatternTranslation = RunRecordPatternTranslation | DontRunRecordPatternTranslation @@ -47,16 +39,12 @@ compileClauses' :: RunRecordPatternTranslation -> [Clause] -> Maybe SplitTree -> TCM CompiledClauses compileClauses' recpat cs mSplitTree = do - -- Apply forcing translation. This only shuffles the deBruijn variables - -- so doesn't affect the right hand side. - cs <- sequence [ forcingTranslation ps <&> \ qs -> c{ namedClausePats = qs } - | c@Clause{ namedClausePats = ps } <- cs ] -- Throw away the unreachable clauses (#2723). let notUnreachable = (Just True /=) . clauseUnreachable cs <- map unBruijn <$> normaliseProjP (filter notUnreachable cs) - let translate | recpat == RunRecordPatternTranslation = translateCompiledClauses + let translate | recpat == RunRecordPatternTranslation = runIdentityT . translateCompiledClauses | otherwise = return translate $ caseMaybe mSplitTree (compile cs) $ \splitTree -> @@ -71,17 +59,19 @@ -- Phases 1. and 2. are skipped if @Nothing@. compileClauses :: Maybe (QName, Type) -- ^ Translate record patterns and coverage check with given type? - -> [Clause] -> TCM (Maybe SplitTree, CompiledClauses) + -> [Clause] + -> TCM (Maybe SplitTree, Bool, CompiledClauses) + -- ^ The 'Bool' indicates whether we turned a record expression into a copattern match. compileClauses mt cs = do -- Construct clauses with pattern variables bound in left-to-right order. -- Discard de Bruijn indices in patterns. case mt of - Nothing -> (Nothing,) . compile . map unBruijn <$> normaliseProjP cs + Nothing -> (Nothing,False,) . compile . map unBruijn <$> normaliseProjP cs Just (q, t) -> do splitTree <- coverageCheck q t cs reportSDoc "tc.cc.tree" 20 $ vcat - [ "split tree from coverage check " + [ "split tree of " <+> prettyTCM q <+> " from coverage check " , return $ P.pretty splitTree ] @@ -93,21 +83,21 @@ let cls = map unBruijn cs reportSDoc "tc.cc" 30 $ sep $ do - "clauses patterns before compilation" : do + ("clauses patterns of " <+> prettyTCM q <+> " before compilation") : do map (prettyTCM . map unArg . clPats) cls reportSDoc "tc.cc" 50 $ - "clauses before compilation" pretty cs + "clauses of " <+> prettyTCM q <+> " before compilation" pretty cs let cc = compileWithSplitTree splitTree cls reportSDoc "tc.cc" 20 $ sep - [ "compiled clauses (still containing record splits)" + [ "compiled clauses of " <+> prettyTCM q <+> " (still containing record splits)" , nest 2 $ return $ P.pretty cc ] - cc <- translateCompiledClauses cc + (cc, becameCopatternLHS) <- runChangeT $ translateCompiledClauses cc reportSDoc "tc.cc" 12 $ sep - [ "compiled clauses" + [ "compiled clauses of " <+> prettyTCM q , nest 2 $ return $ P.pretty cc ] - return (Just splitTree, fmap precomputeFreeVars_ cc) + return (Just splitTree, becameCopatternLHS, fmap precomputeFreeVars_ cc) -- | Stripped-down version of 'Agda.Syntax.Internal.Clause' -- used in clause compiler. @@ -132,7 +122,7 @@ compileWithSplitTree :: SplitTree -> Cls -> CompiledClauses compileWithSplitTree t cs = case t of - SplitAt i ts -> Case i $ compiles ts $ splitOn (length ts == 1) (unArg i) cs + SplitAt i lz ts -> Case i $ compiles lz ts $ splitOn (length ts == 1) (unArg i) cs -- if there is just one case, we force expansion of catch-alls -- this is needed to generate a sound tree on which we can -- collapse record pattern splits @@ -140,18 +130,20 @@ -- after end of split tree, continue with left-to-right strategy where - compiles :: SplitTrees -> Case Cls -> Case CompiledClauses - compiles ts br@Branches{ projPatterns = cop - , conBranches = cons - , etaBranch = Nothing - , litBranches = lits - , fallThrough = fT - , catchAllBranch = catchAll } + compiles :: LazySplit -> SplitTrees -> Case Cls -> Case CompiledClauses + compiles lz ts br@Branches{ projPatterns = cop + , conBranches = cons + , etaBranch = Nothing + , litBranches = lits + , fallThrough = fT + , catchAllBranch = catchAll + , lazyMatch = lazy } = br{ conBranches = updCons cons , etaBranch = Nothing , litBranches = updLits lits , fallThrough = fT , catchAllBranch = updCatchall catchAll + , lazyMatch = lazy || lz == LazySplit } where updCons = Map.mapWithKey $ \ c cl -> @@ -160,7 +152,7 @@ updLits = Map.mapWithKey $ \ l cl -> caseMaybe (lookup (SplitLit l) ts) compile compileWithSplitTree cl updCatchall = fmap $ caseMaybe (lookup SplitCatchall ts) compile compileWithSplitTree - compiles _ Branches{etaBranch = Just{}} = __IMPOSSIBLE__ -- we haven't inserted eta matches yet + compiles _ _ Branches{etaBranch = Just{}} = __IMPOSSIBLE__ -- we haven't inserted eta matches yet compile :: Cls -> CompiledClauses compile [] = Fail @@ -193,7 +185,7 @@ nonLazy _ (ConP _ cpi _) = not $ conPLazy cpi nonLazy _ _ = True - findSplit okPat ps = headMaybe (catMaybes $ + findSplit okPat ps = listToMaybe (catMaybes $ zipWith (\ (Arg ai p) n -> (, Arg ai n) <$> properSplit p <* guard (okPat n p)) ps [0..]) allAgree i (ConP c _ _) = all ((== Just (conName c)) . getCon . map unArg . drop i . clPats) cs @@ -205,7 +197,7 @@ -- | Is is not a variable pattern? -- And if yes, is it a record pattern and/or a fallThrough one? properSplit :: Pattern' a -> Maybe Bool -properSplit (ConP _ cpi _) = Just (Just PatORec == conPRecord cpi || conPFallThrough cpi) +properSplit (ConP _ cpi _) = Just ((conPRecord cpi && patOrigin (conPInfo cpi) == PatORec) || conPFallThrough cpi) properSplit DefP{} = Just False properSplit LitP{} = Just False properSplit ProjP{} = Just False @@ -240,12 +232,12 @@ Cl (ps0 ++ map (fmap namedThing) qs ++ ps1) b) { lazyMatch = conPLazy i } DefP o q qs -> (conCase q False $ WithArity (length qs) $ Cl (ps0 ++ map (fmap namedThing) qs ++ ps1) b) { lazyMatch = False } - LitP l -> litCase l $ Cl (ps0 ++ ps1) b + LitP _ l -> litCase l $ Cl (ps0 ++ ps1) b VarP{} -> fallback DotP{} -> fallback where (ps0, rest) = splitAt n ps - mp = unArg <$> headMaybe rest + mp = unArg <$> listToMaybe rest ps1 = drop 1 rest fallback = catchAll $ Cl ps b @@ -343,14 +335,14 @@ -- True if nth pattern exists and is variable. exCatchAllNth ps = any (isVar . unArg) $ take 1 $ drop n ps - classify (LitP l) = Left l + classify (LitP _ l) = Left l classify (ConP c _ _) = Right (Left c) classify (DefP _ q _) = Right (Right q) classify _ = __IMPOSSIBLE__ -- All non-catch-all patterns following this one (at position n). -- These are the cases the wildcard needs to be expanded into. - expansions = nubBy ((==) `on` (classify . unArg . snd)) + expansions = nubOn (classify . unArg . snd) . mapMaybe (notVarNth . clPats) $ cs notVarNth @@ -359,7 +351,7 @@ , Arg Pattern) -- @n+1@st pattern, not a variable notVarNth ps = do let (ps1, ps2) = splitAt n ps - p <- headMaybe ps2 + p <- listToMaybe ps2 guard $ not $ isVar $ unArg p return (ps1, p) @@ -374,7 +366,7 @@ -- TODO Andrea: might need these to sometimes be IApply? conPArgs = map (fmap ($> varP "_")) qs' conArgs = zipWith (\ q' i -> q' $> var i) qs' $ downFrom m - LitP l -> Cl (ps0 ++ [q $> LitP l] ++ ps1) (substBody n' 0 (Lit l) b) + LitP i l -> Cl (ps0 ++ [q $> LitP i l] ++ ps1) (substBody n' 0 (Lit l) b) DefP o d qs' -> Cl (ps0 ++ [q $> DefP o d conPArgs] ++ ps1) (substBody n' m (Def d (map Apply conArgs)) b) where diff --git a/src/full/Agda/TypeChecking/CompiledClause/Compile.hs-boot b/src/full/Agda/TypeChecking/CompiledClause/Compile.hs-boot --- a/src/full/Agda/TypeChecking/CompiledClause/Compile.hs-boot +++ b/src/full/Agda/TypeChecking/CompiledClause/Compile.hs-boot @@ -5,4 +5,4 @@ import Agda.TypeChecking.Coverage.SplitTree import Agda.TypeChecking.Monad.Base -compileClauses :: Maybe (QName, Type) -> [Clause] -> TCM (Maybe SplitTree, CompiledClauses) +compileClauses :: Maybe (QName, Type) -> [Clause] -> TCM (Maybe SplitTree, Bool, CompiledClauses) diff --git a/src/full/Agda/TypeChecking/CompiledClause/Match.hs b/src/full/Agda/TypeChecking/CompiledClause/Match.hs --- a/src/full/Agda/TypeChecking/CompiledClause/Match.hs +++ b/src/full/Agda/TypeChecking/CompiledClause/Match.hs @@ -1,27 +1,19 @@ -{-# LANGUAGE CPP #-} module Agda.TypeChecking.CompiledClause.Match where -import Control.Monad.Reader (asks) - -import qualified Data.List as List import qualified Data.Map as Map -import qualified Data.Set as Set import Agda.Syntax.Internal import Agda.Syntax.Common import Agda.TypeChecking.CompiledClause -import Agda.TypeChecking.Monad -import Agda.TypeChecking.Monad.Builtin (getBuiltinName', builtinIZero, builtinIOne) -import Agda.TypeChecking.Pretty +import Agda.TypeChecking.Monad hiding (constructorForm) import Agda.TypeChecking.Reduce import Agda.TypeChecking.Reduce.Monad as RedM import Agda.TypeChecking.Substitute import Agda.Utils.Maybe -#include "undefined.h" import Agda.Utils.Impossible matchCompiled :: CompiledClauses -> MaybeReducedArgs -> ReduceM (Reduced (Blocked Args) Term) diff --git a/src/full/Agda/TypeChecking/Constraints.hs b/src/full/Agda/TypeChecking/Constraints.hs --- a/src/full/Agda/TypeChecking/Constraints.hs +++ b/src/full/Agda/TypeChecking/Constraints.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE NondecreasingIndentation #-} module Agda.TypeChecking.Constraints where @@ -6,7 +5,6 @@ import Prelude hiding (null) import Control.Monad -import Control.Monad.Reader import qualified Data.List as List import qualified Data.Set as Set @@ -14,7 +12,6 @@ import Agda.Syntax.Internal import Agda.TypeChecking.Monad -import Agda.TypeChecking.Monad.Caching import Agda.TypeChecking.InstanceArguments import Agda.TypeChecking.Pretty import Agda.TypeChecking.Reduce @@ -36,64 +33,100 @@ import Agda.Utils.Monad import Agda.Utils.Null import Agda.Utils.Pretty (prettyShow) -import Agda.Utils.Lens -#include "undefined.h" import Agda.Utils.Impossible --- | Catches pattern violation errors and adds a constraint. --- -catchConstraint :: Constraint -> TCM () -> TCM () -catchConstraint c v = liftTCM $ - catchError_ v $ \err -> - case err of - -- Not putting s (which should really be the what's already there) makes things go - -- a lot slower (+20% total time on standard library). How is that possible?? - -- The problem is most likely that there are internal catchErrors which forgets the - -- state. catchError should preserve the state on pattern violations. - PatternErr{} -> addConstraint c - _ -> throwError err +instance MonadConstraint TCM where + catchPatternErr = catchPatternErrTCM + addConstraint = addConstraintTCM + addAwakeConstraint = addAwakeConstraint' + solveConstraint = solveConstraintTCM + solveSomeAwakeConstraints = solveSomeAwakeConstraintsTCM + wakeConstraints = wakeConstraintsTCM + stealConstraints = stealConstraintsTCM + modifyAwakeConstraints = modifyTC . mapAwakeConstraints + modifySleepingConstraints = modifyTC . mapSleepingConstraints -addConstraint :: Constraint -> TCM () -addConstraint c = do - pids <- asksTC envActiveProblems - reportSDoc "tc.constr.add" 20 $ hsep - [ "adding constraint" - , text (show $ Set.toList pids) - , prettyTCM c ] - -- Need to reduce to reveal possibly blocking metas - c <- reduce =<< instantiateFull c - cs <- simpl c - if ([c] /= cs) - then do - reportSDoc "tc.constr.add" 20 $ " simplified:" <+> prettyList (map prettyTCM cs) - mapM_ solveConstraint_ cs - else mapM_ addConstraint' cs - -- the added constraint can cause instance constraints to be solved (but only - -- the constraints which aren’t blocked on an uninstantiated meta) - unless (isInstanceConstraint c) $ - wakeConstraints' (isWakeableInstanceConstraint . clValue . theConstraint) - where - isWakeableInstanceConstraint :: Constraint -> TCM Bool - isWakeableInstanceConstraint (FindInstance _ b _) = caseMaybe b (return True) (\m -> isInstantiatedMeta m) - isWakeableInstanceConstraint _ = return False +catchPatternErrTCM :: TCM a -> TCM a -> TCM a +catchPatternErrTCM handle v = + catchError_ v $ \err -> + case err of + -- Not putting s (which should really be the what's already there) makes things go + -- a lot slower (+20% total time on standard library). How is that possible?? + -- The problem is most likely that there are internal catchErrors which forgets the + -- state. catchError should preserve the state on pattern violations. + PatternErr{} -> handle + _ -> throwError err - isLvl LevelCmp{} = True - isLvl _ = False +addConstraintTCM :: Constraint -> TCM () +addConstraintTCM c = do + pids <- asksTC envActiveProblems + reportSDoc "tc.constr.add" 20 $ hsep + [ "adding constraint" + , text (show $ Set.toList pids) + , prettyTCM c ] + -- Need to reduce to reveal possibly blocking metas + c <- reduce =<< instantiateFull c + caseMaybeM (simpl c) {-no-} (addConstraint' c) $ {-yes-} \ cs -> do + reportSDoc "tc.constr.add" 20 $ " simplified:" <+> prettyList (map prettyTCM cs) + mapM_ solveConstraint_ cs + -- The added constraint can cause instance constraints to be solved, + -- but only the constraints which aren’t blocked on an uninstantiated meta. + unless (isInstanceConstraint c) $ + wakeConstraints' (isWakeableInstanceConstraint . clValue . theConstraint) + where + isWakeableInstanceConstraint :: Constraint -> TCM Bool + isWakeableInstanceConstraint = \case + FindInstance _ b _ -> maybe (return True) isInstantiatedMeta b + _ -> return False - -- Try to simplify a level constraint - simpl :: Constraint -> TCM [Constraint] - simpl c = if not $ isLvl c then return [c] else do - cs <- map theConstraint <$> getAllConstraints - lvls <- instantiateFull $ List.filter (isLvl . clValue) cs - when (not $ null lvls) $ do - reportSDoc "tc.constr.lvl" 40 $ "simplifying level constraint" <+> prettyTCM c - $$ nest 2 (hang "using" 2 (prettyTCM lvls)) - return $ simplifyLevelConstraint c $ map clValue lvls + isLvl LevelCmp{} = True + isLvl _ = False + -- Try to simplify a level constraint + simpl :: Constraint -> TCM (Maybe [Constraint]) + simpl c + | isLvl c = do + -- Get all level constraints. + lvlcs <- instantiateFull =<< do + List.filter (isLvl . clValue) . map theConstraint <$> getAllConstraints + unless (null lvlcs) $ do + reportSDoc "tc.constr.lvl" 40 $ vcat + [ "simplifying level constraint" <+> prettyTCM c + , nest 2 $ hang "using" 2 $ prettyTCM lvlcs + ] + -- Try to simplify @c@ using the other constraints. + return $ simplifyLevelConstraint c $ map clValue lvlcs + | otherwise = return Nothing + +wakeConstraintsTCM :: (ProblemConstraint-> TCM Bool) -> TCM () +wakeConstraintsTCM wake = do + c <- useR stSleepingConstraints + (wakeup, sleepin) <- partitionM wake c + reportSLn "tc.constr.wake" 50 $ + "waking up " ++ show (List.map (Set.toList . constraintProblems) wakeup) ++ "\n" ++ + " still sleeping: " ++ show (List.map (Set.toList . constraintProblems) sleepin) + modifySleepingConstraints $ const sleepin + modifyAwakeConstraints (++ wakeup) + +-- | Add all constraints belonging to the given problem to the current problem(s). +stealConstraintsTCM :: ProblemId -> TCM () +stealConstraintsTCM pid = do + current <- asksTC envActiveProblems + reportSLn "tc.constr.steal" 50 $ "problem " ++ show (Set.toList current) ++ " is stealing problem " ++ show pid ++ "'s constraints!" + -- Add current to any constraint in pid. + let rename pc@(PConstr pids c) | Set.member pid pids = PConstr (Set.union current pids) c + | otherwise = pc + -- We should never steal from an active problem. + whenM (Set.member pid <$> asksTC envActiveProblems) __IMPOSSIBLE__ + modifyAwakeConstraints $ List.map rename + modifySleepingConstraints $ List.map rename + -- | Don't allow the argument to produce any blocking constraints. -noConstraints :: TCM a -> TCM a -noConstraints problem = liftTCM $ do +noConstraints + :: (MonadConstraint m, MonadWarning m, MonadError TCErr m, MonadFresh ProblemId m) + => m a -> m a +noConstraints problem = do (pid, x) <- newProblem problem cs <- getConstraintsForProblem pid unless (null cs) $ do @@ -102,7 +135,9 @@ return x -- | Create a fresh problem for the given action. -newProblem :: TCM a -> TCM (ProblemId, a) +newProblem + :: (MonadFresh ProblemId m, MonadConstraint m) + => m a -> m (ProblemId, a) newProblem action = do pid <- fresh -- Don't get distracted by other constraints while working on the problem @@ -111,7 +146,9 @@ solveAwakeConstraints return (pid, x) -newProblem_ :: TCM () -> TCM ProblemId +newProblem_ + :: (MonadFresh ProblemId m, MonadConstraint m) + => m a -> m ProblemId newProblem_ action = fst <$> newProblem action ifNoConstraints :: TCM a -> (a -> TCM b) -> (ProblemId -> a -> TCM b) -> TCM b @@ -137,10 +174,10 @@ handler -- | Wake constraints matching the given predicate (and aren't instance --- constraints if 'isConsideringInstance'). +-- constraints if 'shouldPostponeInstanceSearch'). wakeConstraints' :: (ProblemConstraint -> TCM Bool) -> TCM () wakeConstraints' p = do - skipInstance <- isConsideringInstance + skipInstance <- shouldPostponeInstanceSearch wakeConstraints (\ c -> (&&) (not $ skipInstance && isInstanceConstraint (clValue $ theConstraint c)) <$> p c) -- | Wake up the constraints depending on the given meta. @@ -155,16 +192,16 @@ wakeConstraints' (return . const True) solveAwakeConstraints -solveAwakeConstraints :: TCM () +solveAwakeConstraints :: (MonadConstraint m) => m () solveAwakeConstraints = solveAwakeConstraints' False -solveAwakeConstraints' :: Bool -> TCM () +solveAwakeConstraints' :: (MonadConstraint m) => Bool -> m () solveAwakeConstraints' = solveSomeAwakeConstraints (const True) -- | Solve awake constraints matching the predicate. If the second argument is -- True solve constraints even if already 'isSolvingConstraints'. -solveSomeAwakeConstraints :: (ProblemConstraint -> Bool) -> Bool -> TCM () -solveSomeAwakeConstraints solveThis force = do +solveSomeAwakeConstraintsTCM :: (ProblemConstraint -> Bool) -> Bool -> TCM () +solveSomeAwakeConstraintsTCM solveThis force = do verboseS "profile.constraints" 10 $ liftTCM $ tickMax "max-open-constraints" . List.genericLength =<< getAllConstraints whenM ((force ||) . not <$> isSolvingConstraints) $ nowSolvingConstraints $ do -- solveSizeConstraints -- Andreas, 2012-09-27 attacks size constrs too early @@ -180,8 +217,8 @@ withConstraint solveConstraint c solve -solveConstraint :: Constraint -> TCM () -solveConstraint c = do +solveConstraintTCM :: Constraint -> TCM () +solveConstraintTCM c = do verboseS "profile.constraints" 10 $ liftTCM $ tick "attempted-constraints" verboseBracket "tc.constr.solve" 20 "solving constraint" $ do pids <- asksTC envActiveProblems @@ -189,10 +226,9 @@ solveConstraint_ c solveConstraint_ :: Constraint -> TCM () -solveConstraint_ (ValueCmp cmp a u v) = compareTerm cmp a u v +solveConstraint_ (ValueCmp cmp a u v) = compareAs cmp a u v solveConstraint_ (ValueCmpOnFace cmp p a u v) = compareTermOnFace cmp p a u v solveConstraint_ (ElimCmp cmp fs a e u v) = compareElims cmp fs a e u v -solveConstraint_ (TypeCmp cmp a b) = compareType cmp a b solveConstraint_ (TelCmp a b cmp tela telb) = compareTel a b cmp tela telb solveConstraint_ (SortCmp cmp s1 s2) = compareSort cmp s1 s2 solveConstraint_ (LevelCmp cmp a b) = compareLevel cmp a b @@ -208,7 +244,7 @@ solveConstraint_ (CheckSizeLtSat t) = checkSizeLtSat t solveConstraint_ (UnquoteTactic _ tac hole goal) = unquoteTactic tac hole goal solveConstraint_ (UnBlock m) = - ifM (isFrozen m) (addConstraint $ UnBlock m) $ do + ifM (isFrozen m `or2M` (not <$> asksTC envAssignMetas)) (addConstraint $ UnBlock m) $ do inst <- mvInstantiation <$> lookupMeta m reportSDoc "tc.constr.unblock" 15 $ text ("unblocking a metavar yields the constraint: " ++ show inst) case inst of @@ -243,6 +279,7 @@ checkFunDef d i q cs solveConstraint_ (HasBiggerSort a) = hasBiggerSort a solveConstraint_ (HasPTSRule a b) = hasPTSRule a b +solveConstraint_ (CheckMetaInst m) = checkMetaInst m checkTypeCheckingProblem :: TypeCheckingProblem -> TCM Term checkTypeCheckingProblem p = case p of diff --git a/src/full/Agda/TypeChecking/Constraints.hs-boot b/src/full/Agda/TypeChecking/Constraints.hs-boot --- a/src/full/Agda/TypeChecking/Constraints.hs-boot +++ b/src/full/Agda/TypeChecking/Constraints.hs-boot @@ -1,13 +1,16 @@ module Agda.TypeChecking.Constraints where import Agda.TypeChecking.Monad.Base +import Agda.TypeChecking.Monad.Constraints (MonadConstraint) +import Agda.TypeChecking.Warnings (MonadWarning) -addConstraint :: Constraint -> TCM () -catchConstraint :: Constraint -> TCM () -> TCM () -solveConstraint :: Constraint -> TCM () -solveAwakeConstraints' :: Bool -> TCM () -solveSomeAwakeConstraints :: (ProblemConstraint -> Bool) -> Bool -> TCM () -noConstraints :: TCM a -> TCM a +import Agda.Utils.Except (MonadError) + +instance MonadConstraint TCM where + +solveAwakeConstraints' :: MonadConstraint m => Bool -> m () +noConstraints :: (MonadConstraint m, MonadWarning m, MonadError TCErr m, MonadFresh ProblemId m) + => m a -> m a ifNoConstraints_ :: TCM () -> TCM a -> (ProblemId -> TCM a) -> TCM a ifNoConstraints :: TCM a -> (a -> TCM b) -> (ProblemId -> a -> TCM b) -> TCM b guardConstraint :: Constraint -> TCM () -> TCM () diff --git a/src/full/Agda/TypeChecking/Conversion.hs b/src/full/Agda/TypeChecking/Conversion.hs --- a/src/full/Agda/TypeChecking/Conversion.hs +++ b/src/full/Agda/TypeChecking/Conversion.hs @@ -1,1789 +1,2027 @@ -{-# LANGUAGE CPP #-} -{-# LANGUAGE NondecreasingIndentation #-} - -module Agda.TypeChecking.Conversion where - -import Control.Monad -import Control.Monad.Reader -import Control.Monad.State - -import qualified Data.List as List -import qualified Data.Map as Map -import qualified Data.Set as Set -import qualified Data.IntSet as IntSet - -import Agda.Syntax.Abstract.Views (isSet) -import Agda.Syntax.Common -import Agda.Syntax.Internal -import Agda.Syntax.Translation.InternalToAbstract (reify) - -import Agda.TypeChecking.Monad -import Agda.TypeChecking.Monad.Builtin -import Agda.TypeChecking.CompiledClause (CompiledClauses'(Fail)) -import Agda.TypeChecking.MetaVars -import Agda.TypeChecking.MetaVars.Occurs (killArgs,PruneResult(..),rigidVarsNotContainedIn) -import Agda.TypeChecking.Names -import Agda.TypeChecking.Reduce -import Agda.TypeChecking.Substitute -import qualified Agda.TypeChecking.SyntacticEquality as SynEq -import Agda.TypeChecking.Telescope -import Agda.TypeChecking.Constraints -import {-# SOURCE #-} Agda.TypeChecking.CheckInternal (infer) -import Agda.TypeChecking.Errors -import Agda.TypeChecking.Forcing (isForced, nextIsForced) -import Agda.TypeChecking.Free -import Agda.TypeChecking.Datatypes (getConType, getFullyAppliedConType) -import Agda.TypeChecking.Records -import Agda.TypeChecking.Pretty -import Agda.TypeChecking.Injectivity -import Agda.TypeChecking.Polarity -import Agda.TypeChecking.SizedTypes -import Agda.TypeChecking.Level -import Agda.TypeChecking.Implicit (implicitArgs) -import Agda.TypeChecking.Irrelevance -import Agda.TypeChecking.ProjectionLike (elimView) -import Agda.TypeChecking.Primitive -import Agda.Interaction.Options - -import Agda.Utils.Except ( MonadError(catchError, throwError) ) -import Agda.Utils.Functor -import Agda.Utils.Monad -import Agda.Utils.Maybe -import Agda.Utils.Size -import Agda.Utils.Tuple -import Agda.Utils.Lens - -#include "undefined.h" -import Agda.Utils.Impossible - --- | Try whether a computation runs without errors or new constraints --- (may create new metas, though). --- Restores state upon failure. -tryConversion :: TCM () -> TCM Bool -tryConversion = isJust <.> tryConversion' - --- | Try whether a computation runs without errors or new constraints --- (may create new metas, though). --- Return 'Just' the result upon success. --- Return 'Nothing' and restore state upon failure. -tryConversion' :: TCM a -> TCM (Maybe a) -tryConversion' m = tryMaybe $ noConstraints m - --- | Check if to lists of arguments are the same (and all variables). --- Precondition: the lists have the same length. -sameVars :: Elims -> Elims -> Bool -sameVars xs ys = and $ zipWith same xs ys - where - same (Apply (Arg _ (Var n []))) (Apply (Arg _ (Var m []))) = n == m - same _ _ = False - --- | @intersectVars us vs@ checks whether all relevant elements in @us@ and @vs@ --- are variables, and if yes, returns a prune list which says @True@ for --- arguments which are different and can be pruned. -intersectVars :: Elims -> Elims -> Maybe [Bool] -intersectVars = zipWithM areVars where - -- ignore irrelevant args - areVars (Apply u) v | isIrrelevant u = Just False -- do not prune - areVars (Apply (Arg _ (Var n []))) (Apply (Arg _ (Var m []))) = Just $ n /= m -- prune different vars - areVars _ _ = Nothing - -equalTerm :: Type -> Term -> Term -> TCM () -equalTerm = compareTerm CmpEq - -equalAtom :: Type -> Term -> Term -> TCM () -equalAtom = compareAtom CmpEq - -equalType :: Type -> Type -> TCM () -equalType = compareType CmpEq - -{- Comparing in irrelevant context always succeeds. - - However, we might want to dig for solutions of irrelevant metas. - - To this end, we can just ignore errors during conversion checking. - -} - --- convError :: MonadTCM tcm => TypeError -> tcm a --- | Ignore errors in irrelevant context. -convError :: TypeError -> TCM () -convError err = ifM ((==) Irrelevant <$> asksTC envRelevance) (return ()) $ typeError err - --- | Type directed equality on values. --- -compareTerm :: Comparison -> Type -> Term -> Term -> TCM () - -- If one term is a meta, try to instantiate right away. This avoids unnecessary unfolding. - -- Andreas, 2012-02-14: This is UNSOUND for subtyping! -compareTerm cmp a u v = do - reportSDoc "tc.conv.term" 10 $ sep - [ "compareTerm" - , nest 2 $ prettyTCM u <+> prettyTCM cmp <+> prettyTCM v - , nest 2 $ ":" <+> prettyTCM a - ] - -- Check syntactic equality. This actually saves us quite a bit of work. - ((u, v), equal) <- SynEq.checkSyntacticEquality u v - -- OLD CODE, traverses the *full* terms u v at each step, even if they - -- are different somewhere. Leads to infeasibility in issue 854. - -- (u, v) <- instantiateFull (u, v) - -- let equal = u == v - if equal then verboseS "profile.sharing" 20 $ tick "equal terms" else do - verboseS "profile.sharing" 20 $ tick "unequal terms" - reportSDoc "tc.conv.term" 15 $ sep - [ "compareTerm (not syntactically equal)" - , nest 2 $ prettyTCM u <+> prettyTCM cmp <+> prettyTCM v - , nest 2 $ ":" <+> prettyTCM a - ] - -- If we are at type Size, we cannot short-cut comparison - -- against metas by assignment. - -- Andreas, 2014-04-12: this looks incomplete. - -- It seems to assume we are never comparing - -- at function types into Size. - let fallback = compareTerm' cmp a u v - unlessSubtyping cont = - if cmp == CmpEq then cont else do - -- Andreas, 2014-04-12 do not short cut if type is blocked. - ifBlockedType a (\ _ _ -> fallback) {-else-} $ \ _ a -> do - -- do not short circuit size comparison! - caseMaybeM (isSizeType a) cont (\ _ -> fallback) - - dir = fromCmp cmp - rid = flipCmp dir -- The reverse direction. Bad name, I know. - case (u, v) of - (MetaV x us, MetaV y vs) - | x /= y -> unlessSubtyping $ solve1 `orelse` solve2 `orelse` compareTerm' cmp a u v - | otherwise -> fallback - where - (solve1, solve2) | x > y = (assign dir x us v, assign rid y vs u) - | otherwise = (assign rid y vs u, assign dir x us v) - (MetaV x us, _) -> unlessSubtyping $ assign dir x us v `orelse` fallback - (_, MetaV y vs) -> unlessSubtyping $ assign rid y vs u `orelse` fallback - _ -> fallback - where - assign dir x es v = do - -- Andreas, 2013-10-19 can only solve if no projections - reportSDoc "tc.conv.term.shortcut" 20 $ sep - [ "attempting shortcut" - , nest 2 $ prettyTCM (MetaV x es) <+> ":=" <+> prettyTCM v - ] - ifM (isInstantiatedMeta x) patternViolation {-else-} $ do - assignE dir x es v $ compareTermDir dir a - reportSDoc "tc.conv.term.shortcut" 50 $ - "shortcut successful" $$ nest 2 ("result:" <+> (pretty =<< instantiate (MetaV x es))) - -- Should be ok with catchError_ but catchError is much safer since we don't - -- rethrow errors. - orelse m h = catchError m (\_ -> h) - --- | Try to assign meta. If meta is projected, try to eta-expand --- and run conversion check again. -assignE :: CompareDirection -> MetaId -> Elims -> Term -> (Term -> Term -> TCM ()) -> TCM () -assignE dir x es v comp = assignWrapper dir x es v $ do - case allApplyElims es of - Just vs -> assignV dir x vs v - Nothing -> do - reportSDoc "tc.conv.assign" 30 $ sep - [ "assigning to projected meta " - , prettyTCM x <+> sep (map prettyTCM es) <+> text (":" ++ show dir) <+> prettyTCM v - ] - etaExpandMeta [Records] x - res <- isInstantiatedMeta' x - case res of - Just u -> do - reportSDoc "tc.conv.assign" 30 $ sep - [ "seems like eta expansion instantiated meta " - , prettyTCM x <+> text (":" ++ show dir) <+> prettyTCM u - ] - let w = u `applyE` es - comp w v - Nothing -> do - reportSLn "tc.conv.assign" 30 "eta expansion did not instantiate meta" - patternViolation -- nothing happened, give up - -compareTermDir :: CompareDirection -> Type -> Term -> Term -> TCM () -compareTermDir dir a = dirToCmp (`compareTerm'` a) dir - -compareTerm' :: Comparison -> Type -> Term -> Term -> TCM () -compareTerm' cmp a m n = - verboseBracket "tc.conv.term" 20 "compareTerm" $ do - a' <- reduce a - catchConstraint (ValueCmp cmp a' m n) $ do - reportSDoc "tc.conv.term" 30 $ fsep - [ "compareTerm", prettyTCM m, prettyTCM cmp, prettyTCM n, ":", prettyTCM a' ] - propIrr <- isPropEnabled - isSize <- isJust <$> isSizeType a' - s <- reduce $ getSort a' - mlvl <- tryMaybe primLevel - reportSDoc "tc.conv.level" 60 $ nest 2 $ sep - [ "a' =" <+> pretty a' - , "mlvl =" <+> pretty mlvl - , text $ "(Just (unEl a') == mlvl) = " ++ show (Just (unEl a') == mlvl) - ] - case s of - Prop{} | propIrr -> compareIrrelevant a' m n - _ | isSize -> compareSizes cmp m n - _ -> case unEl a' of - a | Just a == mlvl -> do - a <- levelView m - b <- levelView n - equalLevel a b - a@Pi{} -> equalFun s a m n - Lam _ _ -> __IMPOSSIBLE__ - Def r es -> do - isrec <- isEtaRecord r - if isrec - then do - sig <- getSignature - let ps = fromMaybe __IMPOSSIBLE__ $ allApplyElims es - -- Andreas, 2010-10-11: allowing neutrals to be blocked things does not seem - -- to change Agda's behavior - -- isNeutral Blocked{} = False - isNeutral (NotBlocked _ Con{}) = return False - -- Andreas, 2013-09-18 / 2015-06-29: a Def by copatterns is - -- not neutral if it is blocked (there can be missing projections - -- to trigger a reduction. - isNeutral (NotBlocked r (Def q _)) = do -- Andreas, 2014-12-06 optimize this using r !! - not <$> usesCopatterns q -- a def by copattern can reduce if projected - isNeutral _ = return True - isMeta (NotBlocked _ MetaV{}) = True - isMeta _ = False - - reportSDoc "tc.conv.term" 30 $ prettyTCM a <+> "is eta record type" - m <- reduceB m - mNeutral <- isNeutral m - n <- reduceB n - nNeutral <- isNeutral n - case (m, n) of - _ | isMeta m || isMeta n -> - compareAtom cmp a' (ignoreBlocking m) (ignoreBlocking n) - - _ | mNeutral && nNeutral -> do - -- Andreas 2011-03-23: (fixing issue 396) - -- if we are dealing with a singleton record, - -- we can succeed immediately - isSing <- isSingletonRecordModuloRelevance r ps - case isSing of - Right True -> return () - -- do not eta-expand if comparing two neutrals - _ -> compareAtom cmp a' (ignoreBlocking m) (ignoreBlocking n) - _ -> do - (tel, m') <- etaExpandRecord r ps $ ignoreBlocking m - (_ , n') <- etaExpandRecord r ps $ ignoreBlocking n - -- No subtyping on record terms - c <- getRecordConstructor r - -- Record constructors are covariant (see test/succeed/CovariantConstructors). - compareArgs (repeat $ polFromCmp cmp) [] (telePi_ tel __DUMMY_TYPE__) (Con c ConOSystem []) m' n' - - else (do pathview <- pathView a' - equalPath pathview a' m n) - _ -> compareAtom cmp a' m n - where - -- equality at function type (accounts for eta) - equalFun :: Sort -> Term -> Term -> Term -> TCM () - equalFun s a@(Pi dom b) m n | domFinite dom = do - mp <- fmap getPrimName <$> getBuiltin' builtinIsOne - case unEl $ unDom dom of - Def q [Apply phi] - | Just q == mp -> compareTermOnFace cmp (unArg phi) (El s (Pi (dom {domFinite = False}) b)) m n - _ -> equalFun s (Pi (dom{domFinite = False}) b) m n - equalFun _ (Pi dom@Dom{domInfo = info} b) m n | not $ domFinite dom = do - name <- freshName_ $ suggest (absName b) ("x" :: String) - addContext (name, dom) $ compareTerm cmp (absBody b) m' n' - where - (m',n') = raise 1 (m,n) `apply` [Arg info $ var 0] - equalFun _ _ _ _ = __IMPOSSIBLE__ - - equalPath :: PathView -> Type -> Term -> Term -> TCM () - equalPath (PathType s _ l a x y) _ m n = do - name <- freshName_ ("i" :: String) - interval <- el primInterval - let (m',n') = raise 1 (m, n) `applyE` [IApply (raise 1 $ unArg x) (raise 1 $ unArg y) (var 0)] - addContext (name, defaultDom interval) $ compareTerm cmp (El (raise 1 s) $ (raise 1 $ unArg a) `apply` [argN $ var 0]) m' n' - equalPath OType{} a' m n = cmpDef a' m n - - cmpDef a'@(El s ty) m n = do - mI <- getBuiltinName' builtinInterval - mIsOne <- getBuiltinName' builtinIsOne - mGlue <- getPrimitiveName' builtinGlue - mSub <- getBuiltinName' builtinSub - case ty of - Def q es | Just q == mIsOne -> return () - Def q es | Just q == mGlue, Just args@(l:_:a:phi:_) <- allApplyElims es -> do - ty <- el' (pure $ unArg l) (pure $ unArg a) - unglue <- prim_unglue - let mkUnglue m = apply unglue $ map (setHiding Hidden) args ++ [argN m] - reportSDoc "conv.glue" 20 $ prettyTCM (ty,mkUnglue m,mkUnglue n) - compareTermOnFace cmp (unArg phi) ty m n - compareTerm cmp ty (mkUnglue m) (mkUnglue n) - Def q es | Just q == mSub, Just args@(l:a:_) <- allApplyElims es -> do - ty <- el' (pure $ unArg l) (pure $ unArg a) - out <- primSubOut - let mkOut m = apply out $ map (setHiding Hidden) args ++ [argN m] - compareTerm cmp ty (mkOut m) (mkOut n) - Def q [] | Just q == mI -> compareInterval cmp a' m n - _ -> compareAtom cmp a' m n - --- | @compareTel t1 t2 cmp tel1 tel1@ checks whether pointwise --- @tel1 \`cmp\` tel2@ and complains that @t2 \`cmp\` t1@ failed if --- not. -compareTel :: Type -> Type -> - Comparison -> Telescope -> Telescope -> TCM () -compareTel t1 t2 cmp tel1 tel2 = - verboseBracket "tc.conv.tel" 20 "compareTel" $ - catchConstraint (TelCmp t1 t2 cmp tel1 tel2) $ case (tel1, tel2) of - (EmptyTel, EmptyTel) -> return () - (EmptyTel, _) -> bad - (_, EmptyTel) -> bad - (ExtendTel dom1{-@(Dom i1 a1)-} tel1, ExtendTel dom2{-@(Dom i2 a2)-} tel2) -> do - compareDom cmp dom1 dom2 tel1 tel2 bad bad $ - compareTel t1 t2 cmp (absBody tel1) (absBody tel2) - where - -- Andreas, 2011-05-10 better report message about types - bad = typeError $ UnequalTypes cmp t2 t1 - -- switch t2 and t1 because of contravariance! - - - --- | Raise 'UnequalTerms' if there is no hope that by --- meta solving and subsequent eta-contraction these --- terms could become equal. --- Precondition: the terms are in reduced form --- (with no top-level pointer) and --- failed to be equal in the 'compareAtom' check. --- --- By eta-contraction, a lambda or a record constructor term --- can become anything. -etaInequal :: Comparison -> Type -> Term -> Term -> TCM () -etaInequal cmp t m n = do - let inequal = typeError $ UnequalTerms cmp m n t - dontKnow = do - reportSDoc "tc.conv.inequal" 20 $ hsep - [ "etaInequal: postponing " - , prettyTCM m - , " != " - , prettyTCM n - ] - patternViolation - -- if type is not blocked, then we would have tried eta already - flip (ifBlockedType t) (\ _ _ -> inequal) $ \ _ _ -> do - -- type is blocked - case (m, n) of - (Con{}, _) -> dontKnow - (_, Con{}) -> dontKnow - (Lam{}, _) -> dontKnow - (_, Lam{}) -> dontKnow - _ -> inequal - -compareAtomDir :: CompareDirection -> Type -> Term -> Term -> TCM () -compareAtomDir dir a = dirToCmp (`compareAtom` a) dir - --- | Compute the head type of an elimination. For projection-like functions --- this requires inferring the type of the principal argument. -computeElimHeadType :: QName -> Elims -> Elims -> TCM Type -computeElimHeadType f es es' = do - def <- getConstInfo f - -- To compute the type @a@ of a projection-like @f@, - -- we have to infer the type of its first argument. - if projectionArgs (theDef def) <= 0 then return $ defType def else do - -- Find an first argument to @f@. - let arg = case (es, es') of - (Apply arg : _, _) -> arg - (_, Apply arg : _) -> arg - _ -> __IMPOSSIBLE__ - -- Infer its type. - reportSDoc "tc.conv.infer" 30 $ - "inferring type of internal arg: " <+> prettyTCM arg - targ <- infer $ unArg arg - reportSDoc "tc.conv.infer" 30 $ - "inferred type: " <+> prettyTCM targ - -- getDefType wants the argument type reduced. - -- Andreas, 2016-02-09, Issue 1825: The type of arg might be - -- a meta-variable, e.g. in interactive development. - -- In this case, we postpone. - fromMaybeM patternViolation $ getDefType f =<< reduce targ - --- | Syntax directed equality on atomic values --- -compareAtom :: Comparison -> Type -> Term -> Term -> TCM () -compareAtom cmp t m n = - verboseBracket "tc.conv.atom" 20 "compareAtom" $ - -- if a PatternErr is thrown, rebuild constraint! - catchConstraint (ValueCmp cmp t m n) $ do - reportSDoc "tc.conv.atom" 50 $ - "compareAtom" <+> fsep [ prettyTCM m <+> prettyTCM cmp - , prettyTCM n - , ":" <+> prettyTCM t ] - -- Andreas: what happens if I cut out the eta expansion here? - -- Answer: Triggers issue 245, does not resolve 348 - (mb',nb') <- ifM (asksTC envCompareBlocked) ((notBlocked -*- notBlocked) <$> reduce (m,n)) $ do - mb' <- etaExpandBlocked =<< reduceB m - nb' <- etaExpandBlocked =<< reduceB n - return (mb', nb') - - -- constructorForm changes literal to constructors - -- only needed if the other side is not a literal - (mb'', nb'') <- case (ignoreBlocking mb', ignoreBlocking nb') of - (Lit _, Lit _) -> return (mb', nb') - _ -> (,) <$> traverse constructorForm mb' - <*> traverse constructorForm nb' - - mb <- traverse unLevel mb'' - nb <- traverse unLevel nb'' - - let m = ignoreBlocking mb - n = ignoreBlocking nb - - postpone = addConstraint $ ValueCmp cmp t m n - - checkSyntacticEquality = - ifNotM (optSyntacticEquality <$> pragmaOptions) postpone $ do - n <- normalise n -- is this what we want? - m <- normalise m - if m == n - then return () -- Check syntactic equality for blocked terms - else postpone - - dir = fromCmp cmp - rid = flipCmp dir -- The reverse direction. Bad name, I know. - - assign dir x es v = assignE dir x es v $ compareAtomDir dir t - - reportSDoc "tc.conv.atom" 30 $ - "compareAtom" <+> fsep [ prettyTCM mb <+> prettyTCM cmp - , prettyTCM nb - , ":" <+> prettyTCM t ] - reportSDoc "tc.conv.atom" 80 $ - "compareAtom" <+> fsep [ (text . show) mb <+> prettyTCM cmp - , (text . show) nb - , ":" <+> (text . show) t ] - case (mb, nb) of - -- equate two metas x and y. if y is the younger meta, - -- try first y := x and then x := y - (NotBlocked _ (MetaV x xArgs), NotBlocked _ (MetaV y yArgs)) - | x == y -> - case intersectVars xArgs yArgs of - -- all relevant arguments are variables - Just kills -> do - -- kills is a list with 'True' for each different var - killResult <- killArgs kills x - case killResult of - NothingToPrune -> return () - PrunedEverything -> return () - PrunedNothing -> postpone - PrunedSomething -> postpone - -- not all relevant arguments are variables - Nothing -> checkSyntacticEquality -- Check syntactic equality on meta-variables - -- (same as for blocked terms) - | otherwise -> do - [p1, p2] <- mapM getMetaPriority [x,y] - -- First try the one with the highest priority. If that doesn't - -- work, try the low priority one. - let (solve1, solve2) - | (p1, x) > (p2, y) = (l1, r2) - | otherwise = (r1, l2) - where l1 = assign dir x xArgs n - r1 = assign rid y yArgs m - -- Careful: the first attempt might prune the low - -- priority meta! (Issue #2978) - l2 = ifM (isInstantiatedMeta x) (compareTermDir dir t m n) l1 - r2 = ifM (isInstantiatedMeta y) (compareTermDir rid t n m) r1 - - try m h = m `catchError_` \err -> case err of - PatternErr{} -> h - _ -> throwError err - - try solve1 solve2 - - -- one side a meta, the other an unblocked term - (NotBlocked _ (MetaV x es), _) -> assign dir x es n - (_, NotBlocked _ (MetaV x es)) -> assign rid x es m - (Blocked{}, Blocked{}) -> checkSyntacticEquality - (Blocked{}, _) -> useInjectivity (fromCmp cmp) t m n -- The blocked term goes first - (_, Blocked{}) -> useInjectivity (flipCmp $ fromCmp cmp) t n m - _ -> do - -- -- Andreas, 2013-10-20 put projection-like function - -- -- into the spine, to make compareElims work. - -- -- 'False' means: leave (Def f []) unchanged even for - -- -- proj-like funs. - -- m <- elimView False m - -- n <- elimView False n - -- Andreas, 2015-07-01, actually, don't put them into the spine. - -- Polarity cannot be communicated properly if projection-like - -- functions are post-fix. - case (m, n) of - (Pi{}, Pi{}) -> equalFun m n - - (Sort s1, Sort s2) -> compareSort CmpEq s1 s2 - - (Lit l1, Lit l2) | l1 == l2 -> return () - (Var i es, Var i' es') | i == i' -> do - a <- typeOfBV i - -- Variables are invariant in their arguments - compareElims [] [] a (var i) es es' - - -- The case of definition application: - (Def f es, Def f' es') -> do - - -- 1. All absurd lambdas are equal. - unlessM (bothAbsurd f f') $ do - - -- 2. If the heads are unequal, the only chance is subtyping between SIZE and SIZELT. - if f /= f' then trySizeUniv cmp t m n f es f' es' else do - - -- 3. If the heads are equal: - -- 3a. If there are no arguments, we are done. - unless (null es && null es') $ do - - -- 3b. If some cubical magic kicks in, we are done. - unlessM (compareEtaPrims f es es') $ do - - -- 3c. Oh no, we actually have to work and compare the eliminations! - a <- computeElimHeadType f es es' - -- The polarity vector of projection-like functions - -- does not include the parameters. - pol <- getPolarity' cmp f - compareElims pol [] a (Def f []) es es' - - -- Due to eta-expansion, these constructors are fully applied. - (Con x ci xArgs, Con y _ yArgs) - | x == y -> do - -- Get the type of the constructor instantiated to the datatype parameters. - a' <- conType x t - forcedArgs <- getForcedArgs $ conName x - -- Constructors are covariant in their arguments - -- (see test/succeed/CovariantConstructors). - compareElims (repeat $ polFromCmp cmp) forcedArgs a' (Con x ci []) xArgs yArgs - _ -> etaInequal cmp t m n -- fixes issue 856 (unsound conversion error) - where - -- returns True in case we handled the comparison already. - compareEtaPrims :: QName -> Elims -> Elims -> TCM Bool - compareEtaPrims q es es' = do - munglue <- getPrimitiveName' builtin_unglue - msubout <- getPrimitiveName' builtinSubOut - case () of - _ | Just q == munglue -> compareUnglueApp q es es' - _ | Just q == msubout -> compareSubApp q es es' - _ -> return False - compareSubApp q es es' = do - let (as,bs) = splitAt 5 es; (as',bs') = splitAt 5 es' - case (allApplyElims as, allApplyElims as') of - (Just [a,bA,phi,u,x], Just [a',bA',phi',u',x']) -> do - tSub <- primSub - -- Andrea, 28-07-16: - -- comparing the types is most probably wasteful, - -- since b and b' should be neutral terms, but it's a - -- precondition for the compareAtom call to make - -- sense. - equalType (El Inf $ apply tSub $ [a] ++ map (setHiding NotHidden) [bA,phi,u]) - (El Inf $ apply tSub $ [a] ++ map (setHiding NotHidden) [bA',phi',u']) - compareAtom cmp (El Inf $ apply tSub $ [a] ++ map (setHiding NotHidden) [bA,phi,u]) - (unArg x) (unArg x') - compareElims [] [] (El (tmSort (unArg a)) (unArg bA)) (Def q as) bs bs' - return True - _ -> return False - compareUnglueApp q es es' = do - let (as,bs) = splitAt 7 es; (as',bs') = splitAt 7 es' - case (allApplyElims as, allApplyElims as') of - (Just [la,lb,bA,phi,bT,e,b], Just [la',lb',bA',phi',bT',e',b']) -> do - tGlue <- getPrimitiveTerm builtinGlue - -- Andrea, 28-07-16: - -- comparing the types is most probably wasteful, - -- since b and b' should be neutral terms, but it's a - -- precondition for the compareAtom call to make - -- sense. - -- equalType (El (tmSort (unArg lb)) $ apply tGlue $ [la,lb] ++ map (setHiding NotHidden) [bA,phi,bT,e]) - -- (El (tmSort (unArg lb')) $ apply tGlue $ [la',lb'] ++ map (setHiding NotHidden) [bA',phi',bT',e']) - compareAtom cmp (El (tmSort (unArg lb)) $ apply tGlue $ [la,lb] ++ map (setHiding NotHidden) [bA,phi,bT,e]) - (unArg b) (unArg b') - compareElims [] [] (El (tmSort (unArg la)) (unArg bA)) (Def q as) bs bs' - return True - _ -> return False - -- Andreas, 2013-05-15 due to new postponement strategy, type can now be blocked - conType c t = ifBlockedType t (\ _ _ -> patternViolation) $ \ _ t -> do - let impossible = do - reportSDoc "impossible" 10 $ - "expected data/record type, found " <+> prettyTCM t - reportSDoc "impossible" 70 $ nest 2 $ "raw =" <+> pretty t - -- __IMPOSSIBLE__ - -- Andreas, 2013-10-20: in case termination checking fails - -- we might get some unreduced types here. - -- In issue 921, this happens during the final attempt - -- to solve left-over constraints. - -- Thus, instead of crashing, just give up gracefully. - patternViolation - maybe impossible (return . snd) =<< getFullyAppliedConType c t - equalFun t1 t2 = case (t1, t2) of - (Pi dom1 b1, Pi dom2 b2) -> do - verboseBracket "tc.conv.fun" 15 "compare function types" $ do - reportSDoc "tc.conv.fun" 20 $ nest 2 $ vcat - [ "t1 =" <+> prettyTCM t1 - , "t2 =" <+> prettyTCM t2 ] - compareDom cmp dom2 dom1 b1 b2 errH errR $ - compareType cmp (absBody b1) (absBody b2) - where - errH = typeError $ UnequalHiding t1 t2 - errR = typeError $ UnequalRelevance cmp t1 t2 - _ -> __IMPOSSIBLE__ - --- | Check whether @a1 `cmp` a2@ and continue in context extended by @a1@. -compareDom :: Free c - => Comparison -- ^ @cmp@ The comparison direction - -> Dom Type -- ^ @a1@ The smaller domain. - -> Dom Type -- ^ @a2@ The other domain. - -> Abs b -- ^ @b1@ The smaller codomain. - -> Abs c -- ^ @b2@ The bigger codomain. - -> TCM () -- ^ Continuation if mismatch in 'Hiding'. - -> TCM () -- ^ Continuation if mismatch in 'Relevance'. - -> TCM () -- ^ Continuation if comparison is successful. - -> TCM () -compareDom cmp dom1@(Dom{domInfo = i1, unDom = a1}) dom2@(Dom{domInfo = i2, unDom = a2}) b1 b2 errH errR cont - | not (sameHiding dom1 dom2) = errH - | not $ compareRelevance cmp (getRelevance dom1) (getRelevance dom2) = errR - | otherwise = do - let r = max (getRelevance dom1) (getRelevance dom2) - -- take "most irrelevant" - dependent = (r /= Irrelevant) && isBinderUsed b2 - pid <- newProblem_ $ compareType cmp a1 a2 - dom <- if dependent - then (\ a -> dom1 {unDom = a}) <$> blockTypeOnProblem a1 pid - else return dom1 - -- We only need to require a1 == a2 if b2 is dependent - -- If it's non-dependent it doesn't matter what we add to the context. - name <- freshName_ $ suggest b1 b2 - addContext (name, dom) $ cont - stealConstraints pid - -- Andreas, 2013-05-15 Now, comparison of codomains is not - -- blocked any more by getting stuck on domains. - -- Only the domain type in context will be blocked. - -- But see issue #1258. - -compareRelevance :: Comparison -> Relevance -> Relevance -> Bool -compareRelevance CmpEq = (==) -compareRelevance CmpLeq = (<=) - --- | When comparing argument spines (in compareElims) where the first arguments --- don't match, we keep going, substituting the anti-unification of the two --- terms in the telescope. More precisely: --- --- @@ --- (u = v : A)[pid] w = antiUnify pid A u v us = vs : Δ[w/x] --- ------------------------------------------------------------- --- u us = v vs : (x : A) Δ --- @@ --- --- The simplest case of anti-unification is to return a fresh metavariable --- (created by blockTermOnProblem), but if there's shared structure between --- the two terms we can expose that. --- --- This is really a crutch that lets us get away with things that otherwise --- would require heterogenous conversion checking. See for instance issue --- #2384. -antiUnify :: ProblemId -> Type -> Term -> Term -> TCM Term -antiUnify pid a u v = do - ((u, v), eq) <- SynEq.checkSyntacticEquality u v - if eq then return u else do - (u, v) <- reduce (u, v) - case (u, v) of - (Pi ua ub, Pi va vb) -> do - wa0 <- antiUnifyType pid (unDom ua) (unDom va) - let wa = wa0 <$ ua - wb <- addContext wa $ antiUnifyType pid (unAbs ub) (unAbs vb) - return $ Pi wa (wb <$ ub) - (Lam i u, Lam _ v) -> - case unEl a of - Pi a b -> Lam i . (<$ u) <$> addContext a (antiUnify pid (unAbs b) (unAbs u) (unAbs v)) - _ -> fallback - (Var i us, Var j vs) | i == j -> maybeGiveUp $ do - a <- typeOfBV i - antiUnifyElims pid a (var i) us vs - -- Andreas, 2017-07-27: - -- It seems that nothing guarantees here that the constructors are fully - -- applied!? Thus, @a@ could be a function type and we need the robust - -- @getConType@ here. - -- (Note that @patternViolation@ swallows exceptions coming from @getConType@ - -- thus, we would not see clearly if we used @getFullyAppliedConType@ instead.) - (Con x ci us, Con y _ vs) | x == y -> maybeGiveUp $ do - a <- maybe patternViolation (return . snd) =<< getConType x a - antiUnifyElims pid a (Con x ci []) us vs - (Def f us, Def g vs) | f == g, length us == length vs -> maybeGiveUp $ do - a <- computeElimHeadType f us vs - antiUnifyElims pid a (Def f []) us vs - _ -> fallback - where - fallback = blockTermOnProblem a u pid - maybeGiveUp m = m `catchError_` \ err -> - case err of - PatternErr{} -> fallback - _ -> throwError err - -antiUnifyType :: ProblemId -> Type -> Type -> TCM Type -antiUnifyType pid (El s a) (El _ b) = El s <$> antiUnify pid (sort s) a b - -antiUnifyElims :: ProblemId -> Type -> Term -> Elims -> Elims -> TCM Term -antiUnifyElims pid a self [] [] = return self -antiUnifyElims pid a self (Proj o f : es1) (Proj _ g : es2) | f == g = do - res <- projectTyped self a o f - case res of - Just (_, self, a) -> antiUnifyElims pid a self es1 es2 - Nothing -> patternViolation -- can fail for projection like -antiUnifyElims pid a self (Apply u : es1) (Apply v : es2) = do - case unEl a of - Pi a b -> do - w <- antiUnify pid (unDom a) (unArg u) (unArg v) - antiUnifyElims pid (b `lazyAbsApp` w) (apply self [w <$ u]) es1 es2 - _ -> patternViolation -antiUnifyElims _ _ _ _ _ = patternViolation -- trigger maybeGiveUp in antiUnify - --- | @compareElims pols a v els1 els2@ performs type-directed equality on eliminator spines. --- @t@ is the type of the head @v@. -compareElims :: [Polarity] -> [IsForced] -> Type -> Term -> [Elim] -> [Elim] -> TCM () -compareElims pols0 fors0 a v els01 els02 = catchConstraint (ElimCmp pols0 fors0 a v els01 els02) $ do - let v1 = applyE v els01 - v2 = applyE v els02 - failure = typeError $ UnequalTerms CmpEq v1 v2 a - -- Andreas, 2013-03-15 since one of the spines is empty, @a@ - -- is the correct type here. - unless (null els01) $ do - reportSDoc "tc.conv.elim" 25 $ "compareElims" $$ do - nest 2 $ vcat - [ "a =" <+> prettyTCM a - , "pols0 (truncated to 10) =" <+> sep (map prettyTCM $ take 10 pols0) - , "fors0 (truncated to 10) =" <+> sep (map prettyTCM $ take 10 fors0) - , "v =" <+> prettyTCM v - , "els01 =" <+> prettyTCM els01 - , "els02 =" <+> prettyTCM els02 - ] - case (els01, els02) of - ([] , [] ) -> return () - ([] , Proj{}:_ ) -> failure -- not impossible, see issue 821 - (Proj{} : _, [] ) -> failure -- could be x.p =?= x for projection p - ([] , Apply{} : _) -> failure -- not impossible, see issue 878 - (Apply{} : _, [] ) -> failure - ([] , IApply{} : _) -> failure - (IApply{} : _, [] ) -> failure - (Apply{} : _, Proj{} : _) -> __IMPOSSIBLE__ <$ solveAwakeConstraints' True -- NB: popped up in issue 889 - (Proj{} : _, Apply{} : _) -> __IMPOSSIBLE__ <$ solveAwakeConstraints' True -- but should be impossible (but again in issue 1467) - (IApply{} : _, Proj{} : _) -> __IMPOSSIBLE__ <$ solveAwakeConstraints' True - (Proj{} : _, IApply{} : _) -> __IMPOSSIBLE__ <$ solveAwakeConstraints' True - (IApply{} : _, Apply{} : _) -> __IMPOSSIBLE__ <$ solveAwakeConstraints' True - (Apply{} : _, IApply{} : _) -> __IMPOSSIBLE__ <$ solveAwakeConstraints' True - (e@(IApply x1 y1 r1) : els1, IApply x2 y2 r2 : els2) -> do - reportSDoc "tc.conv.elim" 25 $ "compareElims IApply" - -- Andrea: copying stuff from the Apply case.. - let (pol, pols) = nextPolarity pols0 - ifBlockedType a (\ m t -> patternViolation) $ \ _ a -> do - va <- pathView a - reportSDoc "tc.conv.elim.iapply" 60 $ "compareElims IApply" $$ do - nest 2 $ "va =" <+> text (show (isPathType va)) - case va of - PathType s path l bA x y -> do - b <- elInf primInterval - compareWithPol pol (flip compareTerm b) - r1 r2 - -- TODO: compare (x1,x2) and (y1,y2) ? - let r = r1 -- TODO Andrea: do blocking - codom <- el' (pure . unArg $ l) ((pure . unArg $ bA) <@> pure r) - compareElims pols [] codom -- Path non-dependent (codom `lazyAbsApp` unArg arg) - (applyE v [e]) els1 els2 - -- We allow for functions (i : I) -> ... to also be heads of a IApply, - -- because @etaContract@ can produce such terms - OType t@(El _ Pi{}) -> compareElims pols0 fors0 t v (Apply (defaultArg r1) : els1) (Apply (defaultArg r2) : els2) - - OType{} -> patternViolation - - (Apply arg1 : els1, Apply arg2 : els2) -> - verboseBracket "tc.conv.elim" 20 "compare Apply" $ do - reportSDoc "tc.conv.elim" 10 $ nest 2 $ vcat - [ "a =" <+> prettyTCM a - , "v =" <+> prettyTCM v - , "arg1 =" <+> prettyTCM arg1 - , "arg2 =" <+> prettyTCM arg2 - ] - reportSDoc "tc.conv.elim" 50 $ nest 2 $ vcat - [ "raw:" - , "a =" <+> pretty a - , "v =" <+> pretty v - , "arg1 =" <+> pretty arg1 - , "arg2 =" <+> pretty arg2 - ] - let (pol, pols) = nextPolarity pols0 - (for, fors) = nextIsForced fors0 - ifBlockedType a (\ m t -> patternViolation) $ \ _ a -> do - reportSLn "tc.conv.elim" 90 $ "type is not blocked" - case unEl a of - (Pi (Dom{domInfo = info, unDom = b}) codom) -> do - reportSLn "tc.conv.elim" 90 $ "type is a function type" - mlvl <- tryMaybe primLevel - let freeInCoDom (Abs _ c) = 0 `freeInIgnoringSorts` c - freeInCoDom _ = False - dependent = (Just (unEl b) /= mlvl) && freeInCoDom codom - -- Level-polymorphism (x : Level) -> ... does not count as dependency here - -- NB: we could drop the free variable test and still be sound. - -- It is a trade-off between the administrative effort of - -- creating a blocking and traversing a term for free variables. - -- Apparently, it is believed that checking free vars is cheaper. - -- Andreas, 2013-05-15 - --- NEW, Andreas, 2013-05-15 - - -- compare arg1 and arg2 - pid <- newProblem_ $ applyModalityToContext info $ - if isForced for then - reportSLn "tc.conv.elim" 90 $ "argument is forced" - else if isIrrelevant info then do - reportSLn "tc.conv.elim" 90 $ "argument is irrelevant" - compareIrrelevant b (unArg arg1) (unArg arg2) - else do - reportSLn "tc.conv.elim" 90 $ "argument has polarity " ++ show pol - compareWithPol pol (flip compareTerm b) - (unArg arg1) (unArg arg2) - -- if comparison got stuck and function type is dependent, block arg - solved <- isProblemSolved pid - reportSLn "tc.conv.elim" 90 $ "solved = " ++ show solved - arg <- if dependent && not solved - then do - arg <- (arg1 $>) <$> antiUnify pid b (unArg arg1) (unArg arg2) - reportSDoc "tc.conv.elims" 30 $ hang "Anti-unification:" 2 (prettyTCM arg) - reportSDoc "tc.conv.elims" 70 $ nest 2 $ "raw:" <+> pretty arg - return arg - else return arg1 - -- continue, possibly with blocked instantiation - compareElims pols fors (codom `lazyAbsApp` unArg arg) (apply v [arg]) els1 els2 - -- any left over constraints of arg are associated to the comparison - reportSLn "tc.conv.elim" 90 $ "stealing constraints from problem " ++ show pid - stealConstraints pid - {- Stealing solves this issue: - - Does not create enough blocked tc-problems, - see test/fail/DontPrune. - (There are remaining problems which do not show up as yellow.) - Need to find a way to associate pid also to result of compareElims. - -} - a -> do - reportSDoc "impossible" 10 $ - "unexpected type when comparing apply eliminations " <+> prettyTCM a - reportSDoc "impossible" 50 $ "raw type:" <+> pretty a - patternViolation - -- Andreas, 2013-10-22 - -- in case of disabled reductions (due to failing termination check) - -- we might get stuck, so do not crash, but fail gently. - -- __IMPOSSIBLE__ - - -- case: f == f' are projections - (Proj o f : els1, Proj _ f' : els2) - | f /= f' -> typeError . GenericError . show =<< prettyTCM f <+> "/=" <+> prettyTCM f' - | otherwise -> ifBlockedType a (\ m t -> patternViolation) $ \ _ a -> do - res <- projectTyped v a o f -- fails only if f is proj.like but parameters cannot be retrieved - case res of - Just (_, u, t) -> do - -- Andreas, 2015-07-01: - -- The arguments following the principal argument of a projection - -- are invariant. (At least as long as we have no explicit polarity - -- annotations.) - compareElims [] [] t u els1 els2 - Nothing -> do - reportSDoc "tc.conv.elims" 30 $ sep - [ text $ "projection " ++ show f - , text "applied to value " <+> prettyTCM v - , text "of unexpected type " <+> prettyTCM a - ] - patternViolation - - --- | "Compare" two terms in irrelevant position. This always succeeds. --- However, we can dig for solutions of irrelevant metas in the --- terms we compare. --- (Certainly not the systematic solution, that'd be proof search...) -compareIrrelevant :: Type -> Term -> Term -> TCM () -{- 2012-04-02 DontCare no longer present -compareIrrelevant t (DontCare v) w = compareIrrelevant t v w -compareIrrelevant t v (DontCare w) = compareIrrelevant t v w --} -compareIrrelevant t v w = do - reportSDoc "tc.conv.irr" 20 $ vcat - [ "compareIrrelevant" - , nest 2 $ "v =" <+> prettyTCM v - , nest 2 $ "w =" <+> prettyTCM w - ] - reportSDoc "tc.conv.irr" 50 $ vcat - [ nest 2 $ "v =" <+> pretty v - , nest 2 $ "w =" <+> pretty w - ] - try v w $ try w v $ return () - where - try (MetaV x es) w fallback = do - mv <- lookupMeta x - let rel = getMetaRelevance mv - inst = case mvInstantiation mv of - InstV{} -> True - _ -> False - reportSDoc "tc.conv.irr" 20 $ vcat - [ nest 2 $ text $ "rel = " ++ show rel - , nest 2 $ "inst =" <+> pretty inst - ] - if not (isIrrelevant rel) || inst - then fallback - -- Andreas, 2016-08-08, issue #2131: - -- Mining for solutions for irrelevant metas is not definite. - -- Thus, in case of error, leave meta unsolved. - else (assignE DirEq x es w $ compareIrrelevant t) `catchError` \ _ -> fallback - -- the value of irrelevant or unused meta does not matter - try v w fallback = fallback - -compareWithPol :: Polarity -> (Comparison -> a -> a -> TCM ()) -> a -> a -> TCM () -compareWithPol Invariant cmp x y = cmp CmpEq x y -compareWithPol Covariant cmp x y = cmp CmpLeq x y -compareWithPol Contravariant cmp x y = cmp CmpLeq y x -compareWithPol Nonvariant cmp x y = return () - -polFromCmp :: Comparison -> Polarity -polFromCmp CmpLeq = Covariant -polFromCmp CmpEq = Invariant - --- | Type-directed equality on argument lists --- -compareArgs :: [Polarity] -> [IsForced] -> Type -> Term -> Args -> Args -> TCM () -compareArgs pol for a v args1 args2 = - compareElims pol for a v (map Apply args1) (map Apply args2) - ---------------------------------------------------------------------------- --- * Types ---------------------------------------------------------------------------- - --- | Equality on Types -compareType :: Comparison -> Type -> Type -> TCM () -compareType cmp ty1@(El s1 a1) ty2@(El s2 a2) = - verboseBracket "tc.conv.type" 20 "compareType" $ - catchConstraint (TypeCmp cmp ty1 ty2) $ do - reportSDoc "tc.conv.type" 50 $ vcat - [ "compareType" <+> sep [ prettyTCM ty1 <+> prettyTCM cmp - , prettyTCM ty2 ] - , hsep [ " sorts:", prettyTCM s1, " and ", prettyTCM s2 ] - ] --- Andreas, 2011-4-27 should not compare sorts, but currently this is needed --- for solving sort and level metas - compareSort CmpEq s1 s2 `catchError` \err -> case err of - TypeError _ e -> do - reportSDoc "tc.conv.type" 30 $ vcat - [ "sort comparison failed" - , nest 2 $ vcat - [ "s1 =" <+> prettyTCM s1 - , "s2 =" <+> prettyTCM s2 - ] - ] - -- This error will probably be more informative - compareTerm cmp (sort s1) a1 a2 - -- Throw the original error if the above doesn't - -- give an error (for instance, due to pending - -- constraints). - -- Or just ignore it... We run into this with irrelevant levels - -- which may show up in sort constraints, causing them to fail. - -- In any case it's not safe to ignore the error, for instance - -- a1 might be Set and a2 a meta of type Set, in which case we - -- really need the sort comparison to fail, instead of silently - -- instantiating the meta. - -- Andreas, 2013-10-31 Maybe the error went away - -- when we compared the types. So we try the sort comparison - -- again, this time not catching the error. (see Issue 930) - -- throwError err - compareSort CmpEq s1 s2 - _ -> throwError err - compareTerm cmp (sort s1) a1 a2 - return () - -leqType :: Type -> Type -> TCM () -leqType = compareType CmpLeq - --- | @coerce v a b@ coerces @v : a@ to type @b@, returning a @v' : b@ --- with maybe extra hidden applications or hidden abstractions. --- --- In principle, this function can host coercive subtyping, but --- currently it only tries to fix problems with hidden function types. --- --- Precondition: @a@ and @b@ are reduced. -coerce :: Comparison -> Term -> Type -> Type -> TCM Term -coerce cmp v t1 t2 = blockTerm t2 $ do - verboseS "tc.conv.coerce" 10 $ do - (a1,a2) <- reify (t1,t2) - let dbglvl = if isSet a1 && isSet a2 then 50 else 10 - reportSDoc "tc.conv.coerce" dbglvl $ - "coerce" <+> vcat - [ "term v =" <+> prettyTCM v - , "from type t1 =" <+> prettyTCM a1 - , "to type t2 =" <+> prettyTCM a2 - , "comparison =" <+> prettyTCM cmp - ] - reportSDoc "tc.conv.coerce" 70 $ - "coerce" <+> vcat - [ "term v =" <+> pretty v - , "from type t1 =" <+> pretty t1 - , "to type t2 =" <+> pretty t2 - , "comparison =" <+> pretty cmp - ] - -- v <$ do workOnTypes $ leqType t1 t2 - -- take off hidden/instance domains from t1 and t2 - TelV tel1 b1 <- telViewUpTo' (-1) notVisible t1 - TelV tel2 b2 <- telViewUpTo' (-1) notVisible t2 - let n = size tel1 - size tel2 - -- the crude solution would be - -- v' = λ {tel2} → v {tel1} - -- however, that may introduce unneccessary many function types - -- If n > 0 and b2 is not blocked, it is safe to - -- insert n many hidden args - if n <= 0 then fallback else do - ifBlockedType b2 (\ _ _ -> fallback) $ \ _ _ -> do - (args, t1') <- implicitArgs n notVisible t1 - let v' = v `apply` args - v' <$ coerceSize (compareType cmp) v' t1' t2 - where - fallback = v <$ coerceSize (compareType cmp) v t1 t2 - --- | Account for situations like @k : (Size< j) <= (Size< k + 1)@ --- --- Actually, the semantics is --- @(Size<= k) ∩ (Size< j) ⊆ rhs@ --- which gives a disjunctive constraint. Mmmh, looks like stuff --- TODO. --- --- For now, we do a cheap heuristics. --- --- Precondition: types are reduced. -coerceSize :: (Type -> Type -> TCM ()) -> Term -> Type -> Type -> TCM () -coerceSize leqType v t1 t2 = verboseBracket "tc.conv.size.coerce" 45 "coerceSize" $ - workOnTypes $ do - reportSDoc "tc.conv.size.coerce" 70 $ - "coerceSize" <+> vcat - [ "term v =" <+> pretty v - , "from type t1 =" <+> pretty t1 - , "to type t2 =" <+> pretty t2 - ] - let fallback = leqType t1 t2 - done = caseMaybeM (isSizeType t1) fallback $ \ _ -> return () - -- Andreas, 2015-07-22, Issue 1615: - -- If t1 is a meta and t2 a type like Size< v2, we need to make sure we do not miss - -- the constraint v < v2! - caseMaybeM (isSizeType t2) fallback $ \ b2 -> do - -- Andreas, 2017-01-20, issue #2329: - -- If v is not a size suitable for the solver, like a neutral term, - -- we can only rely on the type. - mv <- sizeMaxView v - if any (\case{ DOtherSize{} -> True; _ -> False }) mv then fallback else do - -- Andreas, 2015-02-11 do not instantiate metas here (triggers issue 1203). - unlessM (tryConversion $ dontAssignMetas $ leqType t1 t2) $ do - -- A (most probably weaker) alternative is to just check syn.eq. - -- ifM (snd <$> checkSyntacticEquality t1 t2) (return v) $ {- else -} do - reportSDoc "tc.conv.size.coerce" 20 $ "coercing to a size type" - case b2 of - -- @t2 = Size@. We are done! - BoundedNo -> done - -- @t2 = Size< v2@ - BoundedLt v2 -> do - sv2 <- sizeView v2 - case sv2 of - SizeInf -> done - OtherSize{} -> do - -- Andreas, 2014-06-16: - -- Issue 1203: For now, just treat v < v2 as suc v <= v2 - -- TODO: Need proper < comparison - vinc <- sizeSuc 1 v - compareSizes CmpLeq vinc v2 - done - -- @v2 = a2 + 1@: In this case, we can try @v <= a2@ - SizeSuc a2 -> do - compareSizes CmpLeq v a2 - done -- to pass Issue 1136 - ---------------------------------------------------------------------------- --- * Sorts and levels ---------------------------------------------------------------------------- - -compareLevel :: Comparison -> Level -> Level -> TCM () -compareLevel CmpLeq u v = leqLevel u v -compareLevel CmpEq u v = equalLevel u v - -compareSort :: Comparison -> Sort -> Sort -> TCM () -compareSort CmpEq = equalSort -compareSort CmpLeq = leqSort - --- | Check that the first sort is less or equal to the second. --- --- We can put @SizeUniv@ below @Inf@, but otherwise, it is --- unrelated to the other universes. --- -leqSort :: Sort -> Sort -> TCM () -leqSort s1 s2 = catchConstraint (SortCmp CmpLeq s1 s2) $ do - (s1,s2) <- reduce (s1,s2) - let postpone = addConstraint (SortCmp CmpLeq s1 s2) - no = typeError $ NotLeqSort s1 s2 - yes = return () - reportSDoc "tc.conv.sort" 30 $ - sep [ "leqSort" - , nest 2 $ fsep [ prettyTCM s1 <+> "=<" - , prettyTCM s2 ] - ] - propEnabled <- isPropEnabled - - let fvsRHS = IntSet.toList $ allFreeVars s2 - badRigid <- s1 `rigidVarsNotContainedIn` fvsRHS - - case (s1, s2) of - -- Andreas, 2018-09-03: crash on dummy sort - (DummyS s, _) -> impossibleSort s - (_, DummyS s) -> impossibleSort s - - -- The most basic rule: @Set l =< Set l'@ iff @l =< l'@ - (Type a , Type b ) -> leqLevel a b - - -- Likewise for @Prop@ - (Prop a , Prop b ) -> leqLevel a b - - -- @Prop l@ is below @Set l@ - (Prop a , Type b ) -> leqLevel a b - (Type a , Prop b ) -> no - - -- Setω is the top sort - (_ , Inf ) -> yes - (Inf , _ ) -> equalSort s1 s2 - - -- @SizeUniv@ and @Prop0@ are bottom sorts. - -- So is @Set0@ if @Prop@ is not enabled. - (_ , SizeUniv) -> equalSort s1 s2 - (_ , Prop (Max [])) -> equalSort s1 s2 - (_ , Type (Max [])) - | not propEnabled -> equalSort s1 s2 - - -- SizeUniv is unrelated to any @Set l@ or @Prop l@ - (SizeUniv, Type{} ) -> no - (SizeUniv, Prop{} ) -> no - - -- If the first sort rigidly depends on a variable and the second - -- sort does not mention this variable, the second sort must be Inf. - (_ , _ ) | badRigid -> equalSort s2 Inf - - -- This shouldn't be necessary - (UnivSort Inf , UnivSort Inf) -> yes - - -- PiSort, UnivSort and MetaS might reduce once we instantiate - -- more metas, so we postpone. - (PiSort{}, _ ) -> postpone - (_ , PiSort{}) -> postpone - (UnivSort{}, _ ) -> postpone - (_ , UnivSort{}) -> postpone - (MetaS{} , _ ) -> postpone - (_ , MetaS{} ) -> postpone - - -- DefS are postulated sorts, so they do not reduce. - (DefS d es , DefS d' es') | d == d' -> postpone - (DefS{} , _ ) -> no - (_ , DefS{}) -> no - - where - impossibleSort s = do - reportSLn "impossible" 10 $ unlines - [ "leqSort: found dummy sort with description:" - , s - ] - __IMPOSSIBLE__ - -leqLevel :: Level -> Level -> TCM () -leqLevel a b = liftTCM $ do - reportSDoc "tc.conv.nat" 30 $ - "compareLevel" <+> - sep [ prettyTCM a <+> "=<" - , prettyTCM b ] - -- Andreas, 2015-12-28 Issue 1757 - -- We normalize both sides to make the syntactic equality check (==) stronger. - -- See case for `same term` below. - a <- normalise a - b <- normalise b - leqView a b - where - -- Andreas, 2016-09-28 - -- If we have to postpone a constraint, then its simplified form! - leqView a@(Max as) b@(Max bs) = catchConstraint (LevelCmp CmpLeq a b) $ do - reportSDoc "tc.conv.nat" 30 $ - "compareLevelView" <+> - sep [ pretty a <+> "=<" - , pretty b ] - wrap $ case (as, bs) of - - -- same term - _ | as == bs -> ok - - -- 0 ≤ any - ([], _) -> ok - - -- as ≤ 0 - (as, []) -> sequence_ [ equalLevel' (Max [a]) (Max []) | a <- as ] - (as, [ClosedLevel 0]) -> sequence_ [ equalLevel' (Max [a]) (Max []) | a <- as ] - -- Andreas, 2016-09-28, @[ClosedLevel 0]@ is possible if we come from case - -- "reduce constants" where we run @subtr@ on both sides. - -- See test/Succeed/LevelMetaLeqZero.agda. - - -- as ≤ [b] - (as@(_:_:_), [b]) -> sequence_ [ leqView (Max [a]) (Max [b]) | a <- as ] - - -- reduce constants - (as, bs) | minN > 0 -> leqView (Max $ map (subtr minN) as) (Max $ map (subtr minN) bs) - where - ns = map constant as - ms = map constant bs - minN = minimum (ns ++ ms) - - -- remove subsumed - -- Andreas, 2014-04-07: This is ok if we do not go back to equalLevel - (as, bs) - | not $ null subsumed -> leqView (Max $ as List.\\ subsumed) (Max bs) - where - subsumed = [ a | a@(Plus m l) <- as, n <- findN l, m <= n ] - -- @findN a@ finds the unique(?) term @Plus n a@ in @bs@, if any. - -- Andreas, 2014-04-07 Why must there be a unique term? - findN a = case [ n | Plus n b <- bs, b == a ] of - [n] -> [n] - _ -> [] - - -- Andreas, 2012-10-02 raise error on unsolvable constraint - ([ClosedLevel n], [ClosedLevel m]) -> if n <= m then ok else notok - - -- closed ≤ bs - ([ClosedLevel n], bs) - | n <= maximum (map constant bs) -> ok - - -- as ≤ neutral - (as, bs) - | neutralB && maxA > maxB -> notok - | neutralB && any (\a -> neutral a && not (isInB a)) as -> notok - | neutralB && neutralA -> maybeok $ all (\a -> constant a <= findN a) as - where - maxA = maximum $ map constant as - maxB = maximum $ map constant bs - neutralA = all neutral as - neutralB = all neutral bs - isInB a = elem (unneutral a) $ map unneutral bs - findN a = case [ n | b@(Plus n _) <- bs, unneutral b == unneutral a ] of - [n] -> n - _ -> __IMPOSSIBLE__ - - -- Andreas, 2016-09-28: This simplification loses the solution lzero. - -- Thus, it is invalid. - -- See test/Succeed/LevelMetaLeqNeutralLevel.agda. - -- -- [a] ≤ [neutral] - -- ([a@(Plus n _)], [b@(Plus m NeutralLevel{})]) - -- | m == n -> equalLevel' (Max [a]) (Max [b]) - -- -- Andreas, 2014-04-07: This call to equalLevel is ok even if we removed - -- -- subsumed terms from the lhs. - - -- anything else - _ -> postpone - where - ok = return () - notok = unlessM typeInType $ typeError $ NotLeqSort (Type a) (Type b) - postpone = patternViolation - - wrap m = catchError m $ \e -> - case e of - TypeError{} -> notok - _ -> throwError e - - maybeok True = ok - maybeok False = notok - - neutral (Plus _ NeutralLevel{}) = True - neutral _ = False - - meta (Plus _ MetaLevel{}) = True - meta _ = False - - unneutral (Plus _ (NeutralLevel _ v)) = v - unneutral _ = __IMPOSSIBLE__ - - constant (ClosedLevel n) = n - constant (Plus n _) = n - - subtr m (ClosedLevel n) = ClosedLevel (n - m) - subtr m (Plus n l) = Plus (n - m) l - --- choice [] = patternViolation --- choice (m:ms) = noConstraints m `catchError` \_ -> choice ms --- case e of --- PatternErr{} -> choice ms --- _ -> throwError e - -equalLevel :: Level -> Level -> TCM () -equalLevel a b = do - -- Andreas, 2013-10-31 Use normalization to make syntactic equality stronger - (a, b) <- normalise (a, b) - equalLevel' a b - --- | Precondition: levels are 'normalise'd. -equalLevel' :: Level -> Level -> TCM () -equalLevel' a b = do - reportSDoc "tc.conv.level" 50 $ sep [ "equalLevel", nest 2 $ parens $ pretty a, nest 2 $ parens $ pretty b ] - liftTCM $ catchConstraint (LevelCmp CmpEq a b) $ - check a b - where - check a@(Max as) b@(Max bs) = do - -- Jesper, 2014-02-02 remove terms that certainly do not contribute - -- to the maximum - as <- return $ [ a | a <- as, not $ a `isStrictlySubsumedBy` bs ] - bs <- return $ [ b | b <- bs, not $ b `isStrictlySubsumedBy` as ] - -- Andreas, 2013-10-31 remove common terms (that don't contain metas!) - -- THAT's actually UNSOUND when metas are instantiated, because - -- max a b == max a c does not imply b == c - -- as <- return $ Set.fromList $ closed0 as - -- bs <- return $ Set.fromList $ closed0 bs - -- let cs = Set.filter (not . hasMeta) $ Set.intersection as bs - -- as <- return $ Set.toList $ as Set.\\ cs - -- bs <- return $ Set.toList $ bs Set.\\ cs - as <- return $ List.sort $ closed0 as - bs <- return $ List.sort $ closed0 bs - reportSDoc "tc.conv.level" 40 $ - sep [ "equalLevel" - , vcat [ nest 2 $ sep [ prettyTCM a <+> "==" - , prettyTCM b - ] - , "reduced" - , nest 2 $ sep [ prettyTCM (Max as) <+> "==" - , prettyTCM (Max bs) - ] - ] - ] - reportSDoc "tc.conv.level" 50 $ - sep [ text "equalLevel" - , vcat [ nest 2 $ sep [ pretty (Max as) <+> "==" - , pretty (Max bs) - ] - ] - ] - case (as, bs) of - _ | as == bs -> ok - | any isBlocked (as ++ bs) -> do - lvl <- levelType - liftTCM $ addConstraint $ ValueCmp CmpEq lvl (Level a) (Level b) - - -- closed == closed - ([ClosedLevel n], [ClosedLevel m]) - | n == m -> ok - | otherwise -> notok - - -- closed == neutral - ([ClosedLevel{}], _) | any isNeutral bs -> notok - (_, [ClosedLevel{}]) | any isNeutral as -> notok - - -- 0 == any - ([ClosedLevel 0], bs@(_:_:_)) -> sequence_ [ equalLevel' (Max []) (Max [b]) | b <- bs ] - (as@(_:_:_), [ClosedLevel 0]) -> sequence_ [ equalLevel' (Max [a]) (Max []) | a <- as ] - -- Andreas, 2014-04-07 Why should the following be ok? - -- X (suc a) could be different from X (suc (suc a)) - -- -- Same meta - -- ([Plus n (MetaLevel x _)], [Plus m (MetaLevel y _)]) - -- | n == m && x == y -> ok - - -- meta == any - ([Plus n (MetaLevel x as)], _) - | any (isThisMeta x) bs -> postpone - (_, [Plus n (MetaLevel x bs)]) - | any (isThisMeta x) as -> postpone - ([Plus n (MetaLevel x as')], [Plus m (MetaLevel y bs')]) - -- lexicographic comparison intended! - | (n, y) < (m, x) -> meta n x as' bs - | otherwise -> meta m y bs' as - ([Plus n (MetaLevel x as')],_) -> meta n x as' bs - (_,[Plus m (MetaLevel y bs')]) -> meta m y bs' as - - -- any other metas - -- Andreas, 2013-10-31: There could be metas in neutral levels (see Issue 930). - -- Should not we postpone there as well? Yes! - _ | any hasMeta (as ++ bs) -> postpone - - -- neutral/closed == neutral/closed - _ | all isNeutralOrClosed (as ++ bs) -> do - reportSLn "tc.conv.level" 60 $ "equalLevel: all are neutral or closed" - if length as == length bs - then zipWithM_ (\a b -> [a] =!= [b]) as bs - else notok - - -- more cases? - _ -> postpone - - where - a === b = unlessM typeInType $ do - lvl <- levelType - equalAtom lvl a b - as =!= bs = levelTm (Max as) === levelTm (Max bs) - - ok = return () - notok = unlessM typeInType notOk - notOk = typeError $ UnequalSorts (Type a) (Type b) - postpone = do - reportSDoc "tc.conv.level" 30 $ hang "postponing:" 2 $ hang (pretty a <+> "==") 0 (pretty b) - patternViolation - - closed0 [] = [ClosedLevel 0] - closed0 as = as - - -- perform assignment (Plus n (MetaLevel x as)) := bs - meta n x as bs = do - reportSLn "tc.meta.level" 30 $ "Assigning meta level" - reportSDoc "tc.meta.level" 50 $ "meta" <+> sep [prettyList $ map pretty as, prettyList $ map pretty bs] - bs' <- mapM (subtr n) bs - assignE DirEq x as (levelTm (Max bs')) (===) -- fallback: check equality as atoms - - -- Make sure to give a sensible error message - wrap m = m `catchError` \err -> - case err of - TypeError{} -> notok - _ -> throwError err - - subtr n (ClosedLevel m) - | m >= n = return $ ClosedLevel (m - n) - | otherwise = ifM typeInType (return $ ClosedLevel 0) $ notOk - subtr n (Plus m a) - | m >= n = return $ Plus (m - n) a - subtr _ (Plus _ BlockedLevel{}) = postpone - subtr _ (Plus _ MetaLevel{}) = postpone - subtr _ (Plus _ NeutralLevel{}) = postpone - subtr _ (Plus _ UnreducedLevel{}) = __IMPOSSIBLE__ - - isNeutral (Plus _ NeutralLevel{}) = True - isNeutral _ = False - - isClosed ClosedLevel{} = True - isClosed _ = False - - isNeutralOrClosed l = isClosed l || isNeutral l - - isBlocked (Plus _ BlockedLevel{}) = True - isBlocked _ = False - - hasMeta ClosedLevel{} = False - hasMeta (Plus _ MetaLevel{}) = True - hasMeta (Plus _ (BlockedLevel _ v)) = isJust $ firstMeta v - hasMeta (Plus _ (NeutralLevel _ v)) = isJust $ firstMeta v - hasMeta (Plus _ (UnreducedLevel v)) = isJust $ firstMeta v - - isThisMeta x (Plus _ (MetaLevel y _)) = x == y - isThisMeta _ _ = False - - constant (ClosedLevel n) = n - constant (Plus n _) = n - - (ClosedLevel m) `isStrictlySubsumedBy` [] = m == 0 - (ClosedLevel m) `isStrictlySubsumedBy` ys = m < maximum (map constant ys) - (Plus m x) `isStrictlySubsumedBy` ys = not $ null $ - [ n | Plus n y <- ys, x == y, m < n ] - - --- | Check that the first sort equal to the second. -equalSort :: Sort -> Sort -> TCM () -equalSort s1 s2 = do - catchConstraint (SortCmp CmpEq s1 s2) $ do - (s1,s2) <- reduce (s1,s2) - let postpone = addConstraint (SortCmp CmpEq s1 s2) - yes = return () - no = typeError $ UnequalSorts s1 s2 - synEq = ifNotM (optSyntacticEquality <$> pragmaOptions) postpone $ do - ((s1,s2) , equal) <- SynEq.checkSyntacticEquality s1 s2 - if | equal -> yes - | otherwise -> postpone - - reportSDoc "tc.conv.sort" 30 $ sep - [ "equalSort" - , vcat [ nest 2 $ fsep [ prettyTCM s1 <+> "==" - , prettyTCM s2 ] - , nest 2 $ fsep [ pretty s1 <+> "==" - , pretty s2 ] - ] - ] - - propEnabled <- isPropEnabled - typeInTypeEnabled <- typeInType - - case (s1, s2) of - - -- Andreas, 2018-09-03: crash on dummy sort - (DummyS s, _) -> impossibleSort s - (_, DummyS s) -> impossibleSort s - - -- one side is a meta sort: try to instantiate - -- In case both sides are meta sorts, instantiate the - -- bigger (i.e. more recent) one. - (MetaS x es , MetaS y es') - | x == y -> synEq - | x < y -> meta y es' s1 - | otherwise -> meta x es s2 - (MetaS x es , _ ) -> meta x es s2 - (_ , MetaS x es ) -> meta x es s1 - - -- Other blocked sorts: check syntactic equality - (PiSort{} , PiSort{} ) -> synEq - (UnivSort{} , UnivSort{} ) -> synEq - - -- diagonal cases for rigid sorts - (Type a , Type b ) -> equalLevel a b - (SizeUniv , SizeUniv ) -> yes - (Prop a , Prop b ) -> equalLevel a b - (Inf , Inf ) -> yes - - -- if --type-in-type is enabled, Setω is equal to any Set ℓ (see #3439) - (Type{} , Inf ) - | typeInTypeEnabled -> yes - (Inf , Type{} ) - | typeInTypeEnabled -> yes - - -- if @PiSort a b == Set0@, then @b == Set0@ - -- we use this fact to solve metas in @b@, - -- hopefully allowing the @PiSort@ to reduce. - (Type (Max []) , PiSort a b ) - | not propEnabled -> piSortEqualsBottom set0 a b - (PiSort a b , Type (Max [])) - | not propEnabled -> piSortEqualsBottom set0 a b - - (Prop (Max []) , PiSort a b ) -> piSortEqualsBottom prop0 a b - (PiSort a b , Prop (Max [])) -> piSortEqualsBottom prop0 a b - - -- @PiSort a b == SizeUniv@ iff @b == SizeUniv@ - (SizeUniv , PiSort a b ) -> - underAbstraction_ b $ equalSort SizeUniv - (PiSort a b , SizeUniv ) -> - underAbstraction_ b $ equalSort SizeUniv - - -- @Prop0@ and @SizeUniv@ don't contain any universes, - -- so they cannot be a UnivSort - (Prop (Max []) , UnivSort s ) -> no - (UnivSort s , Prop (Max [])) -> no - (SizeUniv , UnivSort s ) -> no - (UnivSort s , SizeUniv ) -> no - - - -- PiSort and UnivSort could compute later, so we postpone - (PiSort{} , _ ) -> postpone - (_ , PiSort{} ) -> postpone - (UnivSort{} , _ ) -> postpone - (_ , UnivSort{} ) -> postpone - - -- postulated sorts can only be equal if they have the same head - (DefS d es , DefS d' es') | d == d' -> synEq - - -- any other combinations of sorts are not equal - (_ , _ ) -> no - - where - -- perform assignment (MetaS x es) := s - meta x es s = do - reportSLn "tc.meta.sort" 30 $ "Assigning meta sort" - reportSDoc "tc.meta.sort" 50 $ "meta" <+> sep [pretty x, prettyList $ map pretty es, pretty s] - assignE DirEq x es (Sort s) __IMPOSSIBLE__ - - set0 = Type $ Max [] - prop0 = Prop $ Max [] - - -- equate @piSort a b@ to @s0@, which is assumed to be a (closed) bottom sort - -- i.e. @piSort a b == s0@ implies @b == s0@. - piSortEqualsBottom s0 a b = do - underAbstraction_ b $ equalSort s0 - -- we may have instantiated some metas, so @a@ could reduce - a <- reduce a - case funSort' a s0 of - Just s -> equalSort s s0 - Nothing -> addConstraint $ SortCmp CmpEq (funSort a s0) s0 - impossibleSort s = do - reportSLn "impossible" 10 $ unlines - [ "equalSort: found dummy sort with description:" - , s - ] - __IMPOSSIBLE__ - - --- -- This should probably represent face maps with a more precise type --- toFaceMaps :: Term -> TCM [[(Int,Term)]] --- toFaceMaps t = do --- view <- intervalView' --- iz <- primIZero --- io <- primIOne --- ineg <- (\ q t -> Def q [Apply $ Arg defaultArgInfo t]) <$> fromMaybe __IMPOSSIBLE__ <$> getPrimitiveName' "primINeg" - --- let f IZero = mzero --- f IOne = return [] --- f (IMin x y) = do xs <- (f . view . unArg) x; ys <- (f . view . unArg) y; return (xs ++ ys) --- f (IMax x y) = msum $ map (f . view . unArg) [x,y] --- f (INeg x) = map (id -*- not) <$> (f . view . unArg) x --- f (OTerm (Var i [])) = return [(i,True)] --- f (OTerm _) = return [] -- what about metas? we should suspend? maybe no metas is a precondition? --- isConsistent xs = all (\ xs -> length xs == 1) . map nub . Map.elems $ xs -- optimize by not doing generate + filter --- as = map (map (id -*- head) . Map.toAscList) . filter isConsistent . map (Map.fromListWith (++) . map (id -*- (:[]))) $ (f (view t)) --- xs <- mapM (mapM (\ (i,b) -> (,) i <$> intervalUnview (if b then IOne else IZero))) as --- return xs - -forallFaceMaps :: Term -> (Map.Map Int Bool -> MetaId -> Term -> TCM a) -> (Substitution -> TCM a) -> TCM [a] -forallFaceMaps t kb k = do - reportSDoc "conv.forall" 20 $ - fsep ["forallFaceMaps" - , prettyTCM t - ] - as <- decomposeInterval t - boolToI <- do - io <- primIOne - iz <- primIZero - return (\b -> if b then io else iz) - forM as $ \ (ms,ts) -> do - ifBlockeds ts (kb ms) $ \ _ _ -> do - let xs = map (id -*- boolToI) $ Map.toAscList ms - cxt <- getContext - reportSDoc "conv.forall" 20 $ - fsep ["substContextN" - , prettyTCM cxt - , prettyTCM xs - ] - (cxt',sigma) <- substContextN cxt xs - resolved <- forM xs (\ (i,t) -> (,) <$> lookupBV i <*> return (applySubst sigma t)) - updateContext sigma (const cxt') $ - addBindings resolved $ do - cl <- buildClosure () - tel <- getContextTelescope - m <- currentModule - sub <- getModuleParameterSub m - reportSLn "conv.forall" 10 $ unlines [replicate 10 '-' - , show (envCurrentModule $ clEnv cl) - , show (envLetBindings $ clEnv cl) - , show tel -- (toTelescope $ envContext $ clEnv cl) - , show sigma - , show m - , show sub] - - k sigma - where - -- TODO Andrea: inefficient because we try to reduce the ts which we know are in whnf - ifBlockeds ts blocked unblocked = do - and <- getPrimitiveTerm "primIMin" - io <- primIOne - let t = foldr (\ x r -> and `apply` [argN x,argN r]) io ts - ifBlocked t blocked unblocked - addBindings [] m = m - addBindings ((Dom{domInfo = info,unDom = (nm,ty)},t):bs) m = addLetBinding info nm t ty (addBindings bs m) - - substContextN :: Context -> [(Int,Term)] -> TCM (Context , Substitution) - substContextN c [] = return (c, idS) - substContextN c ((i,t):xs) = do - (c', sigma) <- substContext i t c - (c'', sigma') <- substContextN c' (map (subtract 1 -*- applySubst sigma) xs) - return (c'', applySubst sigma' sigma) - - - -- assumes the term can be typed in the shorter telescope - -- the terms we get from toFaceMaps are closed. - substContext :: Int -> Term -> Context -> TCM (Context , Substitution) - substContext i t [] = __IMPOSSIBLE__ - substContext i t (x:xs) | i == 0 = return $ (xs , singletonS 0 t) - substContext i t (x:xs) | i > 0 = do - reportSDoc "conv.forall" 20 $ - fsep ["substContext" - , text (show (i-1)) - , prettyTCM t - , prettyTCM xs - ] - (c,sigma) <- substContext (i-1) t xs - let e = applySubst sigma x - return (e:c, liftS 1 sigma) - substContext i t (x:xs) = __IMPOSSIBLE__ - -compareInterval :: Comparison -> Type -> Term -> Term -> TCM () -compareInterval cmp i t u = do - reportSDoc "tc.conv.interval" 15 $ - sep [ "{ compareInterval" <+> prettyTCM t <+> "=" <+> prettyTCM u ] - tb <- reduceB t - ub <- reduceB u - let t = ignoreBlocking tb - u = ignoreBlocking ub - it <- decomposeInterval' t - iu <- decomposeInterval' u - case () of - _ | blockedOrMeta tb || blockedOrMeta ub -> do - -- in case of metas we wouldn't be able to make progress by how we deal with de morgan laws. - -- (because the constraints generated by decomposition are sufficient but not necessary). - -- but we could still prune/solve some metas by comparing the terms as atoms. - -- also if blocked we won't find the terms conclusively unequal(?) so compareAtom - -- won't report type errors when we should accept. - interval <- elInf $ primInterval - compareAtom CmpEq interval t u - _ | otherwise -> do - x <- leqInterval it iu - y <- leqInterval iu it - let final = isCanonical it && isCanonical iu - if x && y then reportSDoc "tc.conv.interval" 15 $ "Ok! }" else - if final then typeError $ UnequalTerms cmp t u i - else do - reportSDoc "tc.conv.interval" 15 $ "Giving up! }" - patternViolation - where - blockedOrMeta Blocked{} = True - blockedOrMeta (NotBlocked _ (MetaV{})) = True - blockedOrMeta _ = False - - -type Conj = (Map.Map Int (Set.Set Bool),[Term]) - -isCanonical :: [Conj] -> Bool -isCanonical = all (null . snd) - --- | leqInterval r q = r ≤ q in the I lattice. --- (∨ r_i) ≤ (∨ q_j) iff ∀ i. ∃ j. r_i ≤ q_j -leqInterval :: [Conj] -> [Conj] -> TCM Bool -leqInterval r q = - and <$> forM r (\ r_i -> - or <$> forM q (\ q_j -> leqConj r_i q_j)) -- TODO shortcut - --- | leqConj r q = r ≤ q in the I lattice, when r and q are conjuctions. --- ' (∧ r_i) ≤ (∧ q_j) iff --- ' (∧ r_i) ∧ (∧ q_j) = (∧ r_i) iff --- ' {r_i | i} ∪ {q_j | j} = {r_i | i} iff --- ' {q_j | j} ⊆ {r_i | i} -leqConj :: Conj -> Conj -> TCM Bool -leqConj (rs,rst) (qs,qst) = do - case toSet qs `Set.isSubsetOf` toSet rs of - False -> return False - True -> do - interval <- elInf $ primInterval - - -- we don't want to generate new constraints here because - -- 1) in some situations the same constraint would get generated twice. - -- 2) unless things are completely accepted we are going to - -- throw patternViolation in compareInterval. - let eqT t u = tryConversion (compareAtom CmpEq interval t u) - - let listSubset ts us = and <$> forM ts (\ t -> - or <$> forM us (\ u -> eqT t u)) -- TODO shortcut - listSubset qst rst - where - toSet m = Set.fromList [ (i,b) | (i,bs) <- Map.toList m, b <- Set.toList bs] - - --- | equalTermOnFace φ A u v = _ , φ ⊢ u = v : A -equalTermOnFace :: Term -> Type -> Term -> Term -> TCM () -equalTermOnFace = compareTermOnFace CmpEq - -compareTermOnFace :: Comparison -> Term -> Type -> Term -> Term -> TCM () -compareTermOnFace = compareTermOnFace' compareTerm - -compareTermOnFace' :: (Comparison -> Type -> Term -> Term -> TCM ()) -> Comparison -> Term -> Type -> Term -> Term -> TCM () -compareTermOnFace' k cmp phi ty u v = do - phi <- reduce phi - _ <- forallFaceMaps phi postponed - $ \ alpha -> k cmp (applySubst alpha ty) (applySubst alpha u) (applySubst alpha v) - return () - where - postponed ms i psi = do - phi <- runNamesT [] $ do - imin <- cl $ getPrimitiveTerm "primIMin" - ineg <- cl $ getPrimitiveTerm "primINeg" - psi <- open psi - let phi = foldr (\ (i,b) r -> do i <- open (var i); pure imin <@> (if b then i else pure ineg <@> i) <@> r) - psi (Map.toList ms) -- TODO Andrea: make a view? - phi - addConstraint (ValueCmpOnFace cmp phi ty u v) - ---------------------------------------------------------------------------- --- * Definitions ---------------------------------------------------------------------------- - -bothAbsurd :: QName -> QName -> TCM Bool +{-# LANGUAGE NondecreasingIndentation #-} + +module Agda.TypeChecking.Conversion where + +import Control.Arrow (first, second) +import Control.Monad +import Control.Monad.Fail (MonadFail) + +import Data.Function +import qualified Data.List as List +import Data.List.NonEmpty (NonEmpty(..)) +import qualified Data.List.NonEmpty as NonEmpty +import qualified Data.Map as Map +import qualified Data.Set as Set +import qualified Data.IntSet as IntSet + +import Agda.Syntax.Abstract.Views (isSet) +import Agda.Syntax.Common +import Agda.Syntax.Internal +import Agda.Syntax.Internal.MetaVars +import Agda.Syntax.Translation.InternalToAbstract (reify) + +import Agda.TypeChecking.Monad +import Agda.TypeChecking.Monad.Builtin +import Agda.TypeChecking.MetaVars +import Agda.TypeChecking.MetaVars.Occurs (killArgs,PruneResult(..),rigidVarsNotContainedIn) +import Agda.TypeChecking.Names +import Agda.TypeChecking.Reduce +import Agda.TypeChecking.Substitute +import qualified Agda.TypeChecking.SyntacticEquality as SynEq +import Agda.TypeChecking.Telescope +import Agda.TypeChecking.Constraints +import Agda.TypeChecking.Conversion.Pure (pureCompareAs) +import {-# SOURCE #-} Agda.TypeChecking.CheckInternal (infer) +import Agda.TypeChecking.Forcing (isForced, nextIsForced) +import Agda.TypeChecking.Free +import Agda.TypeChecking.Datatypes (getConType, getFullyAppliedConType) +import Agda.TypeChecking.Records +import Agda.TypeChecking.Pretty +import Agda.TypeChecking.Injectivity +import Agda.TypeChecking.Polarity +import Agda.TypeChecking.SizedTypes +import Agda.TypeChecking.Level +import Agda.TypeChecking.Implicit (implicitArgs) +import Agda.TypeChecking.Irrelevance +import Agda.TypeChecking.Primitive +import Agda.TypeChecking.Warnings (MonadWarning) +import Agda.Interaction.Options + +import Agda.Utils.Except ( MonadError(catchError, throwError) ) +import Agda.Utils.Functor +import Agda.Utils.Monad +import Agda.Utils.Maybe +import Agda.Utils.Permutation +import Agda.Utils.Size +import Agda.Utils.Tuple +import Agda.Utils.WithDefault + +import Agda.Utils.Impossible + +type MonadConversion m = + ( MonadReduce m + , MonadAddContext m + , MonadConstraint m + , MonadMetaSolver m + , MonadError TCErr m + , MonadWarning m + , MonadDebug m + , MonadStatistics m + , MonadFresh ProblemId m + , MonadFresh Int m + , HasBuiltins m + , HasConstInfo m + , HasOptions m + , MonadFail m + ) + +-- | Try whether a computation runs without errors or new constraints +-- (may create new metas, though). +-- Restores state upon failure. +tryConversion + :: (MonadConstraint m, MonadWarning m, MonadError TCErr m, MonadFresh ProblemId m) + => m () -> m Bool +tryConversion = isJust <.> tryConversion' + +-- | Try whether a computation runs without errors or new constraints +-- (may create new metas, though). +-- Return 'Just' the result upon success. +-- Return 'Nothing' and restore state upon failure. +tryConversion' + :: (MonadConstraint m, MonadWarning m, MonadError TCErr m, MonadFresh ProblemId m) + => m a -> m (Maybe a) +tryConversion' m = tryMaybe $ noConstraints m + +-- | Check if to lists of arguments are the same (and all variables). +-- Precondition: the lists have the same length. +sameVars :: Elims -> Elims -> Bool +sameVars xs ys = and $ zipWith same xs ys + where + same (Apply (Arg _ (Var n []))) (Apply (Arg _ (Var m []))) = n == m + same _ _ = False + +-- | @intersectVars us vs@ checks whether all relevant elements in @us@ and @vs@ +-- are variables, and if yes, returns a prune list which says @True@ for +-- arguments which are different and can be pruned. +intersectVars :: Elims -> Elims -> Maybe [Bool] +intersectVars = zipWithM areVars where + -- ignore irrelevant args + areVars (Apply u) v | isIrrelevant u = Just False -- do not prune + areVars (Apply (Arg _ (Var n []))) (Apply (Arg _ (Var m []))) = Just $ n /= m -- prune different vars + areVars _ _ = Nothing + +equalTerm :: MonadConversion m => Type -> Term -> Term -> m () +equalTerm = compareTerm CmpEq + +equalAtom :: MonadConversion m => CompareAs -> Term -> Term -> m () +equalAtom = compareAtom CmpEq + +equalType :: MonadConversion m => Type -> Type -> m () +equalType = compareType CmpEq + +{- Comparing in irrelevant context always succeeds. + + However, we might want to dig for solutions of irrelevant metas. + + To this end, we can just ignore errors during conversion checking. + -} + +-- convError :: MonadTCM tcm => TypeError -> tcm a +-- | Ignore errors in irrelevant context. +convError :: TypeError -> TCM () +convError err = ifM ((==) Irrelevant <$> asksTC getRelevance) (return ()) $ typeError err + +-- | Type directed equality on values. +-- +compareTerm :: forall m. MonadConversion m => Comparison -> Type -> Term -> Term -> m () +compareTerm cmp a u v = compareAs cmp (AsTermsOf a) u v + +-- | Type directed equality on terms or types. +compareAs :: forall m. MonadConversion m => Comparison -> CompareAs -> Term -> Term -> m () + -- If one term is a meta, try to instantiate right away. This avoids unnecessary unfolding. + -- Andreas, 2012-02-14: This is UNSOUND for subtyping! +compareAs cmp a u v = do + reportSDoc "tc.conv.term" 10 $ sep $ + [ "compareTerm" + , nest 2 $ prettyTCM u <+> prettyTCM cmp <+> prettyTCM v + , nest 2 $ prettyTCM a + ] + -- Check syntactic equality. This actually saves us quite a bit of work. + ((u, v), equal) <- SynEq.checkSyntacticEquality u v + -- OLD CODE, traverses the *full* terms u v at each step, even if they + -- are different somewhere. Leads to infeasibility in issue 854. + -- (u, v) <- instantiateFull (u, v) + -- let equal = u == v + if equal then verboseS "profile.sharing" 20 $ tick "equal terms" else do + verboseS "profile.sharing" 20 $ tick "unequal terms" + reportSDoc "tc.conv.term" 15 $ sep $ + [ "compareTerm (not syntactically equal)" + , nest 2 $ prettyTCM u <+> prettyTCM cmp <+> prettyTCM v + , nest 2 $ prettyTCM a + ] + -- If we are at type Size, we cannot short-cut comparison + -- against metas by assignment. + -- Andreas, 2014-04-12: this looks incomplete. + -- It seems to assume we are never comparing + -- at function types into Size. + let fallback = compareAs' cmp a u v + unlessSubtyping :: m () -> m () + unlessSubtyping cont = + if cmp == CmpEq then cont else do + -- Andreas, 2014-04-12 do not short cut if type is blocked. + ifBlocked a (\ _ _ -> fallback) {-else-} $ \ _ a -> do + -- do not short circuit size comparison! + caseMaybeM (isSizeType a) cont (\ _ -> fallback) + + dir = fromCmp cmp + rid = flipCmp dir -- The reverse direction. Bad name, I know. + case (u, v) of + (MetaV x us, MetaV y vs) + | x /= y -> unlessSubtyping $ solve1 `orelse` solve2 `orelse` fallback + | otherwise -> fallback + where + (solve1, solve2) | x > y = (assign dir x us v, assign rid y vs u) + | otherwise = (assign rid y vs u, assign dir x us v) + (MetaV x us, _) -> unlessSubtyping $ assign dir x us v `orelse` fallback + (_, MetaV y vs) -> unlessSubtyping $ assign rid y vs u `orelse` fallback + _ -> fallback + where + assign :: CompareDirection -> MetaId -> Elims -> Term -> m () + assign dir x es v = do + -- Andreas, 2013-10-19 can only solve if no projections + reportSDoc "tc.conv.term.shortcut" 20 $ sep + [ "attempting shortcut" + , nest 2 $ prettyTCM (MetaV x es) <+> ":=" <+> prettyTCM v + ] + whenM (isInstantiatedMeta x) patternViolation + assignE dir x es v a $ compareAsDir dir a + reportSDoc "tc.conv.term.shortcut" 50 $ + "shortcut successful" $$ nest 2 ("result:" <+> (pretty =<< instantiate (MetaV x es))) + -- Should be ok with catchError_ but catchError is much safer since we don't + -- rethrow errors. + orelse :: m () -> m () -> m () + orelse m h = catchError m (\_ -> h) + +-- | Try to assign meta. If meta is projected, try to eta-expand +-- and run conversion check again. +assignE :: (MonadConversion m) + => CompareDirection -> MetaId -> Elims -> Term -> CompareAs -> (Term -> Term -> m ()) -> m () +assignE dir x es v a comp = assignWrapper dir x es v $ do + case allApplyElims es of + Just vs -> assignV dir x vs v a + Nothing -> do + reportSDoc "tc.conv.assign" 30 $ sep + [ "assigning to projected meta " + , prettyTCM x <+> sep (map prettyTCM es) <+> text (":" ++ show dir) <+> prettyTCM v + ] + etaExpandMeta [Records] x + res <- isInstantiatedMeta' x + case res of + Just u -> do + reportSDoc "tc.conv.assign" 30 $ sep + [ "seems like eta expansion instantiated meta " + , prettyTCM x <+> text (":" ++ show dir) <+> prettyTCM u + ] + let w = u `applyE` es + comp w v + Nothing -> do + reportSLn "tc.conv.assign" 30 "eta expansion did not instantiate meta" + patternViolation -- nothing happened, give up + +compareAsDir :: MonadConversion m => CompareDirection -> CompareAs -> Term -> Term -> m () +compareAsDir dir a = dirToCmp (`compareAs'` a) dir + +compareAs' :: forall m. MonadConversion m => Comparison -> CompareAs -> Term -> Term -> m () +compareAs' cmp tt m n = case tt of + AsTermsOf a -> compareTerm' cmp a m n + AsSizes -> compareSizes cmp m n + AsTypes -> compareAtom cmp AsTypes m n + +compareTerm' :: forall m. MonadConversion m => Comparison -> Type -> Term -> Term -> m () +compareTerm' cmp a m n = + verboseBracket "tc.conv.term" 20 "compareTerm" $ do + a' <- reduce a + (catchConstraint (ValueCmp cmp (AsTermsOf a') m n) :: m () -> m ()) $ do + reportSDoc "tc.conv.term" 30 $ fsep + [ "compareTerm", prettyTCM m, prettyTCM cmp, prettyTCM n, ":", prettyTCM a' ] + propIrr <- isPropEnabled + isSize <- isJust <$> isSizeType a' + s <- reduce $ getSort a' + mlvl <- getBuiltin' builtinLevel + reportSDoc "tc.conv.level" 60 $ nest 2 $ sep + [ "a' =" <+> pretty a' + , "mlvl =" <+> pretty mlvl + , text $ "(Just (unEl a') == mlvl) = " ++ show (Just (unEl a') == mlvl) + ] + case s of + Prop{} | propIrr -> compareIrrelevant a' m n + _ | isSize -> compareSizes cmp m n + _ -> case unEl a' of + a | Just a == mlvl -> do + a <- levelView m + b <- levelView n + equalLevel a b + a@Pi{} -> equalFun s a m n + Lam _ _ -> __IMPOSSIBLE__ + Def r es -> do + isrec <- isEtaRecord r + if isrec + then do + sig <- getSignature + let ps = fromMaybe __IMPOSSIBLE__ $ allApplyElims es + -- Andreas, 2010-10-11: allowing neutrals to be blocked things does not seem + -- to change Agda's behavior + -- isNeutral Blocked{} = False + isNeutral (NotBlocked _ Con{}) = return False + -- Andreas, 2013-09-18 / 2015-06-29: a Def by copatterns is + -- not neutral if it is blocked (there can be missing projections + -- to trigger a reduction. + isNeutral (NotBlocked r (Def q _)) = do -- Andreas, 2014-12-06 optimize this using r !! + not <$> usesCopatterns q -- a def by copattern can reduce if projected + isNeutral _ = return True + isMeta (NotBlocked _ MetaV{}) = True + isMeta _ = False + + reportSDoc "tc.conv.term" 30 $ prettyTCM a <+> "is eta record type" + m <- reduceB m + mNeutral <- isNeutral m + n <- reduceB n + nNeutral <- isNeutral n + case (m, n) of + _ | isMeta m || isMeta n -> + compareAtom cmp (AsTermsOf a') (ignoreBlocking m) (ignoreBlocking n) + + _ | mNeutral && nNeutral -> do + -- Andreas 2011-03-23: (fixing issue 396) + -- if we are dealing with a singleton record, + -- we can succeed immediately + isSing <- isSingletonRecordModuloRelevance r ps + case isSing of + Right True -> return () + -- do not eta-expand if comparing two neutrals + _ -> compareAtom cmp (AsTermsOf a') (ignoreBlocking m) (ignoreBlocking n) + _ -> do + (tel, m') <- etaExpandRecord r ps $ ignoreBlocking m + (_ , n') <- etaExpandRecord r ps $ ignoreBlocking n + -- No subtyping on record terms + c <- getRecordConstructor r + -- Record constructors are covariant (see test/succeed/CovariantConstructors). + compareArgs (repeat $ polFromCmp cmp) [] (telePi_ tel __DUMMY_TYPE__) (Con c ConOSystem []) m' n' + + else (do pathview <- pathView a' + equalPath pathview a' m n) + _ -> compareAtom cmp (AsTermsOf a') m n + where + -- equality at function type (accounts for eta) + equalFun :: (MonadConversion m) => Sort -> Term -> Term -> Term -> m () + equalFun s a@(Pi dom b) m n | domFinite dom = do + mp <- fmap getPrimName <$> getBuiltin' builtinIsOne + case unEl $ unDom dom of + Def q [Apply phi] + | Just q == mp -> compareTermOnFace cmp (unArg phi) (El s (Pi (dom {domFinite = False}) b)) m n + _ -> equalFun s (Pi (dom{domFinite = False}) b) m n + equalFun _ (Pi dom@Dom{domInfo = info} b) m n | not $ domFinite dom = do + let name = suggests [ Suggestion b , Suggestion m , Suggestion n ] + addContext (name, dom) $ compareTerm cmp (absBody b) m' n' + where + (m',n') = raise 1 (m,n) `apply` [Arg info $ var 0] + equalFun _ _ _ _ = __IMPOSSIBLE__ + + equalPath :: (MonadConversion m) => PathView -> Type -> Term -> Term -> m () + equalPath (PathType s _ l a x y) _ m n = do + let name = "i" :: String + interval <- el primInterval + let (m',n') = raise 1 (m, n) `applyE` [IApply (raise 1 $ unArg x) (raise 1 $ unArg y) (var 0)] + addContext (name, defaultDom interval) $ compareTerm cmp (El (raise 1 s) $ (raise 1 $ unArg a) `apply` [argN $ var 0]) m' n' + equalPath OType{} a' m n = cmpDef a' m n + + cmpDef a'@(El s ty) m n = do + mI <- getBuiltinName' builtinInterval + mIsOne <- getBuiltinName' builtinIsOne + mGlue <- getPrimitiveName' builtinGlue + mHComp <- getPrimitiveName' builtinHComp + mSub <- getBuiltinName' builtinSub + case ty of + Def q es | Just q == mIsOne -> return () + Def q es | Just q == mGlue, Just args@(l:_:a:phi:_) <- allApplyElims es -> do + ty <- el' (pure $ unArg l) (pure $ unArg a) + unglue <- prim_unglue + let mkUnglue m = apply unglue $ map (setHiding Hidden) args ++ [argN m] + reportSDoc "conv.glue" 20 $ prettyTCM (ty,mkUnglue m,mkUnglue n) + compareTermOnFace cmp (unArg phi) ty m n + compareTerm cmp ty (mkUnglue m) (mkUnglue n) + Def q es | Just q == mHComp, Just (sl:s:args@[phi,u,u0]) <- allApplyElims es + , Sort (Type lvl) <- unArg s -> do + let l = Level lvl + ty <- el' (pure $ l) (pure $ unArg u0) + unglueU <- prim_unglueU + subIn <- primSubIn + let bA = subIn `apply` [sl,s,phi,u0] + let mkUnglue m = apply unglueU $ [argH l] ++ map (setHiding Hidden) [phi,u] ++ [argH bA,argN m] + reportSDoc "conv.hcompU" 20 $ prettyTCM (ty,mkUnglue m,mkUnglue n) + compareTermOnFace cmp (unArg phi) ty m n + compareTerm cmp ty (mkUnglue m) (mkUnglue n) + Def q es | Just q == mSub, Just args@(l:a:_) <- allApplyElims es -> do + ty <- el' (pure $ unArg l) (pure $ unArg a) + out <- primSubOut + let mkOut m = apply out $ map (setHiding Hidden) args ++ [argN m] + compareTerm cmp ty (mkOut m) (mkOut n) + Def q [] | Just q == mI -> compareInterval cmp a' m n + _ -> compareAtom cmp (AsTermsOf a') m n + +-- | @compareTel t1 t2 cmp tel1 tel1@ checks whether pointwise +-- @tel1 \`cmp\` tel2@ and complains that @t2 \`cmp\` t1@ failed if +-- not. +compareTel :: MonadConversion m => Type -> Type -> + Comparison -> Telescope -> Telescope -> m () +compareTel t1 t2 cmp tel1 tel2 = + verboseBracket "tc.conv.tel" 20 "compareTel" $ + catchConstraint (TelCmp t1 t2 cmp tel1 tel2) $ case (tel1, tel2) of + (EmptyTel, EmptyTel) -> return () + (EmptyTel, _) -> bad + (_, EmptyTel) -> bad + (ExtendTel dom1{-@(Dom i1 a1)-} tel1, ExtendTel dom2{-@(Dom i2 a2)-} tel2) -> do + compareDom cmp dom1 dom2 tel1 tel2 bad bad bad bad $ + compareTel t1 t2 cmp (absBody tel1) (absBody tel2) + where + -- Andreas, 2011-05-10 better report message about types + bad = typeError $ UnequalTypes cmp t2 t1 + -- switch t2 and t1 because of contravariance! + +compareAtomDir :: MonadConversion m => CompareDirection -> CompareAs -> Term -> Term -> m () +compareAtomDir dir a = dirToCmp (`compareAtom` a) dir + +-- | Compute the head type of an elimination. For projection-like functions +-- this requires inferring the type of the principal argument. +computeElimHeadType :: MonadConversion m => QName -> Elims -> Elims -> m Type +computeElimHeadType f es es' = do + def <- getConstInfo f + -- To compute the type @a@ of a projection-like @f@, + -- we have to infer the type of its first argument. + if projectionArgs (theDef def) <= 0 then return $ defType def else do + -- Find an first argument to @f@. + let arg = case (es, es') of + (Apply arg : _, _) -> arg + (_, Apply arg : _) -> arg + _ -> __IMPOSSIBLE__ + -- Infer its type. + reportSDoc "tc.conv.infer" 30 $ + "inferring type of internal arg: " <+> prettyTCM arg + targ <- infer $ unArg arg + reportSDoc "tc.conv.infer" 30 $ + "inferred type: " <+> prettyTCM targ + -- getDefType wants the argument type reduced. + -- Andreas, 2016-02-09, Issue 1825: The type of arg might be + -- a meta-variable, e.g. in interactive development. + -- In this case, we postpone. + fromMaybeM patternViolation $ getDefType f =<< reduce targ + +-- | Syntax directed equality on atomic values +-- +compareAtom :: forall m. MonadConversion m => Comparison -> CompareAs -> Term -> Term -> m () +compareAtom cmp t m n = + verboseBracket "tc.conv.atom" 20 "compareAtom" $ + -- if a PatternErr is thrown, rebuild constraint! + (catchConstraint (ValueCmp cmp t m n) :: m () -> m ()) $ do + reportSDoc "tc.conv.atom" 50 $ + "compareAtom" <+> fsep [ prettyTCM m <+> prettyTCM cmp + , prettyTCM n + , prettyTCM t + ] + -- Andreas: what happens if I cut out the eta expansion here? + -- Answer: Triggers issue 245, does not resolve 348 + (mb',nb') <- ifM (asksTC envCompareBlocked) ((notBlocked -*- notBlocked) <$> reduce (m,n)) $ do + mb' <- etaExpandBlocked =<< reduceB m + nb' <- etaExpandBlocked =<< reduceB n + return (mb', nb') + + -- constructorForm changes literal to constructors + -- only needed if the other side is not a literal + (mb'', nb'') <- case (ignoreBlocking mb', ignoreBlocking nb') of + (Lit _, Lit _) -> return (mb', nb') + _ -> (,) <$> traverse constructorForm mb' + <*> traverse constructorForm nb' + + mb <- traverse unLevel mb'' + nb <- traverse unLevel nb'' + + cmpBlocked <- viewTC eCompareBlocked + + let m = ignoreBlocking mb + n = ignoreBlocking nb + + postpone = addConstraint $ ValueCmp cmp t m n + + -- Jesper, 2019-05-14, Issue #3776: If the type is blocked, + -- the comparison could be solved by eta-expansion so we + -- cannot fail hard + postponeIfBlockedAs :: CompareAs -> (Blocked CompareAs -> m ()) -> m () + postponeIfBlockedAs AsTypes f = f $ NotBlocked ReallyNotBlocked AsTypes + postponeIfBlockedAs AsSizes f = f $ NotBlocked ReallyNotBlocked AsSizes + postponeIfBlockedAs (AsTermsOf t) f = ifBlocked t + (\m t -> (f $ Blocked m $ AsTermsOf t) `catchError` \case + TypeError{} -> postpone + err -> throwError err) + (\nb t -> f $ NotBlocked nb $ AsTermsOf t) + + checkDefinitionalEquality = unlessM (pureCompareAs CmpEq t m n) postpone + + dir = fromCmp cmp + rid = flipCmp dir -- The reverse direction. Bad name, I know. + + assign dir x es v = assignE dir x es v t $ compareAtomDir dir t + + reportSDoc "tc.conv.atom" 30 $ + "compareAtom" <+> fsep [ prettyTCM mb <+> prettyTCM cmp + , prettyTCM nb + , prettyTCM t + ] + reportSDoc "tc.conv.atom" 80 $ + "compareAtom" <+> fsep [ (text . show) mb <+> prettyTCM cmp + , (text . show) nb + , ":" <+> (text . show) t ] + case (mb, nb) of + -- equate two metas x and y. if y is the younger meta, + -- try first y := x and then x := y + (NotBlocked _ (MetaV x xArgs), NotBlocked _ (MetaV y yArgs)) + | x == y , cmpBlocked -> do + a <- metaType x + compareElims [] [] a (MetaV x []) xArgs yArgs + | x == y -> + case intersectVars xArgs yArgs of + -- all relevant arguments are variables + Just kills -> do + -- kills is a list with 'True' for each different var + killResult <- killArgs kills x + case killResult of + NothingToPrune -> return () + PrunedEverything -> return () + PrunedNothing -> postpone + PrunedSomething -> postpone + -- not all relevant arguments are variables + Nothing -> checkDefinitionalEquality -- Check definitional equality on meta-variables + -- (same as for blocked terms) + | otherwise -> do + [p1, p2] <- mapM getMetaPriority [x,y] + -- First try the one with the highest priority. If that doesn't + -- work, try the low priority one. + let (solve1, solve2) + | (p1, x) > (p2, y) = (l1, r2) + | otherwise = (r1, l2) + where l1 = assign dir x xArgs n + r1 = assign rid y yArgs m + -- Careful: the first attempt might prune the low + -- priority meta! (Issue #2978) + l2 = ifM (isInstantiatedMeta x) (compareAsDir dir t m n) l1 + r2 = ifM (isInstantiatedMeta y) (compareAsDir rid t n m) r1 + + catchPatternErr solve2 solve1 + + -- one side a meta, the other an unblocked term + (NotBlocked _ (MetaV x es), _) -> assign dir x es n + (_, NotBlocked _ (MetaV x es)) -> assign rid x es m + (Blocked{}, Blocked{}) -> checkDefinitionalEquality + (Blocked{}, _) -> useInjectivity (fromCmp cmp) t m n -- The blocked term goes first + (_, Blocked{}) -> useInjectivity (flipCmp $ fromCmp cmp) t n m + _ -> postponeIfBlockedAs t $ \bt -> do + -- -- Andreas, 2013-10-20 put projection-like function + -- -- into the spine, to make compareElims work. + -- -- 'False' means: leave (Def f []) unchanged even for + -- -- proj-like funs. + -- m <- elimView False m + -- n <- elimView False n + -- Andreas, 2015-07-01, actually, don't put them into the spine. + -- Polarity cannot be communicated properly if projection-like + -- functions are post-fix. + case (m, n) of + (Pi{}, Pi{}) -> equalFun m n + + (Sort s1, Sort s2) -> + ifM (optCumulativity <$> pragmaOptions) + (compareSort cmp s1 s2) + (equalSort s1 s2) + + (Lit l1, Lit l2) | l1 == l2 -> return () + (Var i es, Var i' es') | i == i' -> do + a <- typeOfBV i + -- Variables are invariant in their arguments + compareElims [] [] a (var i) es es' + + -- The case of definition application: + (Def f es, Def f' es') -> do + + -- 1. All absurd lambdas are equal. + unlessM (bothAbsurd f f') $ do + + -- 2. If the heads are unequal, the only chance is subtyping between SIZE and SIZELT. + if f /= f' then trySizeUniv cmp t m n f es f' es' else do + + -- 3. If the heads are equal: + -- 3a. If there are no arguments, we are done. + unless (null es && null es') $ do + + -- 3b. If some cubical magic kicks in, we are done. + unlessM (compareEtaPrims f es es') $ do + + -- 3c. Oh no, we actually have to work and compare the eliminations! + a <- computeElimHeadType f es es' + -- The polarity vector of projection-like functions + -- does not include the parameters. + pol <- getPolarity' cmp f + compareElims pol [] a (Def f []) es es' + + -- Due to eta-expansion, these constructors are fully applied. + (Con x ci xArgs, Con y _ yArgs) + | x == y -> do + -- Get the type of the constructor instantiated to the datatype parameters. + a' <- case t of + AsTermsOf a -> conType x a + AsSizes -> __IMPOSSIBLE__ + AsTypes -> __IMPOSSIBLE__ + forcedArgs <- getForcedArgs $ conName x + -- Constructors are covariant in their arguments + -- (see test/succeed/CovariantConstructors). + compareElims (repeat $ polFromCmp cmp) forcedArgs a' (Con x ci []) xArgs yArgs + _ -> typeError $ UnequalTerms cmp m n $ ignoreBlocking bt + where + -- returns True in case we handled the comparison already. + compareEtaPrims :: MonadConversion m => QName -> Elims -> Elims -> m Bool + compareEtaPrims q es es' = do + munglue <- getPrimitiveName' builtin_unglue + munglueU <- getPrimitiveName' builtin_unglueU + msubout <- getPrimitiveName' builtinSubOut + case () of + _ | Just q == munglue -> compareUnglueApp q es es' + _ | Just q == munglueU -> compareUnglueUApp q es es' + _ | Just q == msubout -> compareSubApp q es es' + _ -> return False + compareSubApp q es es' = do + let (as,bs) = splitAt 5 es; (as',bs') = splitAt 5 es' + case (allApplyElims as, allApplyElims as') of + (Just [a,bA,phi,u,x], Just [a',bA',phi',u',x']) -> do + tSub <- primSub + -- Andrea, 28-07-16: + -- comparing the types is most probably wasteful, + -- since b and b' should be neutral terms, but it's a + -- precondition for the compareAtom call to make + -- sense. + equalType (El Inf $ apply tSub $ [a] ++ map (setHiding NotHidden) [bA,phi,u]) + (El Inf $ apply tSub $ [a] ++ map (setHiding NotHidden) [bA',phi',u']) + compareAtom cmp (AsTermsOf $ El Inf $ apply tSub $ [a] ++ map (setHiding NotHidden) [bA,phi,u]) + (unArg x) (unArg x') + compareElims [] [] (El (tmSort (unArg a)) (unArg bA)) (Def q as) bs bs' + return True + _ -> return False + compareUnglueApp q es es' = do + let (as,bs) = splitAt 7 es; (as',bs') = splitAt 7 es' + case (allApplyElims as, allApplyElims as') of + (Just [la,lb,bA,phi,bT,e,b], Just [la',lb',bA',phi',bT',e',b']) -> do + tGlue <- getPrimitiveTerm builtinGlue + -- Andrea, 28-07-16: + -- comparing the types is most probably wasteful, + -- since b and b' should be neutral terms, but it's a + -- precondition for the compareAtom call to make + -- sense. + -- equalType (El (tmSort (unArg lb)) $ apply tGlue $ [la,lb] ++ map (setHiding NotHidden) [bA,phi,bT,e]) + -- (El (tmSort (unArg lb')) $ apply tGlue $ [la',lb'] ++ map (setHiding NotHidden) [bA',phi',bT',e']) + compareAtom cmp (AsTermsOf $ El (tmSort (unArg lb)) $ apply tGlue $ [la,lb] ++ map (setHiding NotHidden) [bA,phi,bT,e]) + (unArg b) (unArg b') + compareElims [] [] (El (tmSort (unArg la)) (unArg bA)) (Def q as) bs bs' + return True + _ -> return False + compareUnglueUApp :: MonadConversion m => QName -> Elims -> Elims -> m Bool + compareUnglueUApp q es es' = do + let (as,bs) = splitAt 5 es; (as',bs') = splitAt 5 es' + case (allApplyElims as, allApplyElims as') of + (Just [la,phi,bT,bAS,b], Just [la',phi',bT',bA',b']) -> do + tHComp <- primHComp + tLSuc <- primLevelSuc + tSubOut <- primSubOut + iz <- primIZero + let lsuc t = tLSuc `apply` [argN t] + s = tmSort $ unArg la + sucla = lsuc <$> la + bA <- runNamesT [] $ do + [la,phi,bT,bAS] <- mapM (open . unArg) [la,phi,bT,bAS] + (pure tSubOut <#> (pure tLSuc <@> la) <#> (Sort . tmSort <$> la) <#> phi <#> (bT <@> primIZero) <@> bAS) + compareAtom cmp (AsTermsOf $ El (tmSort . unArg $ sucla) $ apply tHComp $ [sucla, argH (Sort s), phi] ++ [argH (unArg bT), argH bA]) + (unArg b) (unArg b') + compareElims [] [] (El s bA) (Def q as) bs bs' + return True + _ -> return False + -- Andreas, 2013-05-15 due to new postponement strategy, type can now be blocked + conType c t = ifBlocked t (\ _ _ -> patternViolation) $ \ _ t -> do + let impossible = do + reportSDoc "impossible" 10 $ + "expected data/record type, found " <+> prettyTCM t + reportSDoc "impossible" 70 $ nest 2 $ "raw =" <+> pretty t + -- __IMPOSSIBLE__ + -- Andreas, 2013-10-20: in case termination checking fails + -- we might get some unreduced types here. + -- In issue 921, this happens during the final attempt + -- to solve left-over constraints. + -- Thus, instead of crashing, just give up gracefully. + patternViolation + maybe impossible (return . snd) =<< getFullyAppliedConType c t + equalFun t1 t2 = case (t1, t2) of + (Pi dom1 b1, Pi dom2 b2) -> do + verboseBracket "tc.conv.fun" 15 "compare function types" $ do + reportSDoc "tc.conv.fun" 20 $ nest 2 $ vcat + [ "t1 =" <+> prettyTCM t1 + , "t2 =" <+> prettyTCM t2 + ] + compareDom cmp dom2 dom1 b1 b2 errH errR errQ errC $ + compareType cmp (absBody b1) (absBody b2) + where + errH = typeError $ UnequalHiding t1 t2 + errR = typeError $ UnequalRelevance cmp t1 t2 + errQ = typeError $ UnequalQuantity cmp t1 t2 + errC = typeError $ UnequalCohesion cmp t1 t2 + _ -> __IMPOSSIBLE__ + +-- | Check whether @a1 `cmp` a2@ and continue in context extended by @a1@. +compareDom :: (MonadConversion m , Free c) + => Comparison -- ^ @cmp@ The comparison direction + -> Dom Type -- ^ @a1@ The smaller domain. + -> Dom Type -- ^ @a2@ The other domain. + -> Abs b -- ^ @b1@ The smaller codomain. + -> Abs c -- ^ @b2@ The bigger codomain. + -> m () -- ^ Continuation if mismatch in 'Hiding'. + -> m () -- ^ Continuation if mismatch in 'Relevance'. + -> m () -- ^ Continuation if mismatch in 'Quantity'. + -> m () -- ^ Continuation if mismatch in 'Cohesion'. + -> m () -- ^ Continuation if comparison is successful. + -> m () +compareDom cmp0 + dom1@(Dom{domInfo = i1, unDom = a1}) + dom2@(Dom{domInfo = i2, unDom = a2}) + b1 b2 errH errR errQ errC cont = do + hasSubtyping <- collapseDefault . optSubtyping <$> pragmaOptions + let cmp = if hasSubtyping then cmp0 else CmpEq + if | not $ sameHiding dom1 dom2 -> errH + | not $ compareRelevance cmp (getRelevance dom1) (getRelevance dom2) -> errR + | not $ compareQuantity cmp (getQuantity dom1) (getQuantity dom2) -> errQ + | not $ compareCohesion cmp (getCohesion dom1) (getCohesion dom2) -> errC + | otherwise -> do + let r = max (getRelevance dom1) (getRelevance dom2) + -- take "most irrelevant" + dependent = (r /= Irrelevant) && isBinderUsed b2 + pid <- newProblem_ $ compareType cmp0 a1 a2 + dom <- if dependent + then (\ a -> dom1 {unDom = a}) <$> blockTypeOnProblem a1 pid + else return dom1 + -- We only need to require a1 == a2 if b2 is dependent + -- If it's non-dependent it doesn't matter what we add to the context. + let name = suggests [ Suggestion b1 , Suggestion b2 ] + addContext (name, dom) $ cont + stealConstraints pid + -- Andreas, 2013-05-15 Now, comparison of codomains is not + -- blocked any more by getting stuck on domains. + -- Only the domain type in context will be blocked. + -- But see issue #1258. + +compareRelevance :: Comparison -> Relevance -> Relevance -> Bool +compareRelevance CmpEq = (==) +compareRelevance CmpLeq = (<=) + +compareQuantity :: Comparison -> Quantity -> Quantity -> Bool +compareQuantity CmpEq = sameQuantity +compareQuantity CmpLeq = moreQuantity + +compareCohesion :: Comparison -> Cohesion -> Cohesion -> Bool +compareCohesion CmpEq = sameCohesion +compareCohesion CmpLeq = moreCohesion + +-- | When comparing argument spines (in compareElims) where the first arguments +-- don't match, we keep going, substituting the anti-unification of the two +-- terms in the telescope. More precisely: +-- +-- @@ +-- (u = v : A)[pid] w = antiUnify pid A u v us = vs : Δ[w/x] +-- ------------------------------------------------------------- +-- u us = v vs : (x : A) Δ +-- @@ +-- +-- The simplest case of anti-unification is to return a fresh metavariable +-- (created by blockTermOnProblem), but if there's shared structure between +-- the two terms we can expose that. +-- +-- This is really a crutch that lets us get away with things that otherwise +-- would require heterogenous conversion checking. See for instance issue +-- #2384. +antiUnify :: MonadConversion m => ProblemId -> Type -> Term -> Term -> m Term +antiUnify pid a u v = do + ((u, v), eq) <- SynEq.checkSyntacticEquality u v + if eq then return u else do + (u, v) <- reduce (u, v) + reportSDoc "tc.conv.antiUnify" 30 $ vcat + [ "antiUnify" + , "a =" <+> prettyTCM a + , "u =" <+> prettyTCM u + , "v =" <+> prettyTCM v + ] + case (u, v) of + (Pi ua ub, Pi va vb) -> do + wa0 <- antiUnifyType pid (unDom ua) (unDom va) + let wa = wa0 <$ ua + wb <- addContext wa $ antiUnifyType pid (absBody ub) (absBody vb) + return $ Pi wa (mkAbs (absName ub) wb) + (Lam i u, Lam _ v) -> + reduce (unEl a) >>= \case + Pi a b -> Lam i . (mkAbs (absName u)) <$> addContext a (antiUnify pid (absBody b) (absBody u) (absBody v)) + _ -> fallback + (Var i us, Var j vs) | i == j -> maybeGiveUp $ do + a <- typeOfBV i + antiUnifyElims pid a (var i) us vs + -- Andreas, 2017-07-27: + -- It seems that nothing guarantees here that the constructors are fully + -- applied!? Thus, @a@ could be a function type and we need the robust + -- @getConType@ here. + -- (Note that @patternViolation@ swallows exceptions coming from @getConType@ + -- thus, we would not see clearly if we used @getFullyAppliedConType@ instead.) + (Con x ci us, Con y _ vs) | x == y -> maybeGiveUp $ do + a <- maybe patternViolation (return . snd) =<< getConType x a + antiUnifyElims pid a (Con x ci []) us vs + (Def f us, Def g vs) | f == g, length us == length vs -> maybeGiveUp $ do + a <- computeElimHeadType f us vs + antiUnifyElims pid a (Def f []) us vs + _ -> fallback + where + maybeGiveUp = catchPatternErr fallback + + fallback = blockTermOnProblem a u pid + +antiUnifyArgs :: MonadConversion m => ProblemId -> Dom Type -> Arg Term -> Arg Term -> m (Arg Term) +antiUnifyArgs pid dom u v + | getModality u /= getModality v = patternViolation + | otherwise = applyModalityToContext u $ + ifM (isIrrelevantOrPropM dom) + {-then-} (return u) + {-else-} ((<$ u) <$> antiUnify pid (unDom dom) (unArg u) (unArg v)) + +antiUnifyType :: MonadConversion m => ProblemId -> Type -> Type -> m Type +antiUnifyType pid (El s a) (El _ b) = workOnTypes $ El s <$> antiUnify pid (sort s) a b + +antiUnifyElims :: MonadConversion m => ProblemId -> Type -> Term -> Elims -> Elims -> m Term +antiUnifyElims pid a self [] [] = return self +antiUnifyElims pid a self (Proj o f : es1) (Proj _ g : es2) | f == g = do + res <- projectTyped self a o f + case res of + Just (_, self, a) -> antiUnifyElims pid a self es1 es2 + Nothing -> patternViolation -- can fail for projection like +antiUnifyElims pid a self (Apply u : es1) (Apply v : es2) = do + reduce (unEl a) >>= \case + Pi a b -> do + w <- antiUnifyArgs pid a u v + antiUnifyElims pid (b `lazyAbsApp` unArg w) (apply self [w]) es1 es2 + _ -> patternViolation +antiUnifyElims _ _ _ _ _ = patternViolation -- trigger maybeGiveUp in antiUnify + +-- | @compareElims pols a v els1 els2@ performs type-directed equality on eliminator spines. +-- @t@ is the type of the head @v@. +compareElims :: forall m. MonadConversion m => [Polarity] -> [IsForced] -> Type -> Term -> [Elim] -> [Elim] -> m () +compareElims pols0 fors0 a v els01 els02 = (catchConstraint (ElimCmp pols0 fors0 a v els01 els02) :: m () -> m ()) $ do + let v1 = applyE v els01 + v2 = applyE v els02 + failure = typeError $ UnequalTerms CmpEq v1 v2 (AsTermsOf a) + -- Andreas, 2013-03-15 since one of the spines is empty, @a@ + -- is the correct type here. + unless (null els01) $ do + reportSDoc "tc.conv.elim" 25 $ "compareElims" $$ do + nest 2 $ vcat + [ "a =" <+> prettyTCM a + , "pols0 (truncated to 10) =" <+> hsep (map prettyTCM $ take 10 pols0) + , "fors0 (truncated to 10) =" <+> hsep (map prettyTCM $ take 10 fors0) + , "v =" <+> prettyTCM v + , "els01 =" <+> prettyTCM els01 + , "els02 =" <+> prettyTCM els02 + ] + case (els01, els02) of + ([] , [] ) -> return () + ([] , Proj{}:_ ) -> failure -- not impossible, see issue 821 + (Proj{} : _, [] ) -> failure -- could be x.p =?= x for projection p + ([] , Apply{} : _) -> failure -- not impossible, see issue 878 + (Apply{} : _, [] ) -> failure + ([] , IApply{} : _) -> failure + (IApply{} : _, [] ) -> failure + (Apply{} : _, Proj{} : _) -> __IMPOSSIBLE__ <$ solveAwakeConstraints' True -- NB: popped up in issue 889 + (Proj{} : _, Apply{} : _) -> __IMPOSSIBLE__ <$ solveAwakeConstraints' True -- but should be impossible (but again in issue 1467) + (IApply{} : _, Proj{} : _) -> __IMPOSSIBLE__ <$ solveAwakeConstraints' True + (Proj{} : _, IApply{} : _) -> __IMPOSSIBLE__ <$ solveAwakeConstraints' True + (IApply{} : _, Apply{} : _) -> __IMPOSSIBLE__ <$ solveAwakeConstraints' True + (Apply{} : _, IApply{} : _) -> __IMPOSSIBLE__ <$ solveAwakeConstraints' True + (e@(IApply x1 y1 r1) : els1, IApply x2 y2 r2 : els2) -> do + reportSDoc "tc.conv.elim" 25 $ "compareElims IApply" + -- Andrea: copying stuff from the Apply case.. + let (pol, pols) = nextPolarity pols0 + ifBlocked a (\ m t -> patternViolation) $ \ _ a -> do + va <- pathView a + reportSDoc "tc.conv.elim.iapply" 60 $ "compareElims IApply" $$ do + nest 2 $ "va =" <+> text (show (isPathType va)) + case va of + PathType s path l bA x y -> do + b <- elInf primInterval + compareWithPol pol (flip compareTerm b) + r1 r2 + -- TODO: compare (x1,x2) and (y1,y2) ? + let r = r1 -- TODO Andrea: do blocking + codom <- el' (pure . unArg $ l) ((pure . unArg $ bA) <@> pure r) + compareElims pols [] codom -- Path non-dependent (codom `lazyAbsApp` unArg arg) + (applyE v [e]) els1 els2 + -- We allow for functions (i : I) -> ... to also be heads of a IApply, + -- because @etaContract@ can produce such terms + OType t@(El _ Pi{}) -> compareElims pols0 fors0 t v (Apply (defaultArg r1) : els1) (Apply (defaultArg r2) : els2) + + OType{} -> patternViolation + + (Apply arg1 : els1, Apply arg2 : els2) -> + (verboseBracket "tc.conv.elim" 20 "compare Apply" :: m () -> m ()) $ do + reportSDoc "tc.conv.elim" 10 $ nest 2 $ vcat + [ "a =" <+> prettyTCM a + , "v =" <+> prettyTCM v + , "arg1 =" <+> prettyTCM arg1 + , "arg2 =" <+> prettyTCM arg2 + ] + reportSDoc "tc.conv.elim" 50 $ nest 2 $ vcat + [ "raw:" + , "a =" <+> pretty a + , "v =" <+> pretty v + , "arg1 =" <+> pretty arg1 + , "arg2 =" <+> pretty arg2 + ] + let (pol, pols) = nextPolarity pols0 + (for, fors) = nextIsForced fors0 + ifBlocked a (\ m t -> patternViolation) $ \ _ a -> do + reportSLn "tc.conv.elim" 90 $ "type is not blocked" + case unEl a of + (Pi (Dom{domInfo = info, unDom = b}) codom) -> do + reportSLn "tc.conv.elim" 90 $ "type is a function type" + mlvl <- tryMaybe primLevel + let freeInCoDom (Abs _ c) = 0 `freeInIgnoringSorts` c + freeInCoDom _ = False + dependent = (Just (unEl b) /= mlvl) && freeInCoDom codom + -- Level-polymorphism (x : Level) -> ... does not count as dependency here + -- NB: we could drop the free variable test and still be sound. + -- It is a trade-off between the administrative effort of + -- creating a blocking and traversing a term for free variables. + -- Apparently, it is believed that checking free vars is cheaper. + -- Andreas, 2013-05-15 + +-- NEW, Andreas, 2013-05-15 + + -- compare arg1 and arg2 + pid <- newProblem_ $ applyModalityToContext info $ + if isForced for then + reportSLn "tc.conv.elim" 90 $ "argument is forced" + else if isIrrelevant info then do + reportSLn "tc.conv.elim" 90 $ "argument is irrelevant" + compareIrrelevant b (unArg arg1) (unArg arg2) + else do + reportSLn "tc.conv.elim" 90 $ "argument has polarity " ++ show pol + compareWithPol pol (flip compareTerm b) + (unArg arg1) (unArg arg2) + -- if comparison got stuck and function type is dependent, block arg + solved <- isProblemSolved pid + reportSLn "tc.conv.elim" 90 $ "solved = " ++ show solved + arg <- if dependent && not solved + then applyModalityToContext info $ do + reportSDoc "tc.conv.elims" 30 $ vcat $ + [ "Trying antiUnify:" + , nest 2 $ "b =" <+> prettyTCM b + , nest 2 $ "arg1 =" <+> prettyTCM arg1 + , nest 2 $ "arg2 =" <+> prettyTCM arg2 + ] + arg <- (arg1 $>) <$> antiUnify pid b (unArg arg1) (unArg arg2) + reportSDoc "tc.conv.elims" 30 $ hang "Anti-unification:" 2 (prettyTCM arg) + reportSDoc "tc.conv.elims" 70 $ nest 2 $ "raw:" <+> pretty arg + return arg + else return arg1 + -- continue, possibly with blocked instantiation + compareElims pols fors (codom `lazyAbsApp` unArg arg) (apply v [arg]) els1 els2 + -- any left over constraints of arg are associated to the comparison + reportSLn "tc.conv.elim" 90 $ "stealing constraints from problem " ++ show pid + stealConstraints pid + {- Stealing solves this issue: + + Does not create enough blocked tc-problems, + see test/fail/DontPrune. + (There are remaining problems which do not show up as yellow.) + Need to find a way to associate pid also to result of compareElims. + -} + a -> do + reportSDoc "impossible" 10 $ + "unexpected type when comparing apply eliminations " <+> prettyTCM a + reportSDoc "impossible" 50 $ "raw type:" <+> pretty a + patternViolation + -- Andreas, 2013-10-22 + -- in case of disabled reductions (due to failing termination check) + -- we might get stuck, so do not crash, but fail gently. + -- __IMPOSSIBLE__ + + -- case: f == f' are projections + (Proj o f : els1, Proj _ f' : els2) + | f /= f' -> typeError . GenericError . show =<< prettyTCM f <+> "/=" <+> prettyTCM f' + | otherwise -> ifBlocked a (\ m t -> patternViolation) $ \ _ a -> do + res <- projectTyped v a o f -- fails only if f is proj.like but parameters cannot be retrieved + case res of + Just (_, u, t) -> do + -- Andreas, 2015-07-01: + -- The arguments following the principal argument of a projection + -- are invariant. (At least as long as we have no explicit polarity + -- annotations.) + compareElims [] [] t u els1 els2 + Nothing -> do + reportSDoc "tc.conv.elims" 30 $ sep + [ text $ "projection " ++ show f + , text "applied to value " <+> prettyTCM v + , text "of unexpected type " <+> prettyTCM a + ] + patternViolation + + +-- | "Compare" two terms in irrelevant position. This always succeeds. +-- However, we can dig for solutions of irrelevant metas in the +-- terms we compare. +-- (Certainly not the systematic solution, that'd be proof search...) +compareIrrelevant :: MonadConversion m => Type -> Term -> Term -> m () +{- 2012-04-02 DontCare no longer present +compareIrrelevant t (DontCare v) w = compareIrrelevant t v w +compareIrrelevant t v (DontCare w) = compareIrrelevant t v w +-} +compareIrrelevant t v0 w0 = do + let v = stripDontCare v0 + w = stripDontCare w0 + reportSDoc "tc.conv.irr" 20 $ vcat + [ "compareIrrelevant" + , nest 2 $ "v =" <+> prettyTCM v + , nest 2 $ "w =" <+> prettyTCM w + ] + reportSDoc "tc.conv.irr" 50 $ vcat + [ nest 2 $ "v =" <+> pretty v + , nest 2 $ "w =" <+> pretty w + ] + try v w $ try w v $ return () + where + try (MetaV x es) w fallback = do + mv <- lookupMeta x + let rel = getMetaRelevance mv + inst = case mvInstantiation mv of + InstV{} -> True + _ -> False + reportSDoc "tc.conv.irr" 20 $ vcat + [ nest 2 $ text $ "rel = " ++ show rel + , nest 2 $ "inst =" <+> pretty inst + ] + if not (isIrrelevant rel) || inst + then fallback + -- Andreas, 2016-08-08, issue #2131: + -- Mining for solutions for irrelevant metas is not definite. + -- Thus, in case of error, leave meta unsolved. + else (assignE DirEq x es w (AsTermsOf t) $ compareIrrelevant t) `catchError` \ _ -> fallback + -- the value of irrelevant or unused meta does not matter + try v w fallback = fallback + +compareWithPol :: MonadConversion m => Polarity -> (Comparison -> a -> a -> m ()) -> a -> a -> m () +compareWithPol Invariant cmp x y = cmp CmpEq x y +compareWithPol Covariant cmp x y = cmp CmpLeq x y +compareWithPol Contravariant cmp x y = cmp CmpLeq y x +compareWithPol Nonvariant cmp x y = return () + +polFromCmp :: Comparison -> Polarity +polFromCmp CmpLeq = Covariant +polFromCmp CmpEq = Invariant + +-- | Type-directed equality on argument lists +-- +compareArgs :: MonadConversion m => [Polarity] -> [IsForced] -> Type -> Term -> Args -> Args -> m () +compareArgs pol for a v args1 args2 = + compareElims pol for a v (map Apply args1) (map Apply args2) + +--------------------------------------------------------------------------- +-- * Types +--------------------------------------------------------------------------- + +-- | Equality on Types +compareType :: MonadConversion m => Comparison -> Type -> Type -> m () +compareType cmp ty1@(El s1 a1) ty2@(El s2 a2) = + workOnTypes $ + verboseBracket "tc.conv.type" 20 "compareType" $ do + reportSDoc "tc.conv.type" 50 $ vcat + [ "compareType" <+> sep [ prettyTCM ty1 <+> prettyTCM cmp + , prettyTCM ty2 ] + , hsep [ " sorts:", prettyTCM s1, " and ", prettyTCM s2 ] + ] + compareAs cmp AsTypes a1 a2 + unlessM ((optCumulativity <$> pragmaOptions) `or2M` + (not . optCompareSorts <$> pragmaOptions)) $ + compareSort CmpEq s1 s2 + return () + +leqType :: MonadConversion m => Type -> Type -> m () +leqType = compareType CmpLeq + +-- | @coerce v a b@ coerces @v : a@ to type @b@, returning a @v' : b@ +-- with maybe extra hidden applications or hidden abstractions. +-- +-- In principle, this function can host coercive subtyping, but +-- currently it only tries to fix problems with hidden function types. +-- +coerce :: (MonadConversion m, MonadTCM m) => Comparison -> Term -> Type -> Type -> m Term +coerce cmp v t1 t2 = blockTerm t2 $ do + verboseS "tc.conv.coerce" 10 $ do + (a1,a2) <- reify (t1,t2) + let dbglvl = if isSet a1 && isSet a2 then 50 else 10 + reportSDoc "tc.conv.coerce" dbglvl $ + "coerce" <+> vcat + [ "term v =" <+> prettyTCM v + , "from type t1 =" <+> prettyTCM a1 + , "to type t2 =" <+> prettyTCM a2 + , "comparison =" <+> prettyTCM cmp + ] + reportSDoc "tc.conv.coerce" 70 $ + "coerce" <+> vcat + [ "term v =" <+> pretty v + , "from type t1 =" <+> pretty t1 + , "to type t2 =" <+> pretty t2 + , "comparison =" <+> pretty cmp + ] + -- v <$ do workOnTypes $ leqType t1 t2 + -- take off hidden/instance domains from t1 and t2 + TelV tel1 b1 <- telViewUpTo' (-1) notVisible t1 + TelV tel2 b2 <- telViewUpTo' (-1) notVisible t2 + let n = size tel1 - size tel2 + -- the crude solution would be + -- v' = λ {tel2} → v {tel1} + -- however, that may introduce unneccessary many function types + -- If n > 0 and b2 is not blocked, it is safe to + -- insert n many hidden args + if n <= 0 then fallback else do + ifBlocked b2 (\ _ _ -> fallback) $ \ _ _ -> do + (args, t1') <- implicitArgs n notVisible t1 + let v' = v `apply` args + v' <$ coerceSize (compareType cmp) v' t1' t2 + where + fallback = v <$ coerceSize (compareType cmp) v t1 t2 + +-- | Account for situations like @k : (Size< j) <= (Size< k + 1)@ +-- +-- Actually, the semantics is +-- @(Size<= k) ∩ (Size< j) ⊆ rhs@ +-- which gives a disjunctive constraint. Mmmh, looks like stuff +-- TODO. +-- +-- For now, we do a cheap heuristics. +-- +coerceSize :: MonadConversion m => (Type -> Type -> m ()) -> Term -> Type -> Type -> m () +coerceSize leqType v t1 t2 = verboseBracket "tc.conv.size.coerce" 45 "coerceSize" $ + workOnTypes $ do + reportSDoc "tc.conv.size.coerce" 70 $ + "coerceSize" <+> vcat + [ "term v =" <+> pretty v + , "from type t1 =" <+> pretty t1 + , "to type t2 =" <+> pretty t2 + ] + let fallback = leqType t1 t2 + done = caseMaybeM (isSizeType =<< reduce t1) fallback $ \ _ -> return () + -- Andreas, 2015-07-22, Issue 1615: + -- If t1 is a meta and t2 a type like Size< v2, we need to make sure we do not miss + -- the constraint v < v2! + caseMaybeM (isSizeType =<< reduce t2) fallback $ \ b2 -> do + -- Andreas, 2017-01-20, issue #2329: + -- If v is not a size suitable for the solver, like a neutral term, + -- we can only rely on the type. + mv <- sizeMaxView v + if any (\case{ DOtherSize{} -> True; _ -> False }) mv then fallback else do + -- Andreas, 2015-02-11 do not instantiate metas here (triggers issue 1203). + unlessM (tryConversion $ dontAssignMetas $ leqType t1 t2) $ do + -- A (most probably weaker) alternative is to just check syn.eq. + -- ifM (snd <$> checkSyntacticEquality t1 t2) (return v) $ {- else -} do + reportSDoc "tc.conv.size.coerce" 20 $ "coercing to a size type" + case b2 of + -- @t2 = Size@. We are done! + BoundedNo -> done + -- @t2 = Size< v2@ + BoundedLt v2 -> do + sv2 <- sizeView v2 + case sv2 of + SizeInf -> done + OtherSize{} -> do + -- Andreas, 2014-06-16: + -- Issue 1203: For now, just treat v < v2 as suc v <= v2 + -- TODO: Need proper < comparison + vinc <- sizeSuc 1 v + compareSizes CmpLeq vinc v2 + done + -- @v2 = a2 + 1@: In this case, we can try @v <= a2@ + SizeSuc a2 -> do + compareSizes CmpLeq v a2 + done -- to pass Issue 1136 + +--------------------------------------------------------------------------- +-- * Sorts and levels +--------------------------------------------------------------------------- + +compareLevel :: MonadConversion m => Comparison -> Level -> Level -> m () +compareLevel CmpLeq u v = leqLevel u v +compareLevel CmpEq u v = equalLevel u v + +compareSort :: MonadConversion m => Comparison -> Sort -> Sort -> m () +compareSort CmpEq = equalSort +compareSort CmpLeq = leqSort + +-- | Check that the first sort is less or equal to the second. +-- +-- We can put @SizeUniv@ below @Inf@, but otherwise, it is +-- unrelated to the other universes. +-- +leqSort :: forall m. MonadConversion m => Sort -> Sort -> m () +leqSort s1 s2 = (catchConstraint (SortCmp CmpLeq s1 s2) :: m () -> m ()) $ do + (s1,s2) <- reduce (s1,s2) + let postpone = addConstraint (SortCmp CmpLeq s1 s2) + no = typeError $ NotLeqSort s1 s2 + yes = return () + synEq = ifNotM (optSyntacticEquality <$> pragmaOptions) postpone $ do + ((s1,s2) , equal) <- SynEq.checkSyntacticEquality s1 s2 + if | equal -> yes + | otherwise -> postpone + reportSDoc "tc.conv.sort" 30 $ + sep [ "leqSort" + , nest 2 $ fsep [ prettyTCM s1 <+> "=<" + , prettyTCM s2 ] + ] + propEnabled <- isPropEnabled + + let fvsRHS = (`IntSet.member` allFreeVars s2) + badRigid <- s1 `rigidVarsNotContainedIn` fvsRHS + + case (s1, s2) of + -- Andreas, 2018-09-03: crash on dummy sort + (DummyS s, _) -> impossibleSort s + (_, DummyS s) -> impossibleSort s + + -- The most basic rule: @Set l =< Set l'@ iff @l =< l'@ + (Type a , Type b ) -> leqLevel a b + + -- Likewise for @Prop@ + (Prop a , Prop b ) -> leqLevel a b + + -- @Prop l@ is below @Set l@ + (Prop a , Type b ) -> leqLevel a b + (Type a , Prop b ) -> no + + -- Setω is the top sort + (_ , Inf ) -> yes + (Inf , _ ) -> equalSort s1 s2 + + -- @SizeUniv@ and @Prop0@ are bottom sorts. + -- So is @Set0@ if @Prop@ is not enabled. + (_ , SizeUniv) -> equalSort s1 s2 + (_ , Prop (Max 0 [])) -> equalSort s1 s2 + (_ , Type (Max 0 [])) + | not propEnabled -> equalSort s1 s2 + + -- SizeUniv is unrelated to any @Set l@ or @Prop l@ + (SizeUniv, Type{} ) -> no + (SizeUniv, Prop{} ) -> no + + -- If the first sort rigidly depends on a variable and the second + -- sort does not mention this variable, the second sort must be Inf. + (_ , _ ) | badRigid -> equalSort s2 Inf + + -- This shouldn't be necessary + (UnivSort Inf , UnivSort Inf) -> yes + + -- PiSort, FunSort, UnivSort and MetaS might reduce once we instantiate + -- more metas, so we postpone. + (PiSort{}, _ ) -> synEq + (_ , PiSort{}) -> synEq + (FunSort{}, _ ) -> synEq + (_ , FunSort{}) -> synEq + (UnivSort{}, _ ) -> synEq + (_ , UnivSort{}) -> synEq + (MetaS{} , _ ) -> synEq + (_ , MetaS{} ) -> synEq + + -- DefS are postulated sorts, so they do not reduce. + (DefS{} , _ ) -> synEq + (_ , DefS{}) -> synEq + + where + impossibleSort s = do + reportS "impossible" 10 + [ "leqSort: found dummy sort with description:" + , s + ] + __IMPOSSIBLE__ + +leqLevel :: MonadConversion m => Level -> Level -> m () +leqLevel a b = do + reportSDoc "tc.conv.nat" 30 $ + "compareLevel" <+> + sep [ prettyTCM a <+> "=<" + , prettyTCM b ] + -- Andreas, 2015-12-28 Issue 1757 + -- We normalize both sides to make the syntactic equality check (==) stronger. + -- See case for `same term` below. + a <- normalise a + b <- normalise b + leqView a b + where + -- Andreas, 2016-09-28 + -- If we have to postpone a constraint, then its simplified form! + leqView :: MonadConversion m => Level -> Level -> m () + leqView a b = catchConstraint (LevelCmp CmpLeq a b) $ do + reportSDoc "tc.conv.level" 30 $ + "compareLevelView" <+> + sep [ pretty a <+> "=<" + , pretty b ] + cumulativity <- optCumulativity <$> pragmaOptions + reportSDoc "tc.conv.level" 40 $ + "compareLevelView" <+> + sep [ prettyList_ (map (pretty . unSingleLevel) $ NonEmpty.toList $ levelMaxView a) + , "=<" + , prettyList_ (map (pretty . unSingleLevel) $ NonEmpty.toList $ levelMaxView b) + ] + wrap $ case (levelMaxView a, levelMaxView b) of + + -- same term + _ | a == b -> ok + + -- 0 ≤ any + (SingleClosed 0 :| [] , _) -> ok + + -- any ≤ 0 + (as , SingleClosed 0 :| []) -> + sequence_ [ equalLevel (unSingleLevel a') (ClosedLevel 0) | a' <- NonEmpty.toList as ] + + -- closed ≤ closed + (SingleClosed m :| [], SingleClosed n :| []) -> if m <= n then ok else notok + + -- closed ≤ b + (SingleClosed m :| [] , _) + | m <= levelLowerBound b -> ok + + -- as ≤ neutral/closed + (as, bs) + | all neutralOrClosed bs , levelLowerBound a > levelLowerBound b -> notok + + -- ⊔ as ≤ single + (as@(_:|_:_), b :| []) -> + sequence_ [ leqView (unSingleLevel a') (unSingleLevel b) | a' <- NonEmpty.toList as ] + + -- reduce constants + (as, bs) + | let minN = min (fst $ levelPlusView a) (fst $ levelPlusView b) + a' = fromMaybe __IMPOSSIBLE__ $ subLevel minN a + b' = fromMaybe __IMPOSSIBLE__ $ subLevel minN b + , minN > 0 -> leqView a' b' + + -- remove subsumed + -- Andreas, 2014-04-07: This is ok if we do not go back to equalLevel + (as, bs) + | (subsumed@(_:_) , as') <- List.partition isSubsumed (NonEmpty.toList as) + -> leqView (unSingleLevels as') b + where + isSubsumed a = any (`subsumes` a) (NonEmpty.toList bs) + + subsumes :: SingleLevel -> SingleLevel -> Bool + subsumes (SingleClosed m) (SingleClosed n) = m >= n + subsumes (SinglePlus (Plus m _)) (SingleClosed n) = m >= n + subsumes (SinglePlus (Plus m a)) (SinglePlus (Plus n b)) = a == b && m >= n + subsumes _ _ = False + + -- as ≤ _l x₁ .. xₙ ⊔ bs + -- We can solve _l := λ x₁ .. xₙ -> as ⊔ (_l' x₁ .. xₙ) + -- (where _l' is a new metavariable) + (as , bs) + | cumulativity + , Just (mb@(MetaLevel x es) , bs') <- singleMetaView (NonEmpty.toList bs) + , null bs' || noMetas (Level a , unSingleLevels bs') -> do + mv <- lookupMeta x + -- Jesper, 2019-10-13: abort if this is an interaction + -- meta or a generalizable meta + abort <- (isJust <$> isInteractionMeta x) `or2M` + ((== YesGeneralize) <$> isGeneralizableMeta x) + if | abort -> postpone + | otherwise -> do + x' <- case mvJudgement mv of + IsSort{} -> __IMPOSSIBLE__ + HasType _ cmp t -> do + TelV tel t' <- telView t + newMeta Instantiable (mvInfo mv) normalMetaPriority (idP $ size tel) $ HasType () cmp t + reportSDoc "tc.conv.level" 20 $ fsep + [ "attempting to solve" , prettyTCM (MetaV x es) , "to the maximum of" + , prettyTCM (Level a) , "and the fresh meta" , prettyTCM (MetaV x' es) + ] + equalLevel (atomicLevel mb) $ levelLub a (atomicLevel $ MetaLevel x' es) + + + -- Andreas, 2016-09-28: This simplification loses the solution lzero. + -- Thus, it is invalid. + -- See test/Succeed/LevelMetaLeqNeutralLevel.agda. + -- -- [a] ≤ [neutral] + -- ([a@(Plus n _)], [b@(Plus m NeutralLevel{})]) + -- | m == n -> equalLevel' (Max [a]) (Max [b]) + -- -- Andreas, 2014-04-07: This call to equalLevel is ok even if we removed + -- -- subsumed terms from the lhs. + + -- anything else + _ | noMetas (Level a , Level b) -> notok + | otherwise -> postpone + where + ok = return () + notok = unlessM typeInType $ typeError $ NotLeqSort (Type a) (Type b) + postpone = patternViolation + + wrap m = m `catchError` \case + TypeError{} -> notok + err -> throwError err + + neutralOrClosed (SingleClosed _) = True + neutralOrClosed (SinglePlus (Plus _ NeutralLevel{})) = True + neutralOrClosed _ = False + + -- Is there exactly one @MetaLevel@ in the list of single levels? + singleMetaView :: [SingleLevel] -> Maybe (LevelAtom, [SingleLevel]) + singleMetaView (SinglePlus (Plus 0 l@(MetaLevel m es)) : ls) + | all (not . isMetaLevel) ls = Just (l,ls) + singleMetaView (l : ls) + | not $ isMetaLevel l = second (l:) <$> singleMetaView ls + singleMetaView _ = Nothing + + isMetaLevel :: SingleLevel -> Bool + isMetaLevel (SinglePlus (Plus _ MetaLevel{})) = True + isMetaLevel (SinglePlus (Plus _ UnreducedLevel{})) = __IMPOSSIBLE__ + isMetaLevel _ = False + +equalLevel :: MonadConversion m => Level -> Level -> m () +equalLevel a b = do + -- Andreas, 2013-10-31 Use normalization to make syntactic equality stronger + (a, b) <- normalise (a, b) + equalLevel' a b + +-- | Precondition: levels are 'normalise'd. +equalLevel' :: forall m. MonadConversion m => Level -> Level -> m () +equalLevel' a b = do + reportSDoc "tc.conv.level" 50 $ sep [ "equalLevel", nest 2 $ parens $ pretty a, nest 2 $ parens $ pretty b ] + -- Andreas, 2013-10-31 remove common terms (that don't contain metas!) + -- THAT's actually UNSOUND when metas are instantiated, because + -- max a b == max a c does not imply b == c + -- as <- return $ Set.fromList $ closed0 as + -- bs <- return $ Set.fromList $ closed0 bs + -- let cs = Set.filter (not . hasMeta) $ Set.intersection as bs + -- as <- return $ Set.toList $ as Set.\\ cs + -- bs <- return $ Set.toList $ bs Set.\\ cs + + reportSDoc "tc.conv.level" 40 $ + sep [ "equalLevel" + , vcat [ nest 2 $ sep [ prettyTCM a <+> "==" + , prettyTCM b + ] + ] + ] + + -- Jesper, 2014-02-02 remove terms that certainly do not contribute + -- to the maximum + let (a',b') = removeSubsumed a b + reportSDoc "tc.conv.level" 50 $ + sep [ "equalLevel (w/o subsumed)" + , vcat [ nest 2 $ sep [ prettyTCM a' <+> "==" + , prettyTCM b' + ] + ] + ] + + let as = levelMaxView a' + bs = levelMaxView b' + reportSDoc "tc.conv.level" 50 $ + sep [ text "equalLevel" + , vcat [ nest 2 $ sep [ prettyList_ (map (pretty . unSingleLevel) $ NonEmpty.toList $ as) + , "==" + , prettyList_ (map (pretty . unSingleLevel) $ NonEmpty.toList $ bs) + ] + ] + ] + + reportSDoc "tc.conv.level" 80 $ + sep [ text "equalLevel" + , vcat [ nest 2 $ sep [ prettyList_ (map (text . show . unSingleLevel) $ NonEmpty.toList $ as) + , "==" + , prettyList_ (map (text . show . unSingleLevel) $ NonEmpty.toList $ bs) + ] + ] + ] + + catchConstraint (LevelCmp CmpEq a b) $ case (as, bs) of + + -- equal levels + _ | a == b -> ok + + -- closed == closed + (SingleClosed m :| [], SingleClosed n :| []) + | m == n -> ok + | otherwise -> notok + + -- closed == neutral + (SingleClosed m :| [] , bs) | any isNeutral bs -> notok + (as , SingleClosed n :| []) | any isNeutral as -> notok + + -- closed == b + (SingleClosed m :| [] , _) | m < levelLowerBound b -> notok + (_ , SingleClosed n :| []) | n < levelLowerBound a -> notok + + -- 0 == a ⊔ b + (SingleClosed 0 :| [] , bs@(_:|_:_)) -> + sequence_ [ equalLevel' (ClosedLevel 0) (unSingleLevel b') | b' <- NonEmpty.toList bs ] + (as@(_:|_:_) , SingleClosed 0 :| []) -> + sequence_ [ equalLevel' (unSingleLevel a') (ClosedLevel 0) | a' <- NonEmpty.toList as ] + + -- meta == any + (SinglePlus (Plus k (MetaLevel x as)) :| [] , bs) + | any (isThisMeta x) bs -> postpone + (as , SinglePlus (Plus k (MetaLevel x bs)) :| []) + | any (isThisMeta x) as -> postpone + (SinglePlus (Plus k (MetaLevel x as')) :| [] , SinglePlus (Plus l (MetaLevel y bs')) :| []) + -- there is only a potential choice when k == l + | k == l -> if + | y < x -> meta x as' $ atomicLevel $ MetaLevel y bs' + | otherwise -> meta y bs' $ atomicLevel $ MetaLevel x as' + (SinglePlus (Plus k (MetaLevel x as')) :| [] , _) + | Just b' <- subLevel k b -> meta x as' b' + (_ , SinglePlus (Plus l (MetaLevel y bs')) :| []) + | Just a' <- subLevel l a -> meta y bs' a' + + -- a' ⊔ b == b + _ | Just a' <- levelMaxDiff a b + , b /= ClosedLevel 0 -> leqLevel a' b + + -- a == b' ⊔ a + _ | Just b' <- levelMaxDiff b a + , a /= ClosedLevel 0 -> leqLevel b' a + + -- neutral/closed == neutral/closed + (as , bs) + | all isNeutralOrClosed (NonEmpty.toList as ++ NonEmpty.toList bs) + -- Andreas, 2013-10-31: There could be metas in neutral levels (see Issue 930). + -- Should not we postpone there as well? Yes! + , not (any hasMeta (NonEmpty.toList as ++ NonEmpty.toList bs)) + , length as == length bs -> do + reportSLn "tc.conv.level" 60 $ "equalLevel: all are neutral or closed" + zipWithM_ ((===) `on` levelTm . unSingleLevel) (NonEmpty.toList as) (NonEmpty.toList bs) + + -- more cases? + _ | noMetas (Level a , Level b) -> notok + | otherwise -> postpone + + where + a === b = unlessM typeInType $ do + lvl <- levelType + equalAtom (AsTermsOf lvl) a b + + ok = return () + notok = unlessM typeInType notOk + notOk = typeError $ UnequalLevel CmpEq a b + postpone = do + reportSDoc "tc.conv.level" 30 $ hang "postponing:" 2 $ hang (pretty a <+> "==") 0 (pretty b) + patternViolation + + -- perform assignment (MetaLevel x as) := b + meta x as b = do + reportSLn "tc.meta.level" 30 $ "Assigning meta level" + reportSDoc "tc.meta.level" 50 $ "meta" <+> sep [prettyList $ map pretty as, pretty b] + lvl <- levelType + assignE DirEq x as (levelTm b) (AsTermsOf lvl) (===) -- fallback: check equality as atoms + + -- Make sure to give a sensible error message + wrap m = m `catchError` \case + TypeError{} -> notok + err -> throwError err + + isNeutral (SinglePlus (Plus _ NeutralLevel{})) = True + isNeutral _ = False + + isNeutralOrClosed (SingleClosed _) = True + isNeutralOrClosed (SinglePlus (Plus _ NeutralLevel{})) = True + isNeutralOrClosed _ = False + + hasMeta (SinglePlus a) = case a of + Plus _ MetaLevel{} -> True + Plus _ (BlockedLevel _ v) -> isJust $ firstMeta v + Plus _ (NeutralLevel _ v) -> isJust $ firstMeta v + Plus _ (UnreducedLevel v) -> isJust $ firstMeta v + hasMeta (SingleClosed _) = False + + isThisMeta x (SinglePlus (Plus _ (MetaLevel y _))) = x == y + isThisMeta _ _ = False + + removeSubsumed a b = + let as = NonEmpty.toList $ levelMaxView a + bs = NonEmpty.toList $ levelMaxView b + a' = unSingleLevels $ filter (not . (`isStrictlySubsumedBy` bs)) as + b' = unSingleLevels $ filter (not . (`isStrictlySubsumedBy` as)) bs + in (a',b') + + x `isStrictlySubsumedBy` ys = any (`strictlySubsumes` x) ys + + SingleClosed m `strictlySubsumes` SingleClosed n = m > n + SinglePlus (Plus m a) `strictlySubsumes` SingleClosed n = m > n + SinglePlus (Plus m a) `strictlySubsumes` SinglePlus (Plus n b) = a == b && m > n + _ `strictlySubsumes` _ = False + + +-- | Check that the first sort equal to the second. +equalSort :: forall m. MonadConversion m => Sort -> Sort -> m () +equalSort s1 s2 = do + catchConstraint (SortCmp CmpEq s1 s2) $ do + (s1,s2) <- reduce (s1,s2) + let yes = return () + no = typeError $ UnequalSorts s1 s2 + + reportSDoc "tc.conv.sort" 30 $ sep + [ "equalSort" + , vcat [ nest 2 $ fsep [ prettyTCM s1 <+> "==" + , prettyTCM s2 ] + , nest 2 $ fsep [ pretty s1 <+> "==" + , pretty s2 ] + ] + ] + + propEnabled <- isPropEnabled + typeInTypeEnabled <- typeInType + + case (s1, s2) of + + -- Andreas, 2018-09-03: crash on dummy sort + (DummyS s, _) -> impossibleSort s + (_, DummyS s) -> impossibleSort s + + -- one side is a meta sort: try to instantiate + -- In case both sides are meta sorts, instantiate the + -- bigger (i.e. more recent) one. + (MetaS x es , MetaS y es') + | x == y -> synEq s1 s2 + | x < y -> meta y es' s1 + | otherwise -> meta x es s2 + (MetaS x es , _ ) -> meta x es s2 + (_ , MetaS x es ) -> meta x es s1 + + -- diagonal cases for rigid sorts + (Type a , Type b ) -> equalLevel a b `catchInequalLevel` no + (SizeUniv , SizeUniv ) -> yes + (Prop a , Prop b ) -> equalLevel a b `catchInequalLevel` no + (Inf , Inf ) -> yes + + -- if --type-in-type is enabled, Setω is equal to any Set ℓ (see #3439) + (Type{} , Inf ) + | typeInTypeEnabled -> yes + (Inf , Type{} ) + | typeInTypeEnabled -> yes + + -- equating @PiSort a b@ to another sort + (s1 , PiSort a b) -> piSortEquals s1 a b + (PiSort a b , s2) -> piSortEquals s2 a b + + -- equating @FunSort a b@ to another sort + (s1 , FunSort a b) -> funSortEquals s1 a b + (FunSort a b , s2) -> funSortEquals s2 a b + + -- equating @UnivSort s@ to another sort + (s1 , UnivSort s2) -> univSortEquals s1 s2 + (UnivSort s1 , s2 ) -> univSortEquals s2 s1 + + -- postulated sorts can only be equal if they have the same head + (DefS d es , DefS d' es') + | d == d' -> synEq s1 s2 + | otherwise -> no + + -- any other combinations of sorts are not equal + (_ , _ ) -> no + + where + -- perform assignment (MetaS x es) := s + meta :: MetaId -> [Elim' Term] -> Sort -> m () + meta x es s = do + reportSLn "tc.meta.sort" 30 $ "Assigning meta sort" + reportSDoc "tc.meta.sort" 50 $ "meta" <+> sep [pretty x, prettyList $ map pretty es, pretty s] + assignE DirEq x es (Sort s) AsTypes __IMPOSSIBLE__ + + -- fall back to syntactic equality check, postpone if it fails + synEq :: Sort -> Sort -> m () + synEq s1 s2 = do + let postpone = addConstraint $ SortCmp CmpEq s1 s2 + doSynEq <- optSyntacticEquality <$> pragmaOptions + if | doSynEq -> do + ((s1,s2) , equal) <- SynEq.checkSyntacticEquality s1 s2 + if | equal -> return () + | otherwise -> postpone + | otherwise -> postpone + + set0 = mkType 0 + prop0 = mkProp 0 + + -- Equate a sort @s1@ to @univSort s2@ + -- Precondition: @s1@ and @univSort s2@ are already reduced. + univSortEquals :: Sort -> Sort -> m () + univSortEquals s1 s2 = do + reportSDoc "tc.conv.sort" 35 $ vcat + [ "univSortEquals" + , " s1 =" <+> prettyTCM s1 + , " s2 =" <+> prettyTCM s2 + ] + let no = typeError $ UnequalSorts s1 (UnivSort s2) + case s1 of + -- @Set l1@ is the successor sort of either @Set l2@ or + -- @Prop l2@ where @l1 == lsuc l2@. + Type l1 -> do + propEnabled <- isPropEnabled + -- @s2@ is definitely not @Inf@ or @SizeUniv@ + if | Inf <- s2 -> no + | SizeUniv <- s2 -> no + -- If @Prop@ is not used, then @s2@ must be of the form + -- @Set l2@ + | not propEnabled -> do + l2 <- case subLevel 1 l1 of + Just l2 -> return l2 + Nothing -> do + l2 <- newLevelMeta + equalLevel l1 (levelSuc l2) + return l2 + equalSort (Type l2) s2 + -- Otherwise we postpone + | otherwise -> synEq (Type l1) (UnivSort s2) + -- @Setω@ is only a successor sort if --type-in-type or + -- --omega-in-omega is enabled. + Inf -> do + infInInf <- (optOmegaInOmega <$> pragmaOptions) `or2M` typeInType + if | infInInf -> equalSort Inf s2 + | otherwise -> no + -- @Prop l@ and @SizeUniv@ are not successor sorts + Prop{} -> no + SizeUniv{} -> no + -- Anything else: postpone + _ -> synEq s1 (UnivSort s2) + + + -- Equate a sort @s@ to @piSort a b@ + -- Precondition: @s@ and @piSort a b@ are already reduced. + piSortEquals :: Sort -> Dom Type -> Abs Sort -> m () + piSortEquals s a NoAbs{} = __IMPOSSIBLE__ + piSortEquals s a bAbs@(Abs x b) = do + reportSDoc "tc.conv.sort" 35 $ vcat + [ "piSortEquals" + , " s =" <+> prettyTCM s + , " a =" <+> prettyTCM a + , " b =" <+> addContext (x,a) (prettyTCM b) + ] + propEnabled <- isPropEnabled + -- If @b@ is dependent, then @piSort a b@ computes to + -- @Setω@. Hence, if @s@ is definitely not @Setω@, then @b@ + -- cannot be dependent. + if | definitelyNotInf s -> do + -- We force @b@ to be non-dependent by unifying it with + -- a fresh meta that does not depend on @x : a@ + b' <- newSortMeta + addContext (x,a) $ equalSort b (raise 1 b') + funSortEquals s (getSort a) b' + -- Otherwise: postpone + | otherwise -> synEq (PiSort a bAbs) s + + -- Equate a sort @s@ to @funSort s1 s2@ + -- Precondition: @s@ and @funSort s1 s2@ are already reduced + funSortEquals :: Sort -> Sort -> Sort -> m () + funSortEquals s0 s1 s2 = do + reportSDoc "tc.conv.sort" 35 $ vcat + [ "funSortEquals" + , " s0 =" <+> prettyTCM s0 + , " s1 =" <+> prettyTCM s1 + , " s2 =" <+> prettyTCM s2 + ] + propEnabled <- isPropEnabled + sizedTypesEnabled <- sizedTypesOption + case s0 of + -- If @Setω == funSort s1 s2@, then either @s1@ or @s2@ must + -- be @Setω@. + Inf | definitelyNotInf s1 && definitelyNotInf s2 -> do + typeError $ UnequalSorts s0 (FunSort s1 s2) + | definitelyNotInf s1 -> equalSort Inf s2 + | definitelyNotInf s2 -> equalSort Inf s1 + | otherwise -> synEq s0 (FunSort s1 s2) + -- If @Set l == funSort s1 s2@, then @s2@ must be of the + -- form @Set l2@. @s1@ can be one of @Set l1@, @Prop l1@, or + -- @SizeUniv@. + Type l -> do + l2 <- forceType s2 + -- We must have @l2 =< l@, this might help us to solve + -- more constraints (in particular when @l == 0@). + leqLevel l2 l + -- Jesper, 2019-12-27: SizeUniv is disabled at the moment. + if | {- sizedTypesEnabled || -} propEnabled -> case funSort' s1 (Type l2) of + -- If the work we did makes the @funSort@ compute, + -- continue working. + Just s -> equalSort (Type l) s + -- Otherwise: postpone + Nothing -> synEq (Type l) (FunSort s1 $ Type l2) + -- If both Prop and sized types are disabled, only the + -- case @s1 == Set l1@ remains. + | otherwise -> do + l1 <- forceType s1 + equalLevel l (levelLub l1 l2) + -- If @Prop l == funSort s1 s2@, then @s2@ must be of the + -- form @Prop l2@, and @s1@ can be one of @Set l1@, Prop + -- l1@, or @SizeUniv@. + Prop l -> do + l2 <- forceProp s2 + leqLevel l2 l + case funSort' s1 (Prop l2) of + -- If the work we did makes the @funSort@ compute, + -- continue working. + Just s -> equalSort (Prop l) s + -- Otherwise: postpone + Nothing -> synEq (Prop l) (FunSort s1 $ Prop l2) + -- We have @SizeUniv == funSort s1 s2@ iff @s2 == SizeUniv@ + SizeUniv -> equalSort SizeUniv s2 + -- Anything else: postpone + _ -> synEq s0 (FunSort s1 s2) + + -- check if the given sort @s0@ is a (closed) bottom sort + -- i.e. @piSort a b == s0@ implies @b == s0@. + isBottomSort :: Bool -> Sort -> Bool + isBottomSort propEnabled (Prop (ClosedLevel 0)) = True + isBottomSort propEnabled (Type (ClosedLevel 0)) = not propEnabled + isBottomSort propEnabled _ = False + + definitelyNotInf :: Sort -> Bool + definitelyNotInf = \case + Inf -> False + Type{} -> True + Prop{} -> True + SizeUniv -> True + PiSort{} -> False + FunSort{} -> False + UnivSort{} -> False + MetaS{} -> False + DefS{} -> False + DummyS{} -> False + + forceType :: Sort -> m Level + forceType (Type l) = return l + forceType s = do + l <- newLevelMeta + equalSort s (Type l) + return l + + forceProp :: Sort -> m Level + forceProp (Prop l) = return l + forceProp s = do + l <- newLevelMeta + equalSort s (Prop l) + return l + + impossibleSort s = do + reportS "impossible" 10 + [ "equalSort: found dummy sort with description:" + , s + ] + __IMPOSSIBLE__ + + catchInequalLevel m fail = m `catchError` \case + TypeError{} -> fail + err -> throwError err + + +-- -- This should probably represent face maps with a more precise type +-- toFaceMaps :: Term -> TCM [[(Int,Term)]] +-- toFaceMaps t = do +-- view <- intervalView' +-- iz <- primIZero +-- io <- primIOne +-- ineg <- (\ q t -> Def q [Apply $ Arg defaultArgInfo t]) <$> fromMaybe __IMPOSSIBLE__ <$> getPrimitiveName' "primINeg" + +-- let f IZero = mzero +-- f IOne = return [] +-- f (IMin x y) = do xs <- (f . view . unArg) x; ys <- (f . view . unArg) y; return (xs ++ ys) +-- f (IMax x y) = msum $ map (f . view . unArg) [x,y] +-- f (INeg x) = map (id -*- not) <$> (f . view . unArg) x +-- f (OTerm (Var i [])) = return [(i,True)] +-- f (OTerm _) = return [] -- what about metas? we should suspend? maybe no metas is a precondition? +-- isConsistent xs = all (\ xs -> length xs == 1) . map nub . Map.elems $ xs -- optimize by not doing generate + filter +-- as = map (map (id -*- head) . Map.toAscList) . filter isConsistent . map (Map.fromListWith (++) . map (id -*- (:[]))) $ (f (view t)) +-- xs <- mapM (mapM (\ (i,b) -> (,) i <$> intervalUnview (if b then IOne else IZero))) as +-- return xs + +forallFaceMaps :: MonadConversion m => Term -> (Map.Map Int Bool -> MetaId -> Term -> m a) -> (Substitution -> m a) -> m [a] +forallFaceMaps t kb k = do + reportSDoc "conv.forall" 20 $ + fsep ["forallFaceMaps" + , prettyTCM t + ] + as <- decomposeInterval t + boolToI <- do + io <- primIOne + iz <- primIZero + return (\b -> if b then io else iz) + forM as $ \ (ms,ts) -> do + ifBlockeds ts (kb ms) $ \ _ _ -> do + let xs = map (id -*- boolToI) $ Map.toAscList ms + cxt <- getContext + reportSDoc "conv.forall" 20 $ + fsep ["substContextN" + , prettyTCM cxt + , prettyTCM xs + ] + (cxt',sigma) <- substContextN cxt xs + resolved <- forM xs (\ (i,t) -> (,) <$> lookupBV i <*> return (applySubst sigma t)) + updateContext sigma (const cxt') $ + addBindings resolved $ do + cl <- buildClosure () + tel <- getContextTelescope + m <- currentModule + sub <- getModuleParameterSub m + reportS "conv.forall" 10 + [ replicate 10 '-' + , show (envCurrentModule $ clEnv cl) + , show (envLetBindings $ clEnv cl) + , show tel -- (toTelescope $ envContext $ clEnv cl) + , show sigma + , show m + , show sub + ] + k sigma + where + -- TODO Andrea: inefficient because we try to reduce the ts which we know are in whnf + ifBlockeds ts blocked unblocked = do + and <- getPrimitiveTerm "primIMin" + io <- primIOne + let t = foldr (\ x r -> and `apply` [argN x,argN r]) io ts + ifBlocked t blocked unblocked + addBindings [] m = m + addBindings ((Dom{domInfo = info,unDom = (nm,ty)},t):bs) m = addLetBinding info nm t ty (addBindings bs m) + + substContextN :: MonadConversion m => Context -> [(Int,Term)] -> m (Context , Substitution) + substContextN c [] = return (c, idS) + substContextN c ((i,t):xs) = do + (c', sigma) <- substContext i t c + (c'', sigma') <- substContextN c' (map (subtract 1 -*- applySubst sigma) xs) + return (c'', applySubst sigma' sigma) + + + -- assumes the term can be typed in the shorter telescope + -- the terms we get from toFaceMaps are closed. + substContext :: MonadConversion m => Int -> Term -> Context -> m (Context , Substitution) + substContext i t [] = __IMPOSSIBLE__ + substContext i t (x:xs) | i == 0 = return $ (xs , singletonS 0 t) + substContext i t (x:xs) | i > 0 = do + reportSDoc "conv.forall" 20 $ + fsep ["substContext" + , text (show (i-1)) + , prettyTCM t + , prettyTCM xs + ] + (c,sigma) <- substContext (i-1) t xs + let e = applySubst sigma x + return (e:c, liftS 1 sigma) + substContext i t (x:xs) = __IMPOSSIBLE__ + +compareInterval :: MonadConversion m => Comparison -> Type -> Term -> Term -> m () +compareInterval cmp i t u = do + reportSDoc "tc.conv.interval" 15 $ + sep [ "{ compareInterval" <+> prettyTCM t <+> "=" <+> prettyTCM u ] + tb <- reduceB t + ub <- reduceB u + let t = ignoreBlocking tb + u = ignoreBlocking ub + it <- decomposeInterval' t + iu <- decomposeInterval' u + case () of + _ | blockedOrMeta tb || blockedOrMeta ub -> do + -- in case of metas we wouldn't be able to make progress by how we deal with de morgan laws. + -- (because the constraints generated by decomposition are sufficient but not necessary). + -- but we could still prune/solve some metas by comparing the terms as atoms. + -- also if blocked we won't find the terms conclusively unequal(?) so compareAtom + -- won't report type errors when we should accept. + interval <- elInf $ primInterval + compareAtom CmpEq (AsTermsOf interval) t u + _ | otherwise -> do + x <- leqInterval it iu + y <- leqInterval iu it + let final = isCanonical it && isCanonical iu + if x && y then reportSDoc "tc.conv.interval" 15 $ "Ok! }" else + if final then typeError $ UnequalTerms cmp t u (AsTermsOf i) + else do + reportSDoc "tc.conv.interval" 15 $ "Giving up! }" + patternViolation + where + blockedOrMeta Blocked{} = True + blockedOrMeta (NotBlocked _ (MetaV{})) = True + blockedOrMeta _ = False + + +type Conj = (Map.Map Int (Set.Set Bool),[Term]) + +isCanonical :: [Conj] -> Bool +isCanonical = all (null . snd) + +-- | leqInterval r q = r ≤ q in the I lattice. +-- (∨ r_i) ≤ (∨ q_j) iff ∀ i. ∃ j. r_i ≤ q_j +leqInterval :: MonadConversion m => [Conj] -> [Conj] -> m Bool +leqInterval r q = + and <$> forM r (\ r_i -> + or <$> forM q (\ q_j -> leqConj r_i q_j)) -- TODO shortcut + +-- | leqConj r q = r ≤ q in the I lattice, when r and q are conjuctions. +-- ' (∧ r_i) ≤ (∧ q_j) iff +-- ' (∧ r_i) ∧ (∧ q_j) = (∧ r_i) iff +-- ' {r_i | i} ∪ {q_j | j} = {r_i | i} iff +-- ' {q_j | j} ⊆ {r_i | i} +leqConj :: MonadConversion m => Conj -> Conj -> m Bool +leqConj (rs,rst) (qs,qst) = do + case toSet qs `Set.isSubsetOf` toSet rs of + False -> return False + True -> do + interval <- elInf $ fromMaybe __IMPOSSIBLE__ <$> getBuiltin' builtinInterval + + -- we don't want to generate new constraints here because + -- 1) in some situations the same constraint would get generated twice. + -- 2) unless things are completely accepted we are going to + -- throw patternViolation in compareInterval. + let eqT t u = tryConversion (compareAtom CmpEq (AsTermsOf interval) t u) + + let listSubset ts us = and <$> forM ts (\ t -> + or <$> forM us (\ u -> eqT t u)) -- TODO shortcut + listSubset qst rst + where + toSet m = Set.fromList [ (i,b) | (i,bs) <- Map.toList m, b <- Set.toList bs] + + +-- | equalTermOnFace φ A u v = _ , φ ⊢ u = v : A +equalTermOnFace :: MonadConversion m => Term -> Type -> Term -> Term -> m () +equalTermOnFace = compareTermOnFace CmpEq + +compareTermOnFace :: MonadConversion m => Comparison -> Term -> Type -> Term -> Term -> m () +compareTermOnFace = compareTermOnFace' compareTerm + +compareTermOnFace' :: MonadConversion m => (Comparison -> Type -> Term -> Term -> m ()) -> Comparison -> Term -> Type -> Term -> Term -> m () +compareTermOnFace' k cmp phi ty u v = do + phi <- reduce phi + _ <- forallFaceMaps phi postponed + $ \ alpha -> k cmp (applySubst alpha ty) (applySubst alpha u) (applySubst alpha v) + return () + where + postponed ms i psi = do + phi <- runNamesT [] $ do + imin <- cl $ getPrimitiveTerm "primIMin" + ineg <- cl $ getPrimitiveTerm "primINeg" + psi <- open psi + let phi = foldr (\ (i,b) r -> do i <- open (var i); pure imin <@> (if b then i else pure ineg <@> i) <@> r) + psi (Map.toList ms) -- TODO Andrea: make a view? + phi + addConstraint (ValueCmpOnFace cmp phi ty u v) + +--------------------------------------------------------------------------- +-- * Definitions +--------------------------------------------------------------------------- + +bothAbsurd :: MonadConversion m => QName -> QName -> m Bool bothAbsurd f f' | isAbsurdLambdaName f, isAbsurdLambdaName f' = do -- Double check we are really dealing with absurd lambdas: diff --git a/src/full/Agda/TypeChecking/Conversion.hs-boot b/src/full/Agda/TypeChecking/Conversion.hs-boot --- a/src/full/Agda/TypeChecking/Conversion.hs-boot +++ b/src/full/Agda/TypeChecking/Conversion.hs-boot @@ -1,22 +1,46 @@ module Agda.TypeChecking.Conversion where +import qualified Control.Monad.Fail as Fail + import Agda.Syntax.Internal import Agda.TypeChecking.Monad +import Agda.TypeChecking.Monad.Builtin (HasBuiltins) +import Agda.TypeChecking.Warnings +import Agda.Utils.Except ( MonadError ) -compareTerm :: Comparison -> Type -> Term -> Term -> TCM () -compareTermOnFace :: Comparison -> Term -> Type -> Term -> Term -> TCM () -compareAtom :: Comparison -> Type -> Term -> Term -> TCM () -compareArgs :: [Polarity] -> [IsForced] -> Type -> Term -> Args -> Args -> TCM () -compareElims :: [Polarity] -> [IsForced] -> Type -> Term -> [Elim] -> [Elim] -> TCM () -compareType :: Comparison -> Type -> Type -> TCM () -compareTel :: Type -> Type -> Comparison -> Telescope -> Telescope -> TCM () -compareSort :: Comparison -> Sort -> Sort -> TCM () -compareLevel :: Comparison -> Level -> Level -> TCM () -equalTerm :: Type -> Term -> Term -> TCM () -equalTermOnFace :: Term -> Type -> Term -> Term -> TCM () -equalType :: Type -> Type -> TCM () -equalSort :: Sort -> Sort -> TCM () -equalLevel :: Level -> Level -> TCM () -leqType :: Type -> Type -> TCM () -leqLevel :: Level -> Level -> TCM () +type MonadConversion m = + ( MonadReduce m + , MonadAddContext m + , MonadConstraint m + , MonadMetaSolver m + , MonadError TCErr m + , MonadWarning m + , MonadDebug m + , MonadStatistics m + , MonadFresh ProblemId m + , MonadFresh Int m + , HasBuiltins m + , HasConstInfo m + , HasOptions m + , Fail.MonadFail m + ) + +compareTerm :: MonadConversion m => Comparison -> Type -> Term -> Term -> m () +compareAs :: MonadConversion m => Comparison -> CompareAs -> Term -> Term -> m () +compareTermOnFace :: MonadConversion m => Comparison -> Term -> Type -> Term -> Term -> m () +compareAtom :: MonadConversion m => Comparison -> CompareAs -> Term -> Term -> m () +compareArgs :: MonadConversion m => [Polarity] -> [IsForced] -> Type -> Term -> Args -> Args -> m () +compareElims :: MonadConversion m => [Polarity] -> [IsForced] -> Type -> Term -> [Elim] -> [Elim] -> m () +compareType :: MonadConversion m => Comparison -> Type -> Type -> m () +compareTel :: MonadConversion m => Type -> Type -> Comparison -> Telescope -> Telescope -> m () +compareSort :: MonadConversion m => Comparison -> Sort -> Sort -> m () +compareLevel :: MonadConversion m => Comparison -> Level -> Level -> m () +equalTerm :: MonadConversion m => Type -> Term -> Term -> m () +equalTermOnFace :: MonadConversion m => Term -> Type -> Term -> Term -> m () +equalType :: MonadConversion m => Type -> Type -> m () +equalSort :: MonadConversion m => Sort -> Sort -> m () +equalLevel :: MonadConversion m => Level -> Level -> m () +leqType :: MonadConversion m => Type -> Type -> m () +leqLevel :: MonadConversion m => Level -> Level -> m () +leqSort :: MonadConversion m => Sort -> Sort -> m () diff --git a/src/full/Agda/TypeChecking/Conversion/Pure.hs b/src/full/Agda/TypeChecking/Conversion/Pure.hs new file mode 100644 --- /dev/null +++ b/src/full/Agda/TypeChecking/Conversion/Pure.hs @@ -0,0 +1,140 @@ +{-# LANGUAGE GeneralizedNewtypeDeriving #-} + +module Agda.TypeChecking.Conversion.Pure where + +import Control.Monad.Fail (MonadFail) +import Control.Monad.State + +import Data.String + +import Agda.Syntax.Common +import Agda.Syntax.Internal + +import {-# SOURCE #-} Agda.TypeChecking.Conversion +import Agda.TypeChecking.Monad +import Agda.TypeChecking.Monad.Builtin +import Agda.TypeChecking.Pretty +import Agda.TypeChecking.Warnings + +import Agda.Utils.Either +import Agda.Utils.Except +import Agda.Utils.Null + +import Agda.Utils.Impossible + +data FreshThings = FreshThings + { freshInt :: Int + , freshProblemId :: ProblemId + , freshNameId :: NameId + } + +newtype PureConversionT m a = PureConversionT + { unPureConversionT :: ExceptT TCErr (StateT FreshThings m) a } + deriving (Functor, Applicative, Monad, MonadError TCErr, MonadState FreshThings) + +pureEqualTerm + :: (MonadReduce m, MonadAddContext m, HasBuiltins m, HasConstInfo m) + => Type -> Term -> Term -> m Bool +pureEqualTerm a u v = locallyTC eCompareBlocked (const True) $ + isRight <$> runPureConversion (equalTerm a u v) + +pureCompareAs + :: (MonadReduce m, MonadAddContext m, HasBuiltins m, HasConstInfo m) + => Comparison -> CompareAs -> Term -> Term -> m Bool +pureCompareAs cmp a u v = locallyTC eCompareBlocked (const True) $ + isRight <$> runPureConversion (compareAs cmp a u v) + +runPureConversion + :: (ReadTCState m, MonadDebug m, HasOptions m, MonadTCEnv m, Show a) + => PureConversionT m a -> m (Either TCErr a) +runPureConversion (PureConversionT m) = do + i <- useR stFreshInt + pid <- useR stFreshProblemId + nid <- useR stFreshNameId + let frsh = FreshThings i pid nid + result <- fst <$> runStateT (runExceptT m) frsh + reportSLn "tc.conv.pure" 40 $ "runPureConversion result: " ++ show result + return result + +deriving instance MonadFail m => MonadFail (PureConversionT m) +deriving instance HasBuiltins m => HasBuiltins (PureConversionT m) +deriving instance HasConstInfo m => HasConstInfo (PureConversionT m) +deriving instance HasOptions m => HasOptions (PureConversionT m) +deriving instance MonadTCEnv m => MonadTCEnv (PureConversionT m) +deriving instance ReadTCState m => ReadTCState (PureConversionT m) +deriving instance MonadReduce m => MonadReduce (PureConversionT m) +deriving instance MonadAddContext m => MonadAddContext (PureConversionT m) +deriving instance MonadDebug m => MonadDebug (PureConversionT m) + +instance (Monad m, Semigroup a) => Semigroup (PureConversionT m a) where + d1 <> d2 = (<>) <$> d1 <*> d2 + +instance (IsString a, Monad m) => IsString (PureConversionT m a) where + fromString s = return (fromString s) + +instance Monad m => Null (PureConversionT m Doc) where + empty = return empty + null = __IMPOSSIBLE__ + +instance (MonadTCEnv m, ReadTCState m, HasOptions m, MonadDebug m) + => MonadConstraint (PureConversionT m) where + addConstraint c = patternViolation + addAwakeConstraint c = patternViolation + catchPatternErr handle m = m `catchError` \case + PatternErr{} -> handle + err -> throwError err + solveConstraint c = patternViolation + solveSomeAwakeConstraints _ _ = return () + wakeConstraints _ = return () + stealConstraints _ = return () + modifyAwakeConstraints _ = patternViolation + modifySleepingConstraints _ = patternViolation + +instance (MonadTCEnv m, MonadReduce m, MonadAddContext m, ReadTCState m, HasBuiltins m, HasConstInfo m, MonadDebug m) + => MonadMetaSolver (PureConversionT m) where + newMeta' _ _ _ _ _ _ = patternViolation + assignV _ _ _ _ _ = patternViolation + assignTerm' _ _ _ = patternViolation + etaExpandMeta _ _ = return () + updateMetaVar _ _ = patternViolation + speculateMetas fallback m = m >>= \case + KeepMetas -> return () + RollBackMetas -> fallback + +instance (MonadTCEnv m, ReadTCState m) => MonadInteractionPoints (PureConversionT m) where + freshInteractionId = patternViolation + modifyInteractionPoints _ = patternViolation + +-- This is a bogus instance that promptly forgets all concrete names, +-- but we don't really care +instance ReadTCState m => MonadStConcreteNames (PureConversionT m) where + runStConcreteNames m = do + concNames <- useR stConcreteNames + fst <$> runStateT m concNames + +instance (MonadReduce m, MonadAddContext m, HasConstInfo m, HasBuiltins m) + => MonadWarning (PureConversionT m) where + addWarning w = case classifyWarning (tcWarning w) of + ErrorWarnings -> patternViolation + AllWarnings -> return () + +instance ReadTCState m => MonadStatistics (PureConversionT m) where + modifyCounter _ _ = return () + +instance Monad m => MonadFresh ProblemId (PureConversionT m) where + fresh = do + i <- gets freshProblemId + modify $ \f -> f { freshProblemId = i + 1 } + return i + +instance Monad m => MonadFresh NameId (PureConversionT m) where + fresh = do + i <- gets freshNameId + modify $ \f -> f { freshNameId = succ i } + return i + +instance Monad m => MonadFresh Int (PureConversionT m) where + fresh = do + i <- gets freshInt + modify $ \f -> f { freshInt = i + 1 } + return i diff --git a/src/full/Agda/TypeChecking/Coverage.hs b/src/full/Agda/TypeChecking/Coverage.hs --- a/src/full/Agda/TypeChecking/Coverage.hs +++ b/src/full/Agda/TypeChecking/Coverage.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE NondecreasingIndentation #-} {-| Coverage checking, case splitting, and splitting for refine tactics. @@ -6,7 +5,7 @@ -} module Agda.TypeChecking.Coverage - ( SplitClause(..), clauseToSplitClause, fixTarget + ( SplitClause(..), clauseToSplitClause, insertTrailingArgs , Covering(..), splitClauses , coverageCheck , isCovered @@ -18,47 +17,42 @@ import Prelude hiding (null, (!!)) -- do not use partial functions like !! -import Control.Arrow (second) - import Control.Monad -import Control.Monad.Reader import Control.Monad.Trans ( lift ) -import Data.Either (lefts) import Data.Foldable (for_) import qualified Data.List as List -import Data.Monoid (Any(..)) import Data.Map (Map) import qualified Data.Map as Map import Data.Set (Set) import qualified Data.Set as Set -import qualified Data.Traversable as Trav +import Data.IntSet (IntSet) +import qualified Data.IntSet as IntSet import Agda.Syntax.Common import Agda.Syntax.Position -import Agda.Syntax.Literal import Agda.Syntax.Internal import Agda.Syntax.Internal.Pattern +import Agda.Syntax.Translation.InternalToAbstract (NamedClause(..)) import Agda.TypeChecking.Names import Agda.TypeChecking.Primitive hiding (Nat) -import Agda.TypeChecking.Primitive.Cubical +import Agda.TypeChecking.Primitive.Cubical (trFillTel) import Agda.TypeChecking.Monad import Agda.TypeChecking.Monad.Builtin import Agda.TypeChecking.Rules.LHS (checkSortOfSplitVar) import Agda.TypeChecking.Rules.LHS.Problem (allFlexVars) import Agda.TypeChecking.Rules.LHS.Unify +import Agda.TypeChecking.Rules.Term (unquoteTactic) import Agda.TypeChecking.Coverage.Match import Agda.TypeChecking.Coverage.SplitTree -import Agda.TypeChecking.Conversion (tryConversion, equalType, equalTermOnFace) +import Agda.TypeChecking.Conversion (tryConversion, equalType) import Agda.TypeChecking.Datatypes (getConForm) import {-# SOURCE #-} Agda.TypeChecking.Empty ( checkEmptyTel, isEmptyTel, isEmptyType ) -import Agda.TypeChecking.Free import Agda.TypeChecking.Irrelevance -import Agda.TypeChecking.Patterns.Internal (dotPatternsToPatterns) import Agda.TypeChecking.Pretty import Agda.TypeChecking.Substitute import Agda.TypeChecking.Reduce @@ -73,10 +67,9 @@ import Agda.Utils.Either import Agda.Utils.Except ( ExceptT - , MonadError(catchError, throwError) + , MonadError (throwError, catchError) , runExceptT ) -import Agda.Utils.Function import Agda.Utils.Functor import Agda.Utils.List import Agda.Utils.Maybe @@ -84,11 +77,10 @@ import Agda.Utils.Null import Agda.Utils.Permutation import Agda.Utils.Pretty (prettyShow) +import Agda.Utils.Singleton import Agda.Utils.Size -import Agda.Utils.Tuple -import Agda.Utils.Lens +import Agda.Utils.WithDefault -#include "undefined.h" import Agda.Utils.Impossible data SplitClause = SClause @@ -113,11 +105,9 @@ , scCheckpoints :: Map CheckpointId Substitution -- ^ We need to keep track of the module parameter checkpoints for the -- clause for the purpose of inferring missing instance clauses. - , scTarget :: Maybe (Arg Type) + , scTarget :: Maybe (Dom Type) -- ^ The type of the rhs, living in context 'scTel'. - -- This invariant is broken before calls to 'fixTarget'; - -- there, 'scTarget' lives in the old context. - -- 'fixTarget' moves 'scTarget' to the new context by applying + -- 'fixTargetType' computes the new 'scTarget' by applying -- substitution 'scSubst'. } @@ -140,7 +130,7 @@ , scPats = toSplitPatterns $ namedClausePats cl , scSubst = idS -- Andreas, 2014-07-15 TODO: Is this ok? , scCheckpoints = Map.empty -- #2996: not __IMPOSSIBLE__ for debug printing - , scTarget = clauseType cl + , scTarget = domFromArg <$> clauseType cl } type CoverM = ExceptT SplitError TCM @@ -182,7 +172,7 @@ checkpoints <- applySubst (raiseS (n - fv)) <$> viewTC eCheckpoints -- construct the initial split clause - let sc = SClause gamma xs idS checkpoints $ Just $ defaultArg a + let sc = SClause gamma xs idS checkpoints $ Just $ defaultDom a reportSDoc "tc.cover.top" 10 $ do let prCl cl = addContext (clauseTel cl) $ @@ -193,14 +183,14 @@ ] -- used = actually used clauses for cover - -- pss = uncovered cases + -- pss = non-covered cases CoverResult splitTree used pss qss noex <- cover f cs sc -- Andreas, 2018-11-12, issue #378: -- some indices in @used@ and @noex@ point outside of @cs@, -- since missing hcomp clauses have been added during the course of @cover@. -- We simply delete theses indices from @noex@. - noex <- return $ List.filter (< length cs) $ Set.toList noex + noex <- return $ List.filter (< length cs) $ IntSet.toList noex reportSDoc "tc.cover.top" 10 $ vcat [ "cover computed!" @@ -213,7 +203,7 @@ ] reportSDoc "tc.cover.covering" 10 $ vcat [ text $ "covering patterns for " ++ prettyShow f - , nest 2 $ vcat $ map (\cl -> enterClosure cl $ \ cl -> addContext (clauseTel cl) $ prettyTCMPatternList $ namedClausePats cl) qss + , nest 2 $ vcat $ map (\ cl -> addContext (clauseTel cl) $ prettyTCMPatternList $ namedClausePats cl) qss ] -- Storing the covering clauses so that checkIApplyConfluence_ can @@ -243,7 +233,9 @@ , clauseBody = Nothing , clauseType = Nothing , clauseCatchall = False + , clauseRecursive = Just False , clauseUnreachable = Just False + , clauseEllipsis = NoEllipsis } reportSDoc "tc.cover.missing" 20 $ inTopContext $ do sep [ "adding missing absurd clause" @@ -258,16 +250,15 @@ return False -- report a warning if there are uncovered cases, - -- generate a catch-all clause with a metavariable as its body to avoid - -- internal errors in the reduction machinery. - unless (null pss) $ - setCurrentRange cs $ - warning $ CoverageIssue f pss + unless (null pss) $ do + stLocalPartialDefs `modifyTCLens` Set.insert f + whenM ((YesCoverageCheck ==) <$> viewTC eCoverageCheck) $ + setCurrentRange cs $ warning $ CoverageIssue f pss -- Andreas, 2017-08-28, issue #2723: -- Mark clauses as reachable or unreachable in the signature. let (is0, cs1) = unzip $ for (zip [0..] cs) $ \ (i, cl) -> - let unreachable = i `Set.notMember` used in + let unreachable = i `IntSet.notMember` used in (boolToMaybe unreachable i, cl { clauseUnreachable = Just unreachable }) -- is = indices of unreachable clauses let is = catMaybes is0 @@ -282,8 +273,8 @@ unless (null is) $ do -- Warn about unreachable clauses. let unreached = filter ((Just True ==) . clauseUnreachable) cs1 - setCurrentRange (map clauseFullRange unreached) $ - warning $ UnreachableClauses f $ map namedClausePats unreached + let ranges = map clauseFullRange unreached + setCurrentRange ranges $ warning $ UnreachableClauses f ranges -- report a warning if there are clauses that are not preserved as -- definitional equalities and --exact-split is enabled @@ -297,17 +288,30 @@ -- case splitter isCovered :: QName -> [Clause] -> SplitClause -> TCM Bool isCovered f cs sc = do - CoverResult { coverMissingClauses = missing } <- cover f cs sc + reportSDoc "tc.cover.isCovered" 20 $ vcat + [ "isCovered" + , nest 2 $ vcat $ + [ "f = " <+> prettyTCM f + , "cs = " <+> vcat (map (nest 2 . prettyTCM . NamedClause f True) cs) + , "sc = " <+> prettyTCM sc + ] + ] + -- Jesper, 2019-10: introduce trailing arguments (see #3828) + (_ , sc') <- insertTrailingArgs sc + CoverResult { coverMissingClauses = missing } <- cover f cs sc' return $ null missing + -- Andreas, 2019-08-08 and 2020-02-11 + -- If there is an error (e.g. unification error), don't report it + -- to the user. Rather, assume the clause is not already covered. + `catchError` \ _ -> return False data CoverResult = CoverResult { coverSplitTree :: SplitTree - , coverUsedClauses :: Set Nat + , coverUsedClauses :: IntSet -- Set Nat , coverMissingClauses :: [(Telescope, [NamedArg DeBruijnPattern])] - , coverPatterns :: [Closure Clause] + , coverPatterns :: [Clause] -- ^ The set of patterns used as cover. - -- Entering the closure puts you directly in the right context (and cps) for the RHS. - , coverNoExactClauses :: Set Nat + , coverNoExactClauses :: IntSet -- Set Nat } -- | @cover f cs (SClause _ _ ps _) = return (splitTree, used, pss)@. @@ -321,42 +325,42 @@ cover f cs sc@(SClause tel ps _ _ target) = updateRelevance $ do reportSDoc "tc.cover.cover" 10 $ inTopContext $ vcat [ "checking coverage of pattern:" - , nest 2 $ "tel =" <+> prettyTCM tel - , nest 2 $ "ps =" <+> do addContext tel $ prettyTCMPatternList $ fromSplitPatterns ps - , nest 2 $ "target =" <+> do addContext tel $ maybe (text "") prettyTCM target - , nest 2 $ "target sort =" <+> do addContext tel $ maybe (text "") (prettyTCM . getSort . unArg) target + , nest 2 $ prettyTCM sc + , nest 2 $ "target sort =" <+> do addContext tel $ maybe (text "") (prettyTCM . getSort . unDom) target ] + reportSLn "tc.cover.cover" 80 $ "raw target =\n" ++ show target match cs ps >>= \case Yes (i,mps) -> do exact <- allM (map snd mps) isTrivialPattern let cl0 = indexWithDefault __IMPOSSIBLE__ cs i let noExactClause = if exact || clauseCatchall (indexWithDefault __IMPOSSIBLE__ cs i) - then Set.empty - else Set.singleton i + then empty + else singleton i reportSLn "tc.cover.cover" 10 $ "pattern covered by clause " ++ show i reportSDoc "tc.cover.cover" 20 $ text "with mps = " <+> do addContext tel $ pretty $ mps cl <- applyCl sc cl0 mps - return $ CoverResult (SplittingDone (size tel)) (Set.singleton i) [] [cl] noExactClause + return $ CoverResult (SplittingDone (size tel)) (singleton i) [] [cl] noExactClause No -> do reportSLn "tc.cover" 20 $ "pattern is not covered" - -- TODO Andrea: add hcomp clause! - case fmap getHiding target of - Just h | isInstance h -> do + let infer dom = isInstance dom || isJust (domTactic dom) + if maybe False infer target + then do -- Ulf, 2016-10-31: For now we only infer instance clauses. It would -- make sense to do it also for hidden, but since the value of a -- hidden clause is expected to be forced by later clauses, it's too -- late to add it now. If it was inferrable we would have gotten a -- type error before getting to this point. + -- Ulf, 2019-11-21: Also @tactic clauses. cl <- inferMissingClause f sc - return $ CoverResult (SplittingDone (size tel)) Set.empty [] [cl] Set.empty - _ -> do + return $ CoverResult (SplittingDone (size tel)) empty [] [cl] empty + else do let ps' = fromSplitPatterns ps - return $ CoverResult (SplittingDone (size tel)) Set.empty [(tel, ps')] [] Set.empty + return $ CoverResult (SplittingDone (size tel)) empty [(tel, ps')] [] empty -- We need to split! -- If all clauses have an unsplit copattern, we try that first. - Block res bs -> trySplitRes res (null bs) $ do + Block res bs -> trySplitRes res (null bs) splitError $ do when (null bs) __IMPOSSIBLE__ -- Otherwise, if there are variables to split, we try them -- in the order determined by a split strategy. @@ -369,28 +373,71 @@ -- If this fails, try to at least carry out the splitting to the end. continue xs NoAllowPartialCover $ \ _err -> do continue xs YesAllowPartialCover $ \ err -> do - typeError $ SplitError err + splitError err where - applyCl :: SplitClause -> Clause -> [(Nat, SplitPattern)] -> TCM (Closure Clause) - applyCl SClause{scTel = tel, scCheckpoints = cps} cl mps - = addContext tel - $ locallyTC eCheckpoints (const cps) - $ checkpoint IdS $ do + -- Andreas, 2019-08-07, issue #3966 + -- | When we get a SplitError, tighten the error Range to the clauses + -- that are still candidates for covering the SplitClause. + splitError :: SplitError -> TCM a + splitError = withRangeOfCandidateClauses . typeError . SplitError + + -- | This repeats the matching, but since we are crashing anyway, + -- the extra work just to compute a better Range does not matter. + withRangeOfCandidateClauses :: TCM a -> TCM a + withRangeOfCandidateClauses cont = do + cands <- mapMaybe (uncurry notNo) . zip cs <$> mapM (matchClause ps) cs + setCurrentRange cands cont + where + notNo :: Clause -> Match a -> Maybe Clause + notNo c = \case + Yes{} -> Just c + Block{} -> Just c + No{} -> Nothing + + applyCl :: SplitClause -> Clause -> [(Nat, SplitPattern)] -> TCM Clause + applyCl SClause{scTel = tel, scPats = sps} cl mps = addContext tel $ do + let ps = namedClausePats cl reportSDoc "tc.cover.applyCl" 40 $ "applyCl" reportSDoc "tc.cover.applyCl" 40 $ "tel =" <+> prettyTCM tel - reportSDoc "tc.cover.applyCl" 40 $ "ps =" <+> pretty (namedClausePats cl) + reportSDoc "tc.cover.applyCl" 40 $ "ps =" <+> pretty ps reportSDoc "tc.cover.applyCl" 40 $ "mps =" <+> pretty mps reportSDoc "tc.cover.applyCl" 40 $ "s =" <+> pretty s - reportSDoc "tc.cover.applyCl" 40 $ "new ps =" <+> pretty (s `applySubst` namedClausePats cl) - buildClosure $ + reportSDoc "tc.cover.applyCl" 40 $ "ps[s] =" <+> pretty (s `applySubst` ps) + + -- If a matching clause has fewer patterns than the split + -- clause we ought to copy over the extra ones. + -- e.g. if the user wrote: + -- + -- bar : Bool -> Bool + -- bar false = false + -- bar = \ _ -> true + -- + -- then for the second clause the @extra@ patterns will be @[true]@. + + let extra = drop (length ps) $ fromSplitPatterns sps + n_extra = length extra + + reportSDoc "tc.cover.applyCl" 40 $ "extra =" <+> pretty extra + + -- When we add the extra patterns we also update the type + -- and the body of the clause. + + mtv <- (traverse . traverse) (telViewUpToPath n_extra) $ clauseType cl + let ty = (fmap . fmap) ((parallelS (reverse $ map namedArg extra) `composeS` liftS n_extra s `applyPatSubst`) . theCore) mtv + + reportSDoc "tc.cover.applyCl" 40 $ "new ty =" <+> pretty ty + + return $ Clause { clauseLHSRange = clauseLHSRange cl , clauseFullRange = clauseFullRange cl , clauseTel = tel - , namedClausePats = s `applySubst` namedClausePats cl - , clauseBody = (s `applyPatSubst`) <$> clauseBody cl - , clauseType = (s `applyPatSubst`) <$> clauseType cl + , namedClausePats = (s `applySubst` ps) ++ extra + , clauseBody = (`applyE` patternsToElims extra) . (s `applyPatSubst`) <$> clauseBody cl + , clauseType = ty , clauseCatchall = clauseCatchall cl + , clauseRecursive = clauseRecursive cl , clauseUnreachable = clauseUnreachable cl + , clauseEllipsis = clauseEllipsis cl } where (vs,qs) = unzip mps @@ -420,7 +467,7 @@ do -- TODO Andrea: I guess an empty pattern is not part of the cover? let qs = [] - return $ CoverResult (SplittingDone (size tel)) Set.empty [] qs Set.empty + return $ CoverResult (SplittingDone (size tel)) empty [] qs empty Right (Covering n scs, x) -> do cs <- do let fallback = return cs @@ -449,30 +496,31 @@ ] -- TODO Andrea: do something with etaRecordSplits and qsss? let trees' = zipWith (etaRecordSplits (unArg n) ps) scs trees - tree = SplitAt n trees' - return $ CoverResult tree (Set.unions useds) (concat psss) (concat qsss) (Set.unions noex) + tree = SplitAt n StrictSplit trees' -- TODO: Lazy? + return $ CoverResult tree (IntSet.unions useds) (concat psss) (concat qsss) (IntSet.unions noex) -- Try to split result trySplitRes :: BlockedOnResult -- ^ Are we blocked on the result? -> Bool -- ^ Is this the last thing we try? + -> (SplitError -> TCM CoverResult) -- ^ Handler for 'SplitError' -> TCM CoverResult -- ^ Continuation -> TCM CoverResult -- not blocked on result: try regular splits - trySplitRes NotBlockedOnResult finalSplit cont + trySplitRes NotBlockedOnResult finalSplit splitError cont | finalSplit = __IMPOSSIBLE__ -- there must be *some* reason we are blocked | otherwise = cont -- blocked on arguments that are not yet introduced: -- we must split on a variable so that the target type becomes a pi type - trySplitRes (BlockedOnApply IsApply) finalSplit cont + trySplitRes (BlockedOnApply IsApply) finalSplit splitError cont | finalSplit = __IMPOSSIBLE__ -- already ruled out by lhs checker | otherwise = cont -- ...or it was an IApply pattern, so we might just need to introduce the variable now. - trySplitRes (BlockedOnApply IsIApply) finalSplit cont + trySplitRes (BlockedOnApply IsIApply) finalSplit splitError cont = do caseMaybeM (splitResultPath f sc) fallback $ \ sc -> - cover f cs . snd =<< fixTarget sc + cover f cs . snd =<< insertTrailingArgs sc where fallback | finalSplit = __IMPOSSIBLE__ -- already ruled out by lhs checker? | otherwise = cont @@ -480,22 +528,22 @@ -- try regular splits if there are any, or else throw an error, -- this is nicer than continuing and reporting unreachable clauses -- (see issue #2833) - trySplitRes (BlockedOnProj True) finalSplit cont - | finalSplit = typeError $ SplitError CosplitCatchall + trySplitRes (BlockedOnProj True) finalSplit splitError cont + | finalSplit = splitError CosplitCatchall | otherwise = cont -- all clauses have an unsplit copattern: try to split - trySplitRes (BlockedOnProj False) finalSplit cont = do + trySplitRes (BlockedOnProj False) finalSplit splitError cont = do reportSLn "tc.cover" 20 $ "blocked by projection pattern" -- forM is a monadic map over a Maybe here mcov <- splitResultRecord f sc case mcov of Left err - | finalSplit -> typeError $ SplitError err + | finalSplit -> splitError err | otherwise -> cont Right (Covering n scs) -> do -- If result splitting was successful, continue coverage checking. (projs, results) <- unzip <$> do - mapM (traverseF $ cover f cs <=< (snd <.> fixTarget)) scs + mapM (traverseF $ cover f cs <=< (snd <.> insertTrailingArgs)) scs -- OR: -- forM scs $ \ (proj, sc') -> (proj,) <$> do -- cover f cs =<< do @@ -505,8 +553,8 @@ psss = map coverMissingClauses results qsss = map coverPatterns results noex = map coverNoExactClauses results - tree = SplitAt n $ zip projs trees - return $ CoverResult tree (Set.unions useds) (concat psss) (concat qsss) (Set.unions noex) + tree = SplitAt n StrictSplit $ zip projs trees -- TODO: Lazy? + return $ CoverResult tree (IntSet.unions useds) (concat psss) (concat qsss) (IntSet.unions noex) gatherEtaSplits :: Int -> SplitClause -> [NamedArg SplitPattern] -> [NamedArg SplitPattern] @@ -520,7 +568,7 @@ VarP _ _ -> p : gatherEtaSplits (-1) sc ps DotP _ _ -> __IMPOSSIBLE__ ConP _ _ qs -> qs ++ gatherEtaSplits (-1) sc ps - LitP _ -> gatherEtaSplits (-1) sc ps + LitP{} -> gatherEtaSplits (-1) sc ps ProjP{} -> __IMPOSSIBLE__ IApplyP{} -> __IMPOSSIBLE__ DefP _ _ qs -> qs ++ gatherEtaSplits (-1) sc ps -- __IMPOSSIBLE__ -- Andrea: maybe? @@ -532,7 +580,7 @@ DotP _ _ -> p : gatherEtaSplits (n-1) sc ps -- count dot patterns ConP _ _ qs -> gatherEtaSplits n sc (qs ++ ps) DefP _ _ qs -> gatherEtaSplits n sc (qs ++ ps) - LitP _ -> gatherEtaSplits n sc ps + LitP{} -> gatherEtaSplits n sc ps ProjP{} -> gatherEtaSplits n sc ps addEtaSplits :: Int -> [NamedArg SplitPattern] -> SplitTree -> SplitTree @@ -540,8 +588,8 @@ addEtaSplits k (p:ps) t = case namedArg p of VarP _ _ -> addEtaSplits (k+1) ps t DotP _ _ -> addEtaSplits (k+1) ps t - ConP c cpi qs -> SplitAt (p $> k) [(SplitCon (conName c) , addEtaSplits k (qs ++ ps) t)] - LitP _ -> __IMPOSSIBLE__ + ConP c cpi qs -> SplitAt (p $> k) LazySplit [(SplitCon (conName c) , addEtaSplits k (qs ++ ps) t)] + LitP{} -> __IMPOSSIBLE__ ProjP{} -> __IMPOSSIBLE__ DefP{} -> __IMPOSSIBLE__ -- Andrea: maybe? IApplyP{} -> addEtaSplits (k+1) ps t @@ -698,7 +746,7 @@ -- Γ,x,Δ ⊢ f old_ps -- Γ ⊢ abstract hdelta (f old_ps) g <- open $ raise (3+size delta) $ abstract hdelta (Def f old_ps) - old_t <- open $ raise (3+size delta) $ abstract hdelta (unArg old_t) + old_t <- open $ raise (3+size delta) $ abstract hdelta (unDom old_t) let bapp a x = lazyAbsApp <$> a <*> x (delta_fill :: NamesT TCM (Abs Args)) <- (open =<<) $ do -- Γ,φ,u,u0,Δ(x = hcomp phi u u0) ⊢ x.Δ @@ -778,7 +826,9 @@ , clauseBody = Just $ rhs , clauseType = Just $ defaultArg t , clauseCatchall = False + , clauseRecursive = Nothing -- TODO: can it be recursive? , clauseUnreachable = Just False -- missing, thus, not unreachable + , clauseEllipsis = NoEllipsis } addClauses f [cl] -- Important: add at the end. return cl @@ -790,27 +840,35 @@ -- ^ Function name. -> SplitClause -- ^ Clause to add. Clause hiding (in 'clauseType') must be 'Instance'. - -> TCM (Closure Clause) + -> TCM Clause inferMissingClause f (SClause tel ps _ cps (Just t)) = setCurrentRange f $ do reportSDoc "tc.cover.infer" 20 $ addContext tel $ "Trying to infer right-hand side of type" <+> prettyTCM t - cl <- addContext tel - $ locallyTC eCheckpoints (const cps) - $ checkpoint IdS $ do -- introduce a fresh checkpoint - (_x, rhs) <- case getHiding t of - Instance{} -> newInstanceMeta "" (unArg t) - Hidden -> __IMPOSSIBLE__ - NotHidden -> __IMPOSSIBLE__ - buildClosure $ - Clause { clauseLHSRange = noRange - , clauseFullRange = noRange - , clauseTel = tel - , namedClausePats = fromSplitPatterns ps - , clauseBody = Just rhs - , clauseType = Just t - , clauseCatchall = False - , clauseUnreachable = Just False -- missing, thus, not unreachable - } - addClauses f [clValue cl] -- Important: add at the end. + rhs <- + addContext tel + $ locallyTC eCheckpoints (const cps) + $ checkpoint IdS -- introduce a fresh checkpoint + $ case getHiding t of + _ | Just tac <- domTactic t -> do + reportSDoc "tc.cover.infer" 40 $ vcat + [ "@tactic rhs" + , nest 2 $ "target =" <+> pretty t ] + (_, v) <- newValueMeta DontRunMetaOccursCheck CmpLeq (unDom t) + v <$ unquoteTactic tac v (unDom t) + Instance{} -> snd <$> newInstanceMeta "" (unDom t) + Hidden -> __IMPOSSIBLE__ + NotHidden -> __IMPOSSIBLE__ + let cl = Clause { clauseLHSRange = noRange + , clauseFullRange = noRange + , clauseTel = tel + , namedClausePats = fromSplitPatterns ps + , clauseBody = Just rhs + , clauseType = Just (argFromDom t) + , clauseCatchall = False + , clauseRecursive = Nothing -- could be recursive + , clauseUnreachable = Just False -- missing, thus, not unreachable + , clauseEllipsis = NoEllipsis + } + addClauses f [cl] -- Important: add at the end. return cl inferMissingClause _ (SClause _ _ _ _ Nothing) = __IMPOSSIBLE__ @@ -820,7 +878,8 @@ -- we make our last try to split. -- Otherwise, we will not get a nice error message. where - xs = bs + xs = strict ++ lazy + (lazy, strict) = List.partition blockingVarLazy bs {- KEEP! -- Andreas, 2012-10-13 -- The following split strategy which prefers all-constructor columns @@ -855,9 +914,7 @@ let ~(Just args) = allApplyElims es def <- liftTCM $ theDef <$> getConstInfo d case def of - Datatype{dataPars = np, dataCons = cs, dataInduction = i} - | i == CoInductive && ind /= CoInductive -> - throw CoinductiveDatatype + Datatype{dataPars = np, dataCons = cs} | otherwise -> do let (ps, is) = splitAt np args return (IsData, d, ps, is, cs, not $ null (dataPathCons def)) @@ -869,29 +926,32 @@ _ -> throw NotADatatype _ -> throw NotADatatype --- | Update the target type, add more patterns to split clause --- if target becomes a function type. --- Returns the domains of the function type (if any). -fixTarget :: SplitClause -> TCM (Telescope, SplitClause) -fixTarget sc@SClause{ scTel = sctel, scPats = ps, scSubst = sigma, scCheckpoints = cps, scTarget = target } = - caseMaybe target (return (empty, sc)) $ \ a -> do +-- | Update the target type of the split clause after a case split. +fixTargetType :: SplitClause -> Dom Type -> TCM SplitClause +fixTargetType sc@SClause{ scTel = sctel, scSubst = sigma } target = do reportSDoc "tc.cover.target" 20 $ sep [ "split clause telescope: " <+> prettyTCM sctel - , "old patterns : " <+> do - addContext sctel $ prettyTCMPatternList $ fromSplitPatterns ps ] reportSDoc "tc.cover.target" 60 $ sep [ "substitution : " <+> prettyTCM sigma ] - reportSDoc "tc.cover.target" 30 $ sep - [ "target type before substitution (variables may be wrong): " <+> do - addContext sctel $ prettyTCM a + reportSDoc "tc.cover.target" 60 $ sep + [ "target type before substitution:" <+> pretty target + , " after substitution:" <+> pretty (applySplitPSubst sigma target) ] - (TelV tel b) <- telViewUpTo (-1) $ applySplitPSubst sigma $ unArg a + return $ sc { scTarget = Just $ applySplitPSubst sigma target } + + +-- | Add more patterns to split clause if the target type is a function type. +-- Returns the domains of the function type (if any). +insertTrailingArgs :: SplitClause -> TCM (Telescope, SplitClause) +insertTrailingArgs sc@SClause{ scTel = sctel, scPats = ps, scSubst = sigma, scCheckpoints = cps, scTarget = target } = + caseMaybe target (return (empty,sc)) $ \ a -> do + (TelV tel b) <- telViewUpTo (-1) $ unDom a reportSDoc "tc.cover.target" 15 $ sep - [ "target type telescope (after substitution): " <+> do + [ "target type telescope: " <+> do addContext sctel $ prettyTCM tel - , "target type core (after substitution): " <+> do + , "target type core : " <+> do addContext sctel $ addContext tel $ prettyTCM b ] let n = size tel @@ -978,9 +1038,9 @@ -- conp = ConP con cpi $ applySubst rho2 $ -- map (mapArgInfo hiddenInserted) $ tele2NamedArgs gamma0 gamma -- -- Andreas, 2016-09-08, issue #2166: use gamma0 for correct argument names - defp = DefP PatOSystem hCompName . map (setOrigin Inserted) $ - map (fmap unnamed) [setHiding Hidden $ defaultArg $ applySubst rho1 $ DotP PatOSystem $ dlvl - ,setHiding Hidden $ defaultArg $ applySubst rho1 $ DotP PatOSystem $ dterm] + defp = DefP defaultPatternInfo hCompName . map (setOrigin Inserted) $ + map (fmap unnamed) [setHiding Hidden $ defaultArg $ applySubst rho1 $ DotP defaultPatternInfo $ dlvl + ,setHiding Hidden $ defaultArg $ applySubst rho1 $ DotP defaultPatternInfo $ dterm] ++ applySubst rho2 (teleNamedArgs gamma) -- rho0? -- Compute final context and substitution let rho3 = consS defp rho1 -- Δ₁' ⊢ ρ₃ : Δ₁(x:D) @@ -1056,19 +1116,30 @@ let preserve (x, t@(El _ (Def d' _))) | d == d' = (n, t) preserve (x, t) = (x, t) - gammal = map (fmap preserve) . telToList $ gamma0 - gamma = telFromList gammal + gamma = telFromList . map (fmap preserve) . telToList $ gamma0 delta1Gamma = delta1 `abstract` gamma debugInit con ctype d pars ixs cixs delta1 delta2 gamma tel ps hix - -- All variables are flexible - let flex = allFlexVars delta1Gamma + cforced <- defForced <$> getConstInfo c + -- Variables in Δ₁ are not forced, since the unifier takes care to not introduce forced + -- variables. + let forced = replicate (size delta1) NotForced ++ cforced + flex = allFlexVars forced delta1Gamma -- All variables are flexible -- Unify constructor target and given type (in Δ₁Γ) let conIxs = drop (size pars) cixs givenIxs = raise (size gamma) ixs + -- Andrea 2019-07-17 propagate the Cohesion to the equation telescope + -- TODO: should we propagate the modality in general? + -- See also LHS checking. + dtype <- do + let (_, Dom{domInfo = info} : _) = splitAt (size tel - hix - 1) (telToList tel) + let updCoh = composeCohesion (getCohesion info) + TelV dtel dt <- telView dtype + return $ abstract (mapCohesion updCoh <$> dtel) dt + r <- unifyIndices delta1Gamma flex @@ -1094,7 +1165,7 @@ -- as the result of splitting is never used further down the pipeline. -- After splitting, Agda reloads the file. -- Andreas, 2017-09-03, issue #2729: remember that pattern was generated by case split. - let cpi = noConPatternInfo{ conPRecord = Just PatOSplit } + let cpi = noConPatternInfo{ conPInfo = PatternInfo PatOSplit [] , conPRecord = True } conp = ConP con cpi $ applySubst rho0' $ map (mapArgInfo hiddenInserted) $ telePatterns' (tele2NamedArgs gamma0) gamma boundary -- Andreas, 2016-09-08, issue #2166: use gamma0 for correct argument names @@ -1113,13 +1184,13 @@ let ps' = applySubst rho ps debugPlugged delta' ps' - let cps' = applySplitPSubst rho cps + let cps' = applySplitPSubst rho cps return $ Just $ SClause delta' ps' rho cps' Nothing -- target fixed later where - debugInit con ctype d pars ixs cixs delta1 delta2 gamma tel ps hix = - liftTCM $ reportSDoc "tc.cover.split.con" 20 $ vcat + debugInit con ctype d pars ixs cixs delta1 delta2 gamma tel ps hix = liftTCM $ do + reportSDoc "tc.cover.split.con" 20 $ vcat [ "computeNeighbourhood" , nest 2 $ vcat [ "context=" <+> (inTopContext . prettyTCM =<< getContextTelescope) @@ -1133,9 +1204,27 @@ , "delta1 =" <+> do inTopContext $ prettyTCM delta1 , "delta2 =" <+> do inTopContext $ addContext delta1 $ addContext gamma $ prettyTCM delta2 , "gamma =" <+> do inTopContext $ addContext delta1 $ prettyTCM gamma + , "tel =" <+> do inTopContext $ prettyTCM tel , "hix =" <+> text (show hix) ] ] + reportSDoc "tc.cover.split.con" 70 $ vcat + [ "computeNeighbourhood" + , nest 2 $ vcat + [ "context=" <+> (inTopContext . (text . show) =<< getContextTelescope) + , "con =" <+> (text . show) con + , "ctype =" <+> (text . show) ctype + , "ps =" <+> (text . show) ps + , "d =" <+> (text . show) d + , "pars =" <+> (text . show) pars + , "ixs =" <+> (text . show) ixs + , "cixs =" <+> (text . show) cixs + , "delta1 =" <+> (text . show) delta1 + , "delta2 =" <+> (text . show) delta2 + , "gamma =" <+> (text . show) gamma + , "hix =" <+> text (show hix) + ] + ] debugNoUnify = liftTCM $ reportSLn "tc.cover.split.con" 20 " Constructor impossible!" @@ -1165,11 +1254,11 @@ [ "ps' =" <+> do prettyTCMPatternList $ fromSplitPatterns ps' ] --- | Introduce trailing pattern variables via 'fixTarget'? -data FixTarget - = YesFixTarget - | NoFixTarget - deriving (Show) +-- | Introduce trailing pattern variables? +data InsertTrailing + = DoInsertTrailing + | DontInsertTrailing + deriving (Eq, Show) -- | Allow partial covering for split? data AllowPartialCover @@ -1180,7 +1269,7 @@ -- | Entry point from @Interaction.MakeCase@. splitClauseWithAbsurd :: SplitClause -> Nat -> TCM (Either SplitError (Either SplitClause Covering)) splitClauseWithAbsurd c x = - split' CheckEmpty Inductive NoAllowPartialCover NoFixTarget c (BlockingVar x [] [] True) + split' CheckEmpty Inductive NoAllowPartialCover DontInsertTrailing c (BlockingVar x [] [] True False) -- Andreas, 2016-05-03, issue 1950: -- Do not introduce trailing pattern vars after split, -- because this does not work for with-clauses. @@ -1189,7 +1278,7 @@ -- @splitLast CoInductive@ is used in the @refine@ tactics. splitLast :: Induction -> Telescope -> [NamedArg DeBruijnPattern] -> TCM (Either SplitError Covering) -splitLast ind tel ps = split ind NoAllowPartialCover sc (BlockingVar 0 [] [] True) +splitLast ind tel ps = split ind NoAllowPartialCover sc (BlockingVar 0 [] [] True False) where sc = SClause tel (toSplitPatterns ps) empty empty Nothing -- | @split ind splitClause x = return res@ @@ -1213,7 +1302,7 @@ -> BlockingVar -> TCM (Either SplitError Covering) split ind allowPartialCover sc x = - fmap blendInAbsurdClause <$> split' NoCheckEmpty ind allowPartialCover YesFixTarget sc x + fmap blendInAbsurdClause <$> split' NoCheckEmpty ind allowPartialCover DoInsertTrailing sc x where n = lookupPatternVar sc $ blockingVarNo x blendInAbsurdClause :: Either SplitClause Covering -> Covering @@ -1258,14 +1347,13 @@ -- 'CoInductive'. -> AllowPartialCover -- ^ Don't fail if computed 'Covering' does not cover all constructors. - -> FixTarget - -- ^ If 'YesFixTarget', introduce new trailing variable patterns via - -- 'fixTarget'. + -> InsertTrailing + -- ^ If 'DoInsertTrailing', introduce new trailing variable patterns. -> SplitClause -> BlockingVar -> TCM (Either SplitError (Either SplitClause Covering)) -split' checkEmpty ind allowPartialCover fixtarget - sc@(SClause tel ps _ cps target) (BlockingVar x pcons' plits overlap) = +split' checkEmpty ind allowPartialCover inserttrailing + sc@(SClause tel ps _ cps target) (BlockingVar x pcons' plits overlap lazy) = liftTCM $ runExceptT $ do debugInit tel x ps cps @@ -1286,9 +1374,13 @@ NoCheckEmpty -> pure cons' mns <- forM cons $ \ con -> fmap (SplitCon con,) <$> computeNeighbourhood delta1 n delta2 d pars ixs x tel ps cps con - hcompsc <- if isHIT then case fixtarget of YesFixTarget -> computeHCompSplit delta1 n delta2 d pars ixs x tel ps cps; _ -> return Nothing - else return Nothing - return $ (dr, catMaybes (mns ++ [hcompsc])) + hcompsc <- if isHIT && inserttrailing == DoInsertTrailing + then computeHCompSplit delta1 n delta2 d pars ixs x tel ps cps + else return Nothing + return ( dr + , not (null ixs) -- Is "d" indexed? + , catMaybes (mns ++ [hcompsc]) + ) computeLitNeighborhoods = do typeOk <- liftTCM $ do @@ -1298,13 +1390,13 @@ ns <- forM plits $ \lit -> do let delta2' = subst 0 (Lit lit) delta2 delta' = delta1 `abstract` delta2' - rho = liftS x $ consS (LitP lit) idS + rho = liftS x $ consS (litP lit) idS ps' = applySubst rho ps cps' = applySplitPSubst rho cps return (SplitLit lit , SClause delta' ps' rho cps' Nothing) ca <- do let delta' = tel -- telescope is unchanged for catchall branch - varp = VarP PatOSplit $ SplitPatVar + varp = VarP (PatternInfo PatOSplit []) $ SplitPatVar { splitPatVarName = underscore , splitPatVarIndex = 0 , splitExcludedLits = plits @@ -1312,17 +1404,26 @@ rho = liftS x $ consS varp $ raiseS 1 ps' = applySubst rho ps return (SplitCatchall , SClause delta' ps' rho cps Nothing) - return (IsData , ns ++ [ ca ]) - (dr, ns) <- if null pcons' && not (null plits) + -- If Agda is changed so that the type of a literal can belong + -- to an inductive family (with at least one index), then the + -- following code should be changed (the constructor False + -- stands for "not indexed"). + return (IsData, False, ns ++ [ ca ]) + + (dr, isIndexed, ns) <- if null pcons' && not (null plits) then computeLitNeighborhoods else computeNeighborhoods - ns <- case fixtarget of - NoFixTarget -> return ns - YesFixTarget -> lift $ forM ns $ \(con,sc) -> - (con,) . snd <$> fixTarget sc{ scTarget = target } + ns <- case target of + Just a -> forM ns $ \ (con, sc) -> lift $ (con,) <$> fixTargetType sc a + Nothing -> return ns + ns <- case inserttrailing of + DontInsertTrailing -> return ns + DoInsertTrailing -> lift $ forM ns $ \(con,sc) -> + (con,) . snd <$> insertTrailingArgs sc + -- Andreas, 2018-10-27, issue #3324; use isPropM. -- Need to reduce sort to decide on Prop. -- Cannot split if domain is a Prop but target is relevant. @@ -1330,10 +1431,16 @@ maybe (return True) (not <.> isPropM) target mHCompName <- getPrimitiveName' builtinHComp + withoutK <- collapseDefault . optWithoutK <$> pragmaOptions + erased <- asksTC hasQuantity0 + reportSLn "tc.cover.split" 60 $ "We are in erased context = " ++ show erased + let erasedError causedByWithoutK = + throwError . ErasedDatatype causedByWithoutK =<< + do liftTCM $ inContextOfT $ buildClosure (unDom t) case ns of [] -> do - let absurdp = VarP PatOAbsurd $ SplitPatVar underscore 0 [] + let absurdp = VarP (PatternInfo PatOAbsurd []) $ SplitPatVar underscore 0 [] rho = liftS x $ consS absurdp $ raiseS 1 ps' = applySubst rho ps return $ Left $ SClause @@ -1350,9 +1457,16 @@ throwError . IrrelevantDatatype =<< do liftTCM $ inContextOfT $ buildClosure (unDom t) -- Andreas, 2018-10-17: If more than one constructor matches, we cannot erase. - (_ : _ : _) | not (usableQuantity t) -> - throwError . ErasedDatatype =<< do liftTCM $ inContextOfT $ buildClosure (unDom t) + (_ : _ : _) | not erased && not (usableQuantity t) -> + erasedError False + -- If exactly one constructor matches and the K rule is turned + -- off, then we only allow erasure for non-indexed data types + -- (#4172). + [_] | not erased && not (usableQuantity t) && + withoutK && isIndexed -> + erasedError True + _ -> do -- Andreas, 2012-10-10 fail if precomputed constructor set does not cover @@ -1378,9 +1492,9 @@ return $ Right $ Covering (lookupPatternVar sc x) ns where - inContextOfT, inContextOfDelta2 :: (MonadTCM tcm, MonadDebug tcm) => tcm a -> tcm a - inContextOfT = addContext tel . escapeContext (x + 1) - inContextOfDelta2 = addContext tel . escapeContext x + inContextOfT, inContextOfDelta2 :: (MonadTCM tcm, MonadAddContext tcm, MonadDebug tcm) => tcm a -> tcm a + inContextOfT = addContext tel . escapeContext __IMPOSSIBLE__ (x + 1) + inContextOfDelta2 = addContext tel . escapeContext __IMPOSSIBLE__ x -- Debug printing debugInit tel x ps cps = liftTCM $ inTopContext $ do @@ -1393,6 +1507,15 @@ , "cps =" <+> prettyTCM cps ] ] + reportSDoc "tc.cover.top" 60 $ vcat + [ "TypeChecking.Coverage.split': split" + , nest 2 $ vcat + [ "tel =" <+> (text . show) tel + , "x =" <+> (text . show) x + , "ps =" <+> (text . show) ps + , "cps =" <+> (text . show) cps + ] + ] debugHoleAndType delta1 delta2 s ps t = liftTCM $ reportSDoc "tc.cover.top" 10 $ nest 2 $ vcat $ @@ -1416,8 +1539,8 @@ splitResultPath :: QName -> SplitClause -> TCM (Maybe SplitClause) splitResultPath f sc@(SClause tel ps _ _ target) = do caseMaybe target (return Nothing) $ \ t -> do - caseMaybeM (isPath (unArg t)) (return Nothing) $ \ _ -> do - (TelV i b, boundary) <- telViewUpToPathBoundary' 1 (unArg t) + caseMaybeM (isPath (unDom t)) (return Nothing) $ \ _ -> do + (TelV i b, boundary) <- telViewUpToPathBoundary' 1 (unDom t) let tel' = abstract tel i rho = raiseS 1 ps' = applySubst rho (scPats sc) ++ telePatterns i boundary @@ -1441,12 +1564,12 @@ -- if we want to split projections, but have no target type, we give up let failure = return . Left caseMaybe target (failure CosplitNoTarget) $ \ t -> do - isR <- addContext tel $ isRecordType $ unArg t + isR <- addContext tel $ isRecordType $ unDom t case isR of Just (_r, vs, Record{ recFields = fs }) -> do reportSDoc "tc.cover" 20 $ sep [ text $ "we are of record type _r = " ++ prettyShow _r - , text "applied to parameters vs = " <+> (addContext tel $ prettyTCM vs) + , text "applied to parameters vs =" <+> (addContext tel $ prettyTCM vs) , text $ "and have fields fs = " ++ prettyShow fs ] -- Andreas, 2018-06-09, issue #2170, we always have irrelevant projections @@ -1458,8 +1581,10 @@ -- Note: module parameters are part of ps let self = defaultArg $ Def f [] `applyE` es pargs = vs ++ [self] - reportSDoc "tc.cover" 20 $ sep - [ text "we are self = " <+> (addContext tel $ prettyTCM $ unArg self) + fieldValues = for fs $ \ proj -> unArg self `applyE` [Proj ProjSystem (unDom proj)] + reportSDoc "tc.cover" 20 $ addContext tel $ sep + [ text "we are self =" <+> prettyTCM (unArg self) + , text " field values =" <+> prettyTCM fieldValues ] let n = defaultArg $ permRange $ fromMaybe __IMPOSSIBLE__ $ dbPatPerm $ fromSplitPatterns ps -- Andreas & James, 2013-11-19 includes the dot patterns! @@ -1469,19 +1594,26 @@ -- Andreas, 2016-07-22 read the style of projections from the user's lips projOrigin <- ifM (optPostfixProjections <$> pragmaOptions) (return ProjPostfix) (return ProjPrefix) Right . Covering n <$> do - forM fs $ \ proj -> do + forM (zip fs $ List.inits fieldValues) $ \ (proj, prevFields) -> do -- compute the new target - dType <- defType <$> do getConstInfo $ unArg proj -- WRONG: typeOfConst $ unArg proj - let -- type of projection instantiated at self - target' = Just $ proj $> dType `piApply` pargs -- Always visible (#2287) - projArg = fmap (Named Nothing . ProjP projOrigin) $ setHiding NotHidden proj + dType <- defType <$> do getConstInfo $ unDom proj -- WRONG: typeOfConst $ unArg proj + let -- Substitution for parameters and previous fields. Needs to be applied to potential + -- tactic in proj. + fieldSub = reverse (map unArg vs ++ prevFields) ++# EmptyS __IMPOSSIBLE__ + proj' = applySubst fieldSub proj + -- type of projection instantiated at self + target' = Just $ proj' $> dType `piApply` pargs -- Always visible (#2287) + projArg = fmap (Named Nothing . ProjP projOrigin) $ argFromDom $ setHiding NotHidden proj sc' = sc { scPats = scPats sc ++ [projArg] , scSubst = idS , scTarget = target' } - return (SplitCon (unArg proj), sc') + reportSDoc "tc.cover.copattern" 40 $ vcat + [ "fieldSub for" <+> prettyTCM (unDom proj) + , nest 2 $ pretty fieldSub ] + return (SplitCon (unDom proj), sc') _ -> addContext tel $ do - buildClosure (unArg t) >>= failure . CosplitNoRecordType + buildClosure (unDom t) >>= failure . CosplitNoRecordType -- Andreas, 2018-06-09, issue #2170: splitting with irrelevant fields is always fine! -- where -- -- A record type is strong if it has all the projections. diff --git a/src/full/Agda/TypeChecking/Coverage/Match.hs b/src/full/Agda/TypeChecking/Coverage/Match.hs --- a/src/full/Agda/TypeChecking/Coverage/Match.hs +++ b/src/full/Agda/TypeChecking/Coverage/Match.hs @@ -1,7 +1,17 @@ -{-# LANGUAGE CPP #-} +{-| Given + 1. the function clauses @cs@ + 2. the patterns @ps@ of the split clause + +we want to compute a variable index (in the split clause) to split on next. + +The matcher here checks whether the split clause is covered by one of +the given clauses @cs@ or whether further splitting is needed (and +when yes, where). +-} + module Agda.TypeChecking.Coverage.Match - ( Match(..), match + ( Match(..), match, matchClause , SplitPattern, SplitPatVar(..), fromSplitPatterns, toSplitPatterns , toSplitPSubst, applySplitPSubst , isTrivialPattern @@ -15,15 +25,12 @@ import Prelude hiding ( null ) import qualified Data.List as List -import Data.Maybe (mapMaybe, isJust, fromMaybe) -import Data.Monoid ( Monoid, mempty, mappend, mconcat ) -import Data.Semigroup ( Semigroup, (<>), Any(..) ) -import Data.Traversable (traverse) +import Data.Maybe (mapMaybe, fromMaybe) +import Data.Semigroup ( Semigroup, (<>)) import Agda.Syntax.Abstract (IsProjP(..)) import Agda.Syntax.Common import Agda.Syntax.Internal -import Agda.Syntax.Internal.Pattern () import Agda.Syntax.Literal import Agda.Syntax.Position @@ -35,41 +42,81 @@ import Agda.TypeChecking.Substitute import Agda.Utils.Null -import Agda.Utils.Permutation import Agda.Utils.Pretty ( Pretty(..), text, (<+>), cat , prettyList_ ) -import qualified Agda.Utils.Pretty as P -import Agda.Utils.Size -import Agda.Utils.List import Agda.Utils.Monad -#include "undefined.h" import Agda.Utils.Impossible -{-| Given +-- | If matching is inconclusive (@Block@) we want to know which +-- variables or projections are blocking the match. +data Match a + = Yes a -- ^ Matches unconditionally. + | No -- ^ Definitely does not match. + | Block + { blockedOnResult :: BlockedOnResult + -- ^ @BlockedOnProj o@ if the clause has a result split. + , blockedOnVars :: BlockingVars + -- ^ @BlockingVar i cs ls o@ means variable @i@ is blocked on + -- constructors @cs@ and literals @ls@. + } + deriving (Functor) - 1. the function clauses @cs@ - 2. the patterns @ps@ +-- | Missing elimination blocking a match. +data BlockedOnResult + = BlockedOnProj -- ^ Blocked on unsplit projection. + { blockedOnResultOverlap :: Bool + -- ^ True if there are also matching clauses without an unsplit + -- copattern. + } + | BlockedOnApply -- ^ Blocked on unintroduced argument. + { blockedOnResultIApply :: ApplyOrIApply + -- ^ Is the unintroduced argument an 'IApply' pattern? + } + | NotBlockedOnResult -we want to compute a variable index of the split clause to split on next. +data ApplyOrIApply = IsApply | IsIApply -First, we find the set @cs'@ of all the clauses that are -instances (via substitutions @rhos@) of the split clause. +-- | Variable blocking a match. +data BlockingVar = BlockingVar + { blockingVarNo :: Nat + -- ^ De Bruijn index of variable blocking the match. + , blockingVarCons :: [ConHead] + -- ^ Constructors in this position. + , blockingVarLits :: [Literal] + -- ^ Literals in this position. + , blockingVarOverlap :: Bool + -- ^ True if at least one clause has a variable pattern in this + -- position. + , blockingVarLazy :: Bool + -- ^ True if at least one clause has a lazy pattern in this position. + } deriving (Show) -In these substitutions, we look for a column that has only constructor patterns. -We try to split on this column first. --} +type BlockingVars = [BlockingVar] -type SplitAssignment = (Nat,SplitPattern) +-- | Substitution of 'SplitPattern's for de Bruijn indices in covering +-- clause to match 'SplitClause'. +type SplitInstantiation = [(Nat,SplitPattern)] --- | Match the given patterns against a list of clauses -match :: (MonadReduce m , HasConstInfo m , HasBuiltins m) => [Clause] -> [NamedArg SplitPattern] -> m (Match (Nat,[SplitAssignment])) +-- | Match the given patterns against a list of clauses. +-- +-- If successful, return the index of the covering clause. +-- +match :: (MonadReduce m , HasConstInfo m , HasBuiltins m) + => [Clause] -- ^ Search for clause that covers the patterns. + -> [NamedArg SplitPattern] -- ^ Patterns of the current 'SplitClause'. + -> m (Match (Nat, SplitInstantiation)) match cs ps = foldr choice (return No) $ zipWith matchIt [0..] cs where - matchIt :: (MonadReduce m , HasConstInfo m , HasBuiltins m) => Nat -> Clause -> m (Match (Nat,[SplitAssignment])) + matchIt :: (MonadReduce m , HasConstInfo m , HasBuiltins m) + => Nat -- ^ Clause number. + -> Clause + -> m (Match (Nat, SplitInstantiation)) matchIt i c = fmap (i,) <$> matchClause ps c -- | For each variable in the patterns of a split clause, we remember the -- de Bruijn-index and the literals excluded by previous matches. + +-- (See issue #708.) data SplitPatVar = SplitPatVar { splitPatVarName :: PatVarName , splitPatVarIndex :: Int @@ -78,10 +125,10 @@ instance Pretty SplitPatVar where prettyPrec _ x = - (text $ patVarNameToString (splitPatVarName x)) P.<> - (text $ "@" ++ show (splitPatVarIndex x)) P.<> + (text $ patVarNameToString (splitPatVarName x)) <> + (text $ "@" ++ show (splitPatVarIndex x)) <> (ifNull (splitExcludedLits x) empty $ \lits -> - "\\{" P.<> prettyList_ lits P.<> "}") + "\\{" <> prettyList_ lits <> "}") instance PrettyTCM SplitPatVar where prettyTCM = prettyTCM . var . splitPatVarIndex @@ -104,10 +151,6 @@ fromSplitPatterns :: [NamedArg SplitPattern] -> [NamedArg DeBruijnPattern] fromSplitPatterns = (fmap . fmap . fmap . fmap) fromSplitVar -instance DeBruijn SplitPattern where - debruijnNamedVar n i = varP $ SplitPatVar n i [] - deBruijnView _ = Nothing - type SplitPSubstitution = Substitution' SplitPattern toSplitPSubst :: PatternSubstitution -> SplitPSubstitution @@ -124,19 +167,19 @@ instance Subst SplitPattern SplitPattern where applySubst IdS p = p applySubst rho p = case p of - VarP o x -> - usePatOrigin o $ + VarP i x -> + usePatternInfo i $ useName (splitPatVarName x) $ useExcludedLits (splitExcludedLits x) $ lookupS rho $ splitPatVarIndex x - DotP o u -> DotP o $ applySplitPSubst rho u + DotP i u -> DotP i $ applySplitPSubst rho u ConP c ci ps -> ConP c ci $ applySubst rho ps - DefP o q ps -> DefP o q $ applySubst rho ps - LitP x -> p + DefP i q ps -> DefP i q $ applySubst rho ps + LitP{} -> p ProjP{} -> p - IApplyP o l r x -> + IApplyP i l r x -> useEndPoints (applySplitPSubst rho l) (applySplitPSubst rho r) $ - usePatOrigin o $ + usePatternInfo i $ useName (splitPatVarName x) $ useExcludedLits (splitExcludedLits x) $ lookupS rho $ splitPatVarIndex x @@ -166,7 +209,7 @@ isTrivialPattern p = case p of VarP{} -> return True DotP{} -> return True - ConP c i ps -> andM $ (isEtaCon $ conName c) + ConP c i ps -> andM $ ((conPLazy i ||) <$> isEtaCon (conName c)) : (map (isTrivialPattern . namedArg) ps) DefP{} -> return False LitP{} -> return False @@ -175,84 +218,42 @@ -- | If matching succeeds, we return the instantiation of the clause pattern vector -- to obtain the split clause pattern vector. -type MatchResult = Match [SplitAssignment] - --- | If matching is inconclusive (@Block@) we want to know which --- variables or projections are blocking the match. -data Match a - = Yes a -- ^ Matches unconditionally. - | No -- ^ Definitely does not match. - | Block - { blockedOnResult :: BlockedOnResult - -- ^ @BlockedOnProj o@ if the clause has a result split - , blockedOnVars :: BlockingVars - -- ^ @BlockingVar i cs ls o@ means variable @i@ is blocked on - -- constructors @cs@ and literals @ls@. - } - deriving (Functor) - -data ApplyOrIApply = IsApply | IsIApply - -data BlockedOnResult - = BlockedOnProj -- ^ Blocked on unsplit projection - { blockedOnResultOverlap :: Bool - -- ^ True if there are also matching clauses without an unsplit - -- copattern. - } - | BlockedOnApply -- ^ Blocked on unintroduced argument - { blockedOnResultIApply :: ApplyOrIApply - -- ^ True if the unintroduced argument was an IApply pattern - } - | NotBlockedOnResult - --- | Variable blocking a match. -data BlockingVar = BlockingVar - { blockingVarNo :: Nat - -- ^ De Bruijn index of variable blocking the match. - , blockingVarCons :: [ConHead] - -- ^ Constructors in this position. - , blockingVarLits :: [Literal] - -- ^ Literals in this position. - , blockingVarOverlap :: Bool - -- ^ True if at least one clause has a variable pattern in this - -- position. - } deriving (Show) +type MatchResult = Match SplitInstantiation instance Pretty BlockingVar where - pretty (BlockingVar i cs ls o) = cat + pretty (BlockingVar i cs ls o l) = cat [ text ("variable " ++ show i) , if null cs then empty else " blocked on constructors" <+> pretty cs , if null ls then empty else " blocked on literals" <+> pretty ls , if o then " (overlapping)" else empty + , if l then " (lazy)" else empty ] -type BlockingVars = [BlockingVar] - yes :: Monad m => a -> m (Match a) yes = return . Yes no :: Monad m => m (Match a) no = return No -blockedOnConstructor :: Monad m => Nat -> ConHead -> m (Match a) -blockedOnConstructor i c = return $ Block NotBlockedOnResult [BlockingVar i [c] [] False] +blockedOnConstructor :: Monad m => Nat -> ConHead -> ConPatternInfo -> m (Match a) +blockedOnConstructor i c ci = return $ Block NotBlockedOnResult [BlockingVar i [c] [] False $ conPLazy ci] blockedOnLiteral :: Monad m => Nat -> Literal -> m (Match a) -blockedOnLiteral i l = return $ Block NotBlockedOnResult [BlockingVar i [] [l] False] +blockedOnLiteral i l = return $ Block NotBlockedOnResult [BlockingVar i [] [l] False False] blockedOnProjection :: Monad m => m (Match a) blockedOnProjection = return $ Block (BlockedOnProj False) [] blockedOnApplication :: Monad m => ApplyOrIApply -> m (Match a) blockedOnApplication b = return $ Block (BlockedOnApply b) [] - --- | Lens for 'blockingVarCons'. -mapBlockingVarCons :: ([ConHead] -> [ConHead]) -> BlockingVar -> BlockingVar -mapBlockingVarCons f b = b { blockingVarCons = f (blockingVarCons b) } - --- | Lens for 'blockingVarLits'. -mapBlockingVarLits :: ([Literal] -> [Literal]) -> BlockingVar -> BlockingVar -mapBlockingVarLits f b = b { blockingVarLits = f (blockingVarLits b) } +--UNUSED Liang-Ting Chen 2019-07-16 +---- | Lens for 'blockingVarCons'. +--mapBlockingVarCons :: ([ConHead] -> [ConHead]) -> BlockingVar -> BlockingVar +--mapBlockingVarCons f b = b { blockingVarCons = f (blockingVarCons b) } +-- +---- | Lens for 'blockingVarLits'. +--mapBlockingVarLits :: ([Literal] -> [Literal]) -> BlockingVar -> BlockingVar +--mapBlockingVarLits f b = b { blockingVarLits = f (blockingVarLits b) } setBlockingVarOverlap :: BlockingVar -> BlockingVar setBlockingVarOverlap = \x -> x { blockingVarOverlap = True } @@ -264,9 +265,9 @@ zipBlockingVars :: BlockingVars -> BlockingVars -> BlockingVars zipBlockingVars xs ys = map upd xs where - upd (BlockingVar x cons lits o) = case List.find ((x ==) . blockingVarNo) ys of - Just (BlockingVar _ cons' lits' o') -> BlockingVar x (cons ++ cons') (lits ++ lits') (o || o') - Nothing -> BlockingVar x cons lits True + upd (BlockingVar x cons lits o l) = case List.find ((x ==) . blockingVarNo) ys of + Just (BlockingVar _ cons' lits' o' l') -> BlockingVar x (cons ++ cons') (lits ++ lits') (o || o') (l || l') + Nothing -> BlockingVar x cons lits True l setBlockedOnResultOverlap :: BlockedOnResult -> BlockedOnResult setBlockedOnResultOverlap b = case b of @@ -284,9 +285,8 @@ choiceBlockedOnResult :: BlockedOnResult -> BlockedOnResult -> BlockedOnResult choiceBlockedOnResult b1 b2 = case (b1,b2) of (NotBlockedOnResult , _ ) -> NotBlockedOnResult - (BlockedOnProj _ , NotBlockedOnResult) -> BlockedOnProj True (BlockedOnProj o1 , BlockedOnProj o2 ) -> BlockedOnProj (o1 || o2) - (BlockedOnProj o1 , BlockedOnApply{} ) -> BlockedOnProj True + (BlockedOnProj _ , _ ) -> BlockedOnProj True (BlockedOnApply b , _ ) -> BlockedOnApply b -- | @choice m m'@ combines the match results @m@ of a function clause @@ -386,13 +386,14 @@ -- | @matchPat p q@ checks whether a function clause pattern @p@ -- covers a split clause pattern @q@. There are three results: --- @Yes rs@ means it covers, because @p@ is a variable pattern. @rs@ collects --- the instantiations of the variables in @p@ s.t. @p[rs] = q@. --- @No@ means it does not cover. --- @Block [x]@ means @p@ is a proper instance of @q@ and could become --- a cover if @q@ was split on variable @x@. --- @BlockLit [x] means @p@ is a proper instance of @q@ and could become --- a cover if variable @x@ is instantiated with an appropriate literal. +-- +-- 1. @Yes rs@ means it covers, because @p@ is a variable pattern. @rs@ collects +-- the instantiations of the variables in @p@ s.t. @p[rs] = q@. +-- +-- 2. @No@ means it does not cover. +-- +-- 3. @Block [x]@ means @p@ is a proper instance of @q@ and could become +-- a cover if @q@ was split on variable @x@. matchPat :: (MonadReduce m , HasConstInfo m , HasBuiltins m, DeBruijn a) @@ -405,61 +406,68 @@ -- If 'Yes', also the instantiation @rs@ of the clause pattern variables -- to produce the split clause pattern, @p[rs] = q@. matchPat p q = case p of + VarP _ x -> yes [(fromMaybe __IMPOSSIBLE__ (deBruijnView x),q)] + DotP{} -> yes [] -- Jesper, 2014-11-04: putting 'Yes [q]' here triggers issue 1333. -- Not checking for trivial patterns should be safe here, as dot patterns are -- guaranteed to match if the rest of the pattern does, so some extra splitting -- on them doesn't change the reduction behaviour. - p@(LitP l) -> case q of + + p@(LitP _ l) -> case q of VarP _ x -> if l `elem` splitExcludedLits x then no else blockedOnLiteral (splitPatVarIndex x) l _ -> isLitP q >>= \case Just l' -> if l == l' then yes [] else no Nothing -> no + ProjP _ d -> case q of ProjP _ d' -> do d <- getOriginalProjection d if d == d' then yes [] else no _ -> __IMPOSSIBLE__ + IApplyP _ _ _ x -> yes [(fromMaybe __IMPOSSIBLE__ (deBruijnView x),q)] - ConP c _ ps -> unDotP q >>= \case - VarP _ x -> blockedOnConstructor (splitPatVarIndex x) c + + -- Issue #4179: If the inferred pattern is a literal + -- v we need to turn it into a constructor pattern. + ConP c ci ps -> unDotP q >>= unLitP >>= \case + VarP _ x -> blockedOnConstructor (splitPatVarIndex x) c ci ConP c' i qs | c == c' -> matchPats ps qs | otherwise -> no DotP o t -> no - LitP l -> isLitP p >>= \case - Just l' -> if l == l' then yes [] else no - Nothing -> no DefP{} -> no + LitP{} -> __IMPOSSIBLE__ -- excluded by typing and unLitP ProjP{} -> __IMPOSSIBLE__ -- excluded by typing - IApplyP _ _ _ x -> blockedOnConstructor (splitPatVarIndex x) c - (DefP o c ps) -> unDotP q >>= \case + IApplyP _ _ _ x -> blockedOnConstructor (splitPatVarIndex x) c ci + + DefP o c ps -> unDotP q >>= \case VarP _ x -> __IMPOSSIBLE__ -- blockedOnConstructor (splitPatVarIndex x) c ConP c' i qs -> no DotP o t -> no - LitP _ -> no + LitP{} -> no DefP o c' qs | c == c' -> matchPats ps qs | otherwise -> no ProjP{} -> __IMPOSSIBLE__ -- excluded by typing - IApplyP _ _ _ x -> __IMPOSSIBLE__ --blockedOnConstructor (splitPatVarIndex x) c + IApplyP _ _ _ x -> __IMPOSSIBLE__ -- blockedOnConstructor (splitPatVarIndex x) c --- unfold one level of a dot pattern to a proper pattern if possible -unDotP :: (MonadReduce m, DeBruijn (Pattern' a)) => Pattern' a -> m (Pattern' a) +-- | Unfold one level of a dot pattern to a proper pattern if possible. +unDotP :: (MonadReduce m, DeBruijn a) => Pattern' a -> m (Pattern' a) unDotP (DotP o v) = reduce v >>= \case Var i [] -> return $ deBruijnVar i Con c _ vs -> do let ps = map (fmap $ unnamed . DotP o) $ fromMaybe __IMPOSSIBLE__ $ allApplyElims vs return $ ConP c noConPatternInfo ps - Lit l -> return $ LitP l + Lit l -> return $ LitP (PatternInfo PatODot []) l v -> return $ dotP v unDotP p = return p isLitP :: (MonadReduce m, HasBuiltins m) => Pattern' a -> m (Maybe Literal) -isLitP (LitP l) = return $ Just l +isLitP (LitP _ l) = return $ Just l isLitP (DotP _ u) = reduce u >>= \case Lit l -> return $ Just l _ -> return $ Nothing @@ -476,3 +484,14 @@ inc (LitNat r n) = LitNat (fuseRange c r) $ n + 1 inc _ = __IMPOSSIBLE__ isLitP _ = return Nothing + +unLitP :: HasBuiltins m => Pattern' a -> m (Pattern' a) +unLitP (LitP info l@(LitNat _ n)) | n >= 0 = do + Con c ci es <- constructorForm' (fromMaybe __IMPOSSIBLE__ <$> getBuiltin' builtinZero) + (fromMaybe __IMPOSSIBLE__ <$> getBuiltin' builtinSuc) + (Lit l) + let toP (Apply (Arg i (Lit l))) = Arg i (LitP info l) + toP _ = __IMPOSSIBLE__ + cpi = noConPatternInfo { conPInfo = info } + return $ ConP c cpi $ map (fmap unnamed . toP) es +unLitP p = return p diff --git a/src/full/Agda/TypeChecking/Coverage/SplitTree.hs b/src/full/Agda/TypeChecking/Coverage/SplitTree.hs --- a/src/full/Agda/TypeChecking/Coverage/SplitTree.hs +++ b/src/full/Agda/TypeChecking/Coverage/SplitTree.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE DeriveDataTypeable #-} {-| Split tree for transforming pattern clauses into case trees. @@ -15,18 +14,17 @@ module Agda.TypeChecking.Coverage.SplitTree where import Data.Tree -import Data.Data (Data, toConstr) +import Data.Data (Data) import Agda.Syntax.Abstract.Name import Agda.Syntax.Common -import Agda.Syntax.Internal as I +import Agda.Syntax.Concrete.Pretty () --instance only import Agda.Syntax.Literal import Agda.Syntax.Position -import Agda.Utils.Monad import Agda.Utils.Pretty +import Agda.Utils.Null -#include "undefined.h" import Agda.Utils.Impossible type SplitTree = SplitTree' SplitTag @@ -42,10 +40,14 @@ | -- | A split is necessary. SplitAt { splitArg :: Arg Int -- ^ Arg. no to split at. + , splitLazy :: LazySplit , splitTrees :: SplitTrees' a -- ^ Sub split trees. } deriving (Data, Show) +data LazySplit = LazySplit | StrictSplit + deriving (Data, Show, Eq, Ord) + -- | Split tree branching. A finite map from constructor names to splittrees -- A list representation seems appropriate, since we are expecting not -- so many constructors per data type, and there is no need for @@ -62,7 +64,7 @@ deriving (Show, Eq, Ord, Data) instance Pretty SplitTag where - pretty (SplitCon c) = pretty c + pretty (SplitCon c) = pretty c pretty (SplitLit l) = pretty l pretty SplitCatchall = underscore @@ -71,21 +73,24 @@ data SplitTreeLabel a = SplitTreeLabel { lblConstructorName :: Maybe a -- ^ 'Nothing' for root of split tree , lblSplitArg :: Maybe (Arg Int) + , lblLazy :: LazySplit , lblBindings :: Maybe Int } instance Pretty a => Pretty (SplitTreeLabel a) where pretty = \case - SplitTreeLabel Nothing Nothing (Just n) -> text $ "done, " ++ prettyShow n ++ " bindings" - SplitTreeLabel Nothing (Just n) Nothing -> text $ "split at " ++ prettyShow n - SplitTreeLabel (Just q) Nothing (Just n) -> pretty q <+> text (" -> done, " ++ prettyShow n ++ " bindings") - SplitTreeLabel (Just q) (Just n) Nothing -> pretty q <+> text (" -> split at " ++ prettyShow n) + SplitTreeLabel Nothing Nothing _ (Just n) -> text $ "done, " ++ prettyShow n ++ " bindings" + SplitTreeLabel Nothing (Just n) lz Nothing -> lzp lz <+> text ("split at " ++ prettyShow n) + SplitTreeLabel (Just q) Nothing _ (Just n) -> pretty q <+> text ("-> done, " ++ prettyShow n ++ " bindings") + SplitTreeLabel (Just q) (Just n) lz Nothing -> pretty q <+> text "->" <+> lzp lz <+> text ("split at " ++ prettyShow n) _ -> __IMPOSSIBLE__ + where lzp lz | lz == LazySplit = "lazy" + | otherwise = empty -- | Convert a split tree into a 'Data.Tree' (for printing). toTree :: SplitTree' a -> Tree (SplitTreeLabel a) toTree t = case t of - SplittingDone n -> Node (SplitTreeLabel Nothing Nothing (Just n)) [] - SplitAt n ts -> Node (SplitTreeLabel Nothing (Just n) Nothing) $ toTrees ts + SplittingDone n -> Node (SplitTreeLabel Nothing Nothing StrictSplit (Just n)) [] + SplitAt n lz ts -> Node (SplitTreeLabel Nothing (Just n) lz Nothing) $ toTrees ts toTrees :: SplitTrees' a -> Forest (SplitTreeLabel a) toTrees = map (\ (c,t) -> setCons c $ toTree t) @@ -105,4 +110,4 @@ instance KillRange a => KillRange (SplitTree' a) where killRange = \case SplittingDone n -> SplittingDone n - SplitAt i ts -> killRange1 (SplitAt i) ts + SplitAt i lz ts -> killRange1 (SplitAt i lz) ts diff --git a/src/full/Agda/TypeChecking/Datatypes.hs b/src/full/Agda/TypeChecking/Datatypes.hs --- a/src/full/Agda/TypeChecking/Datatypes.hs +++ b/src/full/Agda/TypeChecking/Datatypes.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} module Agda.TypeChecking.Datatypes where @@ -17,11 +16,9 @@ import Agda.TypeChecking.Pretty import Agda.Utils.Either -import Agda.Utils.Functor import Agda.Utils.Pretty ( prettyShow ) import Agda.Utils.Size -#include "undefined.h" import Agda.Utils.Impossible --------------------------------------------------------------------------- @@ -78,9 +75,10 @@ -- @Nothing@ if @t@ is not a data/record type or does not have -- a constructor @c@. getConType - :: ConHead -- ^ Constructor. + :: (MonadReduce m, MonadAddContext m, HasConstInfo m, MonadDebug m) + => ConHead -- ^ Constructor. -> Type -- ^ Ending in data/record type. - -> TCM (Maybe ((QName, Type, Args), Type)) + -> m (Maybe ((QName, Type, Args), Type)) -- ^ @Nothing@ if not ends in data or record type. -- -- @Just ((d, dt, pars), ct)@ otherwise, where @@ -158,14 +156,14 @@ data ConstructorInfo = DataCon Nat -- ^ Arity. - | RecordCon HasEta [Arg QName] -- ^ List of field names. + | RecordCon HasEta [Dom QName] -- ^ List of field names. -- | Return the number of non-parameter arguments to a data constructor, -- or the field names of a record constructor. -- -- For getting just the arity of constructor @c@, -- use @either id size <$> getConstructorArity c@. -getConstructorInfo :: QName -> TCM ConstructorInfo +getConstructorInfo :: HasConstInfo m => QName -> m ConstructorInfo getConstructorInfo c = do (theDef <$> getConstInfo c) >>= \case Constructor{ conData = d, conArity = n } -> do @@ -238,14 +236,22 @@ -- | 'Nothing' if not data or record type name. getConHeads' :: QName -> TCM (Maybe [ConHead]) -getConHeads' d = getConHeads_ . theDef <$> getConstInfo d +getConHeads' d = theDef <$> getConstInfo d >>= \case + Record{recConHead = h} -> return $ Just [h] + Datatype{dataCons = cs} -> Just <$> mapM makeConHead cs + _ -> return $ Nothing --- | 'Nothing' if not data or record definition. -getConHeads_ :: Defn -> Maybe [ConHead] -getConHeads_ = \case - Datatype{dataCons = cs} -> Just $ map (\ c -> ConHead c Inductive []) cs - Record{recConHead = h} -> Just [h] - _ -> Nothing +-- | Fills in the fields. +makeConHead :: QName -> TCM ConHead +makeConHead c = do + def <- getConstInfo c + case theDef def of + Constructor{conPars = n, conProj = Just fs} -> do + TelV tel _ <- telView (defType def) + let ai = map getArgInfo $ drop n $ telToList tel + return $ ConHead c Inductive $ zipWith Arg ai fs + Constructor{conProj = Nothing} -> return $ ConHead c Inductive [] + _ -> __IMPOSSIBLE__ {- UNUSED data DatatypeInfo = DataInfo diff --git a/src/full/Agda/TypeChecking/Datatypes.hs-boot b/src/full/Agda/TypeChecking/Datatypes.hs-boot --- a/src/full/Agda/TypeChecking/Datatypes.hs-boot +++ b/src/full/Agda/TypeChecking/Datatypes.hs-boot @@ -1,7 +1,6 @@ module Agda.TypeChecking.Datatypes where -import Agda.TypeChecking.Monad.Base import Agda.TypeChecking.Monad.Signature import Agda.Syntax.Internal diff --git a/src/full/Agda/TypeChecking/DeadCode.hs b/src/full/Agda/TypeChecking/DeadCode.hs --- a/src/full/Agda/TypeChecking/DeadCode.hs +++ b/src/full/Agda/TypeChecking/DeadCode.hs @@ -1,37 +1,24 @@ -{-# LANGUAGE CPP #-} module Agda.TypeChecking.DeadCode (eliminateDeadCode) where -import Control.Monad -import Data.Map (Map) import qualified Data.Map as Map import Data.Set (Set) import qualified Data.Set as Set -import Data.Foldable (foldMap, Foldable) import Data.Traversable (traverse) +import qualified Data.HashMap.Strict as HMap -import Agda.Syntax.Common -import Agda.Syntax.Literal -import qualified Agda.Syntax.Concrete as C import qualified Agda.Syntax.Abstract as A import Agda.Syntax.Internal import Agda.Syntax.Internal.Names import Agda.Syntax.Scope.Base -import Agda.Syntax.Scope.Monad import qualified Agda.Benchmarking as Bench import qualified Agda.TypeChecking.Monad.Benchmark as Bench import Agda.TypeChecking.Monad -import Agda.TypeChecking.CompiledClause import Agda.TypeChecking.Reduce -import Agda.Utils.HashMap (HashMap) -import qualified Agda.Utils.HashMap as HMap import Agda.Utils.Lens - -import Agda.Utils.Impossible -#include "undefined.h" -- | Run before serialisation to remove any definitions that are not reachable -- from the public interface to the module. diff --git a/src/full/Agda/TypeChecking/DisplayForm.hs b/src/full/Agda/TypeChecking/DisplayForm.hs --- a/src/full/Agda/TypeChecking/DisplayForm.hs +++ b/src/full/Agda/TypeChecking/DisplayForm.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE UndecidableInstances #-} -- for Arg a => Elim' a -- | Tools for 'DisplayTerm' and 'DisplayForm'. @@ -10,7 +9,6 @@ import Control.Monad.Trans (lift) import Control.Monad.Trans.Maybe import Data.Foldable (all) -import qualified Data.Set as Set import qualified Data.Map as Map import Agda.Syntax.Common @@ -19,18 +17,16 @@ import Agda.Syntax.Scope.Base (inverseScopeLookupName) import Agda.TypeChecking.Monad +import Agda.TypeChecking.Monad.Builtin (HasBuiltins(..)) import Agda.TypeChecking.Substitute import Agda.TypeChecking.Level import Agda.TypeChecking.Reduce (instantiate) -import Agda.Utils.Except import Agda.Utils.Functor -import Agda.Utils.Lens import Agda.Utils.List import Agda.Utils.Maybe import Agda.Utils.Pretty -#include "undefined.h" import Agda.Utils.Impossible -- | Convert a 'DisplayTerm' into a 'Term'. @@ -44,14 +40,22 @@ DTerm v -> v -- | Get the arities of all display forms for a name. -displayFormArities :: QName -> TCM [Int] +displayFormArities :: (HasConstInfo m, ReadTCState m) => QName -> m [Int] displayFormArities q = map (length . dfPats . dget) <$> getDisplayForms q +type MonadDisplayForm m = + ( MonadReduce m + , ReadTCState m + , HasConstInfo m + , HasBuiltins m + , MonadDebug m + ) + -- | Find a matching display form for @q es@. -- In essence this tries to rewrite @q es@ with any -- display form @q ps --> dt@ and returns the instantiated -- @dt@ if successful. First match wins. -displayForm :: QName -> Elims -> TCM (Maybe DisplayTerm) +displayForm :: MonadDisplayForm m => QName -> Elims -> m (Maybe DisplayTerm) displayForm q es = do -- Get display forms for name q. odfs <- getDisplayForms q @@ -77,15 +81,15 @@ return [ m | Just (d, m) <- ms, wellScoped scope d ] -- Not safe when printing non-terminating terms. -- (nfdfs, us) <- normalise (dfs, es) - unlessDebugPrinting $ reportSLn "tc.display.top" 100 $ unlines + unlessDebugPrinting $ reportS "tc.display.top" 100 [ "name : " ++ prettyShow q , "displayForms: " ++ show dfs , "arguments : " ++ show es , "matches : " ++ show ms - , "result : " ++ show (headMaybe ms) + , "result : " ++ show (listToMaybe ms) ] -- Return the first display form that matches. - return $ headMaybe ms + return $ listToMaybe ms where -- Look at the original display form, not the instantiated result when -- checking if it's well-scoped. Otherwise we might pick up out of scope @@ -102,7 +106,8 @@ -- | Match a 'DisplayForm' @q ps = v@ against @q es@. -- Return the 'DisplayTerm' @v[us]@ if the match was successful, -- i.e., @es / ps = Just us@. -matchDisplayForm :: DisplayForm -> Elims -> MaybeT TCM (DisplayForm, DisplayTerm) +matchDisplayForm :: MonadDisplayForm m + => DisplayForm -> Elims -> MaybeT m (DisplayForm, DisplayTerm) matchDisplayForm d@(Display _ ps v) es | length ps > length es = mzero | otherwise = do @@ -126,7 +131,7 @@ -- (It has been substituted by __IMPOSSIBLE__ which corresponds to -- a raise by -1). class Match a where - match :: a -> a -> MaybeT TCM [WithOrigin Term] + match :: MonadDisplayForm m => a -> a -> MaybeT m [WithOrigin Term] instance Match a => Match [a] where match xs ys = concat <$> zipWithM match xs ys diff --git a/src/full/Agda/TypeChecking/DropArgs.hs b/src/full/Agda/TypeChecking/DropArgs.hs --- a/src/full/Agda/TypeChecking/DropArgs.hs +++ b/src/full/Agda/TypeChecking/DropArgs.hs @@ -1,8 +1,7 @@ -{-# LANGUAGE CPP #-} module Agda.TypeChecking.DropArgs where -import Control.Arrow (first, second) +import Control.Arrow (second) import Agda.Syntax.Common import Agda.Syntax.Internal @@ -16,7 +15,6 @@ import Agda.Utils.Functor import Agda.Utils.Permutation -#include "undefined.h" import Agda.Utils.Impossible --------------------------------------------------------------------------- @@ -77,5 +75,5 @@ instance DropArgs SplitTree where dropArgs n (SplittingDone m) = SplittingDone (m - n) - dropArgs n (SplitAt i ts) = SplitAt (subtract n <$> i) $ map (second $ dropArgs n) ts + dropArgs n (SplitAt i lz ts) = SplitAt (subtract n <$> i) lz $ map (second $ dropArgs n) ts diff --git a/src/full/Agda/TypeChecking/Empty.hs b/src/full/Agda/TypeChecking/Empty.hs --- a/src/full/Agda/TypeChecking/Empty.hs +++ b/src/full/Agda/TypeChecking/Empty.hs @@ -1,22 +1,23 @@ -module Agda.TypeChecking.Empty where +module Agda.TypeChecking.Empty + ( isEmptyType + , isEmptyTel + , ensureEmptyType + , checkEmptyTel + ) where import Control.Monad.Except import Data.Semigroup -import Data.Monoid import Agda.Syntax.Common import Agda.Syntax.Internal -import Agda.Syntax.Internal.Pattern import Agda.Syntax.Position import Agda.TypeChecking.Monad import Agda.TypeChecking.Coverage import Agda.TypeChecking.Coverage.Match ( fromSplitPatterns ) -import Agda.TypeChecking.Constraints import Agda.TypeChecking.Records -import Agda.TypeChecking.Reduce import Agda.TypeChecking.Substitute import Agda.TypeChecking.Telescope diff --git a/src/full/Agda/TypeChecking/Empty.hs-boot b/src/full/Agda/TypeChecking/Empty.hs-boot --- a/src/full/Agda/TypeChecking/Empty.hs-boot +++ b/src/full/Agda/TypeChecking/Empty.hs-boot @@ -1,5 +1,10 @@ -module Agda.TypeChecking.Empty where +module Agda.TypeChecking.Empty + ( isEmptyType + , isEmptyTel + , ensureEmptyType + , checkEmptyTel + ) where import Agda.TypeChecking.Monad (TCM) import Agda.Syntax.Internal (Type, Telescope) diff --git a/src/full/Agda/TypeChecking/Errors.hs b/src/full/Agda/TypeChecking/Errors.hs --- a/src/full/Agda/TypeChecking/Errors.hs +++ b/src/full/Agda/TypeChecking/Errors.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE NondecreasingIndentation #-} {-# OPTIONS_GHC -fno-warn-orphans #-} @@ -13,74 +12,57 @@ , applyFlagsToTCWarnings' , applyFlagsToTCWarnings , dropTopLevelModule + , topLevelModuleDropper , stringTCErr - , sayWhen ) where -#if MIN_VERSION_base(4,11,0) -import Prelude hiding ( (<>), null ) -#else import Prelude hiding ( null ) -#endif -import Control.Monad.Reader -import Control.Monad.State - import Data.Function -import Data.List (nub, sortBy, intersperse, isInfixOf, dropWhileEnd) +import Data.List (sortBy, isInfixOf, dropWhileEnd) +import Data.List.NonEmpty (NonEmpty(..)) +import qualified Data.List.NonEmpty as NonEmpty import Data.Maybe import Data.Char (toLower) import qualified Data.Set as Set -import qualified Data.Map as Map import qualified Text.PrettyPrint.Boxes as Boxes -import {-# SOURCE #-} Agda.Interaction.Imports (MainInterface(..)) -import Agda.Interaction.Options -import Agda.Interaction.Options.Warnings import Agda.Syntax.Common +import Agda.Syntax.Concrete.Pretty (prettyHiding, prettyRelevance) import Agda.Syntax.Fixity import Agda.Syntax.Notation import Agda.Syntax.Position -import qualified Agda.Syntax.Info as A import qualified Agda.Syntax.Concrete as C -import qualified Agda.Syntax.Concrete.Definitions as D import Agda.Syntax.Abstract as A -import Agda.Syntax.Abstract.Views (deepUnscope) import Agda.Syntax.Internal as I import Agda.Syntax.Translation.InternalToAbstract -import Agda.Syntax.Translation.AbstractToConcrete -import Agda.Syntax.Scope.Monad (isDatatypeModule, withContextPrecedence) +import Agda.Syntax.Scope.Monad (isDatatypeModule) import Agda.Syntax.Scope.Base + import Agda.TypeChecking.Monad.Base import Agda.TypeChecking.Monad.Closure import Agda.TypeChecking.Monad.Context import Agda.TypeChecking.Monad.Debug -import Agda.TypeChecking.Monad.Options import Agda.TypeChecking.Monad.Builtin +import Agda.TypeChecking.Monad.SizedTypes ( sizeType ) import Agda.TypeChecking.Monad.State -import Agda.TypeChecking.Monad.MetaVars -import Agda.TypeChecking.Positivity import Agda.TypeChecking.Pretty +import Agda.TypeChecking.Pretty.Call +import Agda.TypeChecking.Pretty.Warning import Agda.TypeChecking.Substitute import Agda.TypeChecking.Telescope ( ifPiType ) import Agda.TypeChecking.Reduce (instantiate) -import Agda.TypeChecking.Warnings -import Agda.Utils.Except ( MonadError(catchError, throwError) ) +import Agda.Utils.Except ( MonadError(catchError) ) import Agda.Utils.FileName +import Agda.Utils.Float ( toStringWithoutDotZero ) import Agda.Utils.Function -import Agda.Utils.Functor -import Agda.Utils.Lens -import Agda.Utils.List import Agda.Utils.Maybe -import Agda.Utils.Monad import Agda.Utils.Null -import Agda.Utils.NonemptyList import Agda.Utils.Pretty ( prettyShow ) import qualified Agda.Utils.Pretty as P import Agda.Utils.Size -#include "undefined.h" import Agda.Utils.Impossible --------------------------------------------------------------------------- @@ -102,241 +84,13 @@ `catchError` \ err' -> prettyError' err' (err:errs) --------------------------------------------------------------------------- --- * Warnings ---------------------------------------------------------------------------- - -instance PrettyTCM TCWarning where - prettyTCM = return . tcWarningPrintedWarning - -instance PrettyTCM Warning where - prettyTCM = prettyWarning - -{-# SPECIALIZE prettyWarning :: Warning -> TCM Doc #-} -prettyWarning :: MonadTCM tcm => Warning -> tcm Doc -prettyWarning wng = liftTCM $ case wng of - - UnsolvedMetaVariables ms -> - fsep ( pwords "Unsolved metas at the following locations:" ) - $$ nest 2 (vcat $ map prettyTCM ms) - - UnsolvedInteractionMetas is -> - fsep ( pwords "Unsolved interaction metas at the following locations:" ) - $$ nest 2 (vcat $ map prettyTCM is) - - UnsolvedConstraints cs -> - fsep ( pwords "Failed to solve the following constraints:" ) - $$ nest 2 (P.vcat . nub <$> mapM prettyConstraint cs) - - where prettyConstraint :: ProblemConstraint -> TCM Doc - prettyConstraint c = f (prettyTCM c) - where - r = getRange c - f d = if null $ P.pretty r - then d - else d $$ nest 4 ("[ at" <+> prettyTCM r <+> "]") - - TerminationIssue because -> do - dropTopLevel <- topLevelModuleDropper - fwords "Termination checking failed for the following functions:" - $$ (nest 2 $ fsep $ punctuate comma $ - map (pretty . dropTopLevel) $ - concatMap termErrFunctions because) - $$ fwords "Problematic calls:" - $$ (nest 2 $ fmap (P.vcat . nub) $ - mapM prettyTCM $ sortBy (compare `on` callInfoRange) $ - concatMap termErrCalls because) - - UnreachableClauses f pss -> fsep $ - pwords "Unreachable" ++ pwords (plural (length pss) "clause") - where - plural 1 thing = thing - plural n thing = thing ++ "s" - - CoverageIssue f pss -> fsep ( - pwords "Incomplete pattern matching for" ++ [prettyTCM f <> "."] ++ - pwords "Missing cases:") $$ nest 2 (vcat $ map display pss) - where - display (tel, ps) = prettyTCM $ NamedClause f True $ - empty { clauseTel = tel, namedClausePats = ps } - - CoverageNoExactSplit f cs -> vcat $ - [ fsep $ pwords "Exact splitting is enabled, but the following" ++ pwords (singPlural cs "clause" "clauses") ++ - pwords "could not be preserved as definitional equalities in the translation to a case tree:" - ] ++ - map (nest 2 . prettyTCM . NamedClause f True) cs - - NotStrictlyPositive d ocs -> fsep $ - [prettyTCM d] ++ pwords "is not strictly positive, because it occurs" - ++ [prettyTCM ocs] - - CantGeneralizeOverSorts ms -> vcat - [ text "Cannot generalize over unsolved sort metas:" - , nest 2 $ vcat [ prettyTCM x <+> text "at" <+> (pretty =<< getMetaRange x) | x <- ms ] - , fsep $ pwords "Suggestion: add a `variable Any : Set _` and replace unsolved metas by Any" - ] - - AbsurdPatternRequiresNoRHS ps -> fwords $ - "The right-hand side must be omitted if there " ++ - "is an absurd pattern, () or {}, in the left-hand side." - - OldBuiltin old new -> fwords $ - "Builtin " ++ old ++ " no longer exists. " ++ - "It is now bound by BUILTIN " ++ new - - EmptyRewritePragma -> fsep . pwords $ "Empty REWRITE pragma" - - IllformedAsClause s -> fsep . pwords $ - "`as' must be followed by an identifier" ++ s - - UselessPublic -> fwords $ "Keyword `public' is ignored here" - - UselessInline q -> fsep $ - pwords "It is pointless for INLINE'd function" ++ [prettyTCM q] ++ - pwords "to have a separate Haskell definition" - - WrongInstanceDeclaration -> fwords "Terms marked as eligible for instance search should end with a name, so `instance' is ignored here." - - InstanceWithExplicitArg q -> fsep $ - pwords "Instance declarations with explicit arguments are never considered by instance search," ++ - pwords "so making" ++ [prettyTCM q] ++ pwords "into an instance has no effect." - - InstanceNoOutputTypeName b -> fsep $ - pwords "Instance arguments whose type does not end in a named or variable type are never considered by instance search," ++ - pwords "so having an instance argument" ++ [return b] ++ pwords "has no effect." - - InstanceArgWithExplicitArg b -> fsep $ - pwords "Instance arguments with explicit arguments are never considered by instance search," ++ - pwords "so having an instance argument" ++ [return b] ++ pwords "has no effect." - - InversionDepthReached f -> do - maxDepth <- maxInversionDepth - fsep $ pwords "Refusing to invert pattern matching of" ++ [prettyTCM f] ++ - pwords ("because the maximum depth (" ++ show maxDepth ++ ") has been reached.") ++ - pwords "Most likely this means you have an unsatisfiable constraint, but it could" ++ - pwords "also mean that you need to increase the maximum depth using the flag" ++ - pwords "--inversion-max-depth=N" - - GenericWarning d -> return d - - GenericNonFatalError d -> return d - - SafeFlagPostulate e -> fsep $ - pwords "Cannot postulate" ++ [pretty e] ++ pwords "with safe flag" - - SafeFlagPragma xs -> - let plural | length xs == 1 = "" - | otherwise = "s" - in fsep $ [fwords ("Cannot set OPTIONS pragma" ++ plural)] - ++ map text xs ++ [fwords "with safe flag."] - - SafeFlagNonTerminating -> fsep $ - pwords "Cannot use NON_TERMINATING pragma with safe flag." - - SafeFlagTerminating -> fsep $ - pwords "Cannot use TERMINATING pragma with safe flag." - - SafeFlagWithoutKFlagPrimEraseEquality -> fsep (pwords "Cannot use primEraseEquality with safe and without-K flags.") - - WithoutKFlagPrimEraseEquality -> fsep (pwords "Using primEraseEquality implies K, but you have the without-K flag enabled.") - - SafeFlagNoPositivityCheck -> fsep $ - pwords "Cannot use NO_POSITIVITY_CHECK pragma with safe flag." - - SafeFlagPolarity -> fsep $ - pwords "Cannot use POLARITY pragma with safe flag." - - SafeFlagNoUniverseCheck -> fsep $ - pwords "Cannot use NO_UNIVERSE_CHECK pragma with safe flag." - - ParseWarning pw -> pretty pw - - DeprecationWarning old new version -> fsep $ - [text old] ++ pwords "has been deprecated. Use" ++ [text new] ++ pwords - "instead. This will be an error in Agda" ++ [text version <> "."] - - NicifierIssue w -> sayWhere (getRange w) $ pretty w - - UserWarning str -> text str - - ModuleDoesntExport m xs -> fsep $ - pwords "The module" ++ [pretty m] ++ pwords "doesn't export the following:" ++ - punctuate comma (map pretty xs) - - LibraryWarning lw -> pretty lw - - InfectiveImport o m -> fsep $ - pwords "Importing module" ++ [pretty m] ++ pwords "using the" ++ - [pretty o] ++ pwords "flag from a module which does not." - - CoInfectiveImport o m -> fsep $ - pwords "Importing module" ++ [pretty m] ++ pwords "not using the" ++ - [pretty o] ++ pwords "flag from a module which does." - -prettyTCWarnings :: [TCWarning] -> TCM String -prettyTCWarnings = fmap (unlines . intersperse "") . prettyTCWarnings' - -prettyTCWarnings' :: [TCWarning] -> TCM [String] -prettyTCWarnings' = mapM (fmap show . prettyTCM) - --- | Turns all warnings into errors. -tcWarningsToError :: [TCWarning] -> TCM a -tcWarningsToError ws = typeError $ case ws of - [] -> SolvedButOpenHoles - _ -> NonFatalErrors ws - - --- | Depending which flags are set, one may happily ignore some --- warnings. - -applyFlagsToTCWarnings' :: MainInterface -> [TCWarning] -> TCM [TCWarning] -applyFlagsToTCWarnings' isMain ws = do - - -- For some reason some SafeFlagPragma seem to be created multiple times. - -- This is a way to collect all of them and remove duplicates. - let pragmas w = case tcWarning w of { SafeFlagPragma ps -> ([w], ps); _ -> ([], []) } - let sfp = case fmap nub (foldMap pragmas ws) of - (TCWarning r w p b:_, sfp) -> - [TCWarning r (SafeFlagPragma sfp) p b] - _ -> [] - - warnSet <- do - opts <- pragmaOptions - let warnSet = optWarningMode opts ^. warningSet - pure $ if isMain /= NotMainInterface - then Set.union warnSet unsolvedWarnings - else warnSet - - -- filter out the warnings the flags told us to ignore - let cleanUp w = let wName = warningName w in - wName /= SafeFlagPragma_ - && wName `elem` warnSet - && case w of - UnsolvedMetaVariables ums -> not $ null ums - UnsolvedInteractionMetas uis -> not $ null uis - UnsolvedConstraints ucs -> not $ null ucs - _ -> True - - return $ sfp ++ filter (cleanUp . tcWarning) ws - -applyFlagsToTCWarnings :: [TCWarning] -> TCM [TCWarning] -applyFlagsToTCWarnings = applyFlagsToTCWarnings' NotMainInterface - ---------------------------------------------------------------------------- -- * Helpers --------------------------------------------------------------------------- -sayWhere :: HasRange a => a -> TCM Doc -> TCM Doc -sayWhere x d = applyUnless (null r) (prettyTCM r $$) d - where r = getRange x - -sayWhen :: Range -> Maybe (Closure Call) -> TCM Doc -> TCM Doc -sayWhen r Nothing m = sayWhere r m -sayWhen r (Just cl) m = sayWhere r (m $$ prettyTCM cl) - -panic :: String -> TCM Doc +panic :: Monad m => String -> m Doc panic s = fwords $ "Panic: " ++ s -nameWithBinding :: QName -> TCM Doc +nameWithBinding :: MonadPretty m => QName -> m Doc nameWithBinding q = (prettyTCM q <+> "bound at") prettyTCM r where @@ -391,6 +145,7 @@ IllformedProjectionPattern{} -> "IllformedProjectionPattern" CannotEliminateWithPattern{} -> "CannotEliminateWithPattern" IllegalLetInTelescope{} -> "IllegalLetInTelescope" + IllegalPatternInTelescope{} -> "IllegalPatternInTelescope" -- UNUSED: IncompletePatternMatching{} -> "IncompletePatternMatching" InternalError{} -> "InternalError" InvalidPattern{} -> "InvalidPattern" @@ -398,6 +153,7 @@ MetaCannotDependOn{} -> "MetaCannotDependOn" MetaOccursInItself{} -> "MetaOccursInItself" MetaIrrelevantSolution{} -> "MetaIrrelevantSolution" + MetaErasedSolution{} -> "MetaErasedSolution" ModuleArityMismatch{} -> "ModuleArityMismatch" ModuleDefinedInOtherFile {} -> "ModuleDefinedInOtherFile" ModuleNameUnexpected{} -> "ModuleNameUnexpected" @@ -455,15 +211,20 @@ TooManyFields{} -> "TooManyFields" TooManyPolarities{} -> "TooManyPolarities" SplitOnIrrelevant{} -> "SplitOnIrrelevant" + SplitOnUnusableCohesion{} -> "SplitOnUnusableCohesion" -- UNUSED: -- SplitOnErased{} -> "SplitOnErased" SplitOnNonVariable{} -> "SplitOnNonVariable" DefinitionIsIrrelevant{} -> "DefinitionIsIrrelevant" + DefinitionIsErased{} -> "DefinitionIsErased" VariableIsIrrelevant{} -> "VariableIsIrrelevant" VariableIsErased{} -> "VariableIsErased" + VariableIsOfUnusableCohesion{} -> "VariableIsOfUnusableCohesion" UnequalBecauseOfUniverseConflict{} -> "UnequalBecauseOfUniverseConflict" UnequalRelevance{} -> "UnequalRelevance" + UnequalQuantity{} -> "UnequalQuantity" + UnequalCohesion{} -> "UnequalCohesion" UnequalHiding{} -> "UnequalHiding" --- UnequalLevel{} -> "UnequalLevel" -- UNUSED + UnequalLevel{} -> "UnequalLevel" UnequalSorts{} -> "UnequalSorts" UnequalTerms{} -> "UnequalTerms" UnequalTypes{} -> "UnequalTypes" @@ -482,8 +243,10 @@ WrongHidingInLambda{} -> "WrongHidingInLambda" WrongIrrelevanceInLambda{} -> "WrongIrrelevanceInLambda" WrongQuantityInLambda{} -> "WrongQuantityInLambda" + WrongCohesionInLambda{} -> "WrongCohesionInLambda" WrongNamedArgument{} -> "WrongNamedArgument" WrongNumberOfConstructorArguments{} -> "WrongNumberOfConstructorArguments" + QuantityMismatch{} -> "QuantityMismatch" HidingMismatch{} -> "HidingMismatch" RelevanceMismatch{} -> "RelevanceMismatch" NonFatalErrors{} -> "NonFatalErrors" @@ -497,23 +260,14 @@ -- fact that ̀ws` is non-empty. TypeError _ Closure{ clValue = NonFatalErrors ws } -> foldr1 ($$) $ fmap prettyTCM ws -- Andreas, 2014-03-23 - -- This use of localState seems ok since we do not collect + -- This use of withTCState seems ok since we do not collect -- Benchmark info during printing errors. - TypeError s e -> localTCState $ do - putTC s + TypeError s e -> withTCState (const s) $ sayWhen (envRange $ clEnv e) (envCall $ clEnv e) $ prettyTCM e Exception r s -> sayWhere r $ return s IOException _ r e -> sayWhere r $ fwords $ show e PatternErr{} -> sayWhere err $ panic "uncaught pattern violation" -instance PrettyTCM CallInfo where - prettyTCM c = do - let call = prettyTCM $ callInfoCall c - r = callInfoRange c - if null $ P.pretty r - then call - else call $$ nest 2 ("(at" <+> prettyTCM r <> ")") - -- | Drops given amount of leading components of the qualified name. dropTopLevelModule' :: Int -> QName -> QName dropTopLevelModule' k (QName (MName ns) n) = QName (MName (drop k ns)) n @@ -523,7 +277,7 @@ dropTopLevelModule q = ($ q) <$> topLevelModuleDropper -- | Produces a function which drops the filename component of the qualified name. -topLevelModuleDropper :: TCM (QName -> QName) +topLevelModuleDropper :: (MonadTCEnv m, ReadTCState m) => m (QName -> QName) topLevelModuleDropper = do caseMaybeM (asksTC envCurrentPath) (return id) $ \ f -> do m <- fromMaybe __IMPOSSIBLE__ <$> lookupModuleFromSource f @@ -586,9 +340,16 @@ WrongQuantityInLambda -> fwords "Incorrect quantity annotation in lambda" - WrongNamedArgument a -> fsep $ + WrongCohesionInLambda -> + fwords "Incorrect cohesion annotation in lambda" + + WrongNamedArgument a xs0 -> fsep $ pwords "Function does not accept argument " ++ [prettyTCM a] -- ++ pwords " (wrong argument name)" + ++ if null xs then [] else + [parens $ fsep $ text "possible arguments:" : map pretty xs] + where + xs = filter (not . isNoName) xs0 WrongHidingInApplication t -> fwords "Found an implicit application where an explicit application was expected" @@ -601,6 +362,10 @@ "Expected " ++ verbalize (Indefinite r') ++ " argument, but found " ++ verbalize (Indefinite r) ++ " argument" + QuantityMismatch q q' -> fwords $ + "Expected " ++ verbalize (Indefinite q') ++ " argument, but found " ++ + verbalize (Indefinite q) ++ " argument" + UninstantiatedDotPattern e -> fsep $ pwords "Failed to infer the value of dotted pattern" @@ -679,7 +444,7 @@ reportSLn "scope.class.error" 30 $ "filtered candidates = " ++ prettyShow xms -- If we found a copy of x with non-empty range, great! - ifJust (headMaybe xms) (\ (x', m) -> return (getRange x', m)) $ {-else-} do + ifJust (listToMaybe xms) (\ (x', m) -> return (getRange x', m)) $ {-else-} do -- If that failed, we pick the first m from ms which has a nameBindingSite. let rms = ms >>= \ m -> map (,m) $ @@ -689,7 +454,7 @@ reportSLn "scope.class.error" 30 $ "rangeful clashing modules = " ++ prettyShow rms -- If even this fails, we pick the first m and give no range. - return $ fromMaybe (noRange, m0) $ headMaybe rms + return $ fromMaybe (noRange, m0) $ listToMaybe rms fsep $ pwords "Duplicate definition of module" ++ [prettyTCM x <> "."] ++ @@ -738,6 +503,10 @@ pwords "Cannot pattern match against" ++ [text $ verbalize $ getRelevance t] ++ pwords "argument of type" ++ [prettyTCM $ unDom t] + SplitOnUnusableCohesion t -> fsep $ + pwords "Cannot pattern match against" ++ [text $ verbalize $ getCohesion t] ++ + pwords "argument of type" ++ [prettyTCM $ unDom t] + -- UNUSED: -- SplitOnErased t -> fsep $ -- pwords "Cannot pattern match against" ++ [text $ verbalize $ getQuantity t] ++ @@ -750,12 +519,18 @@ DefinitionIsIrrelevant x -> fsep $ "Identifier" : prettyTCM x : pwords "is declared irrelevant, so it cannot be used here" + DefinitionIsErased x -> fsep $ + "Identifier" : prettyTCM x : pwords "is declared erased, so it cannot be used here" + VariableIsIrrelevant x -> fsep $ "Variable" : prettyTCM (nameConcrete x) : pwords "is declared irrelevant, so it cannot be used here" VariableIsErased x -> fsep $ "Variable" : prettyTCM (nameConcrete x) : pwords "is declared erased, so it cannot be used here" + VariableIsOfUnusableCohesion x c -> fsep + ["Variable", prettyTCM (nameConcrete x), "is declared", text (show c), "so it cannot be used here"] + UnequalBecauseOfUniverseConflict cmp s t -> fsep $ [prettyTCM s, notCmp cmp, prettyTCM t, "because this would result in an invalid use of Setω" ] @@ -769,11 +544,17 @@ (s , Sort DefS{} ) -> prettyTCM $ ShouldBeASort $ El Inf s (_ , _ ) -> do (d1, d2, d) <- prettyInEqual s t - fsep $ [return d1, notCmp cmp, return d2] ++ pwords "of type" ++ [prettyTCM a] ++ [return d] + fsep $ concat $ + [ [return d1, notCmp cmp, return d2] + , case a of + AsTermsOf t -> pwords "of type" ++ [prettyTCM t] + AsSizes -> pwords "of type" ++ [prettyTCM =<< sizeType] + AsTypes -> [] + , [return d] + ] --- UnequalLevel is UNUSED --- UnequalLevel cmp s t -> fsep $ --- [prettyTCM s, notCmp cmp, prettyTCM t] + UnequalLevel cmp s t -> fsep $ + [prettyTCM s, notCmp cmp, prettyTCM t] -- UnequalTelescopes is UNUSED -- UnequalTelescopes cmp a b -> fsep $ @@ -786,6 +567,15 @@ [prettyTCM a, notCmp cmp, prettyTCM b] ++ pwords "because one is a relevant function type and the other is an irrelevant function type" + UnequalQuantity cmp a b -> fsep $ + [prettyTCM a, notCmp cmp, prettyTCM b] ++ + pwords "because one is a non-erased function type and the other is an erased function type" + + UnequalCohesion cmp a b -> fsep $ + [prettyTCM a, notCmp cmp, prettyTCM b] ++ + pwords "because one is a non-flat function type and the other is a flat function type" + -- FUTURE Cohesion: update message if/when introducing sharp. + UnequalHiding a b -> fsep $ [prettyTCM a, "!=", prettyTCM b] ++ pwords "because one is an implicit function type and the other is an explicit function type" @@ -828,24 +618,32 @@ pwords "With clause pattern " ++ [prettyA p] ++ pwords " is not an instance of its parent pattern " ++ [P.fsep <$> prettyTCMPatterns [q]] - MetaCannotDependOn m ps i -> fsep $ + -- The following error is caught and reraised as GenericDocError in Occurs.hs + MetaCannotDependOn m {- ps -} i -> fsep $ pwords "The metavariable" ++ [prettyTCM $ MetaV m []] ++ pwords "cannot depend on" ++ [pvar i] ++ - pwords "because it" ++ deps + [] -- pwords "because it" ++ deps where pvar = prettyTCM . I.var - deps = case map pvar ps of - [] -> pwords "does not depend on any variables" - [x] -> pwords "only depends on the variable" ++ [x] - xs -> pwords "only depends on the variables" ++ punctuate comma xs + -- deps = case map pvar ps of + -- [] -> pwords "does not depend on any variables" + -- [x] -> pwords "only depends on the variable" ++ [x] + -- xs -> pwords "only depends on the variables" ++ punctuate comma xs + -- The following error is caught and reraised as GenericDocError in Occurs.hs MetaOccursInItself m -> fsep $ pwords "Cannot construct infinite solution of metavariable" ++ [prettyTCM $ MetaV m []] + -- The following error is caught and reraised as GenericDocError in Occurs.hs MetaIrrelevantSolution m _ -> fsep $ pwords "Cannot instantiate the metavariable because (part of) the" ++ pwords "solution was created in an irrelevant context." + -- The following error is caught and reraised as GenericDocError in Occurs.hs + MetaErasedSolution m _ -> fsep $ + pwords "Cannot instantiate the metavariable because (part of) the" ++ + pwords "solution was created in an erased context." + BuiltinMustBeConstructor s e -> fsep $ [prettyA e] ++ pwords "must be a constructor in the binding to builtin" ++ [text s] @@ -857,7 +655,7 @@ pwords "previous binding to" ++ [prettyTCM x] NoBindingForBuiltin x - | elem x [builtinZero, builtinSuc] -> fsep $ + | x `elem` [builtinZero, builtinSuc] -> fsep $ pwords "No binding for builtin " ++ [text x <> comma] ++ pwords ("use {-# BUILTIN " ++ builtinNat ++ " name #-} to bind builtin natural " ++ "numbers to the type 'name'") @@ -881,6 +679,10 @@ [pretty tb] ++ pwords " is not allowed in a telescope here." + IllegalPatternInTelescope bd -> fsep $ + [pretty bd] ++ + pwords " is not allowed in a telescope here." + NoRHSRequiresAbsurdPattern ps -> fwords $ "The right-hand side can only be omitted if there " ++ "is an absurd pattern, () or {}, in the left-hand side." @@ -944,49 +746,27 @@ , prettyTCM q ] ++ pwords "is abstract, thus, not in scope here" - NotInScope xs -> do - inscope <- Set.toList . concreteNamesInScope <$> getScope - fsep (pwords "Not in scope:") $$ nest 2 (vcat $ map (name inscope) xs) - where - name inscope x = - fsep [ pretty x - , "at" <+> prettyTCM (getRange x) - , suggestion inscope x - ] - suggestion inscope x = nest 2 $ par $ - [ "did you forget space around the ':'?" | elem ':' s ] ++ - [ "did you forget space around the '->'?" | isInfixOf "->" s ] ++ - [ sep [ "did you mean" - , nest 2 $ vcat (punctuate " or" $ map (\ y -> text $ "'" ++ y ++ "'") ys) <> "?" ] - | not $ null ys ] - where - s = P.prettyShow x - par [] = empty - par [d] = parens d - par ds = parens $ vcat ds - - strip x = map toLower $ filter (/= '_') $ P.prettyShow $ C.unqualify x - maxDist n = div n 3 - close a b = editDistance a b <= maxDist (length a) - ys = map P.prettyShow $ filter (close (strip x) . strip) inscope + NotInScope xs -> + -- using the warning version to avoid code duplication + prettyTCM (NotInScopeW xs) NoSuchModule x -> fsep $ pwords "No module" ++ [pretty x] ++ pwords "in scope" AmbiguousName x ys -> vcat [ fsep $ pwords "Ambiguous name" ++ [pretty x <> "."] ++ pwords "It could refer to any one of" - , nest 2 $ vcat $ map nameWithBinding (toList ys) + , nest 2 $ vcat $ map nameWithBinding (NonEmpty.toList ys) , fwords "(hint: Use C-c C-w (in Emacs) if you want to know why)" ] AmbiguousModule x ys -> vcat [ fsep $ pwords "Ambiguous module name" ++ [pretty x <> "."] ++ pwords "It could refer to any one of" - , nest 2 $ vcat $ map help (toList ys) + , nest 2 $ vcat $ map help (NonEmpty.toList ys) , fwords "(hint: Use C-c C-w (in Emacs) if you want to know why)" ] where - help :: ModuleName -> TCM Doc + help :: MonadPretty m => ModuleName -> m Doc help m = do anno <- caseMaybeM (isDatatypeModule m) (return empty) $ \case IsData -> return $ "(datatype module)" @@ -1055,16 +835,16 @@ pwords "Could mean any one of:" ) $$ nest 2 (vcat $ map pretty' es') where - pretty_es :: TCM Doc + pretty_es :: MonadPretty m => m Doc pretty_es = pretty $ C.RawApp noRange es - pretty' :: C.Expr -> TCM Doc + pretty' :: MonadPretty m => C.Expr -> m Doc pretty' e = do p1 <- pretty_es p2 <- pretty e if show p1 == show p2 then unambiguous e else pretty e - unambiguous :: C.Expr -> TCM Doc + unambiguous :: MonadPretty m => C.Expr -> m Doc unambiguous e@(C.OpApp r op _ xs) | all (isOrdinary . namedArg) xs = pretty $ @@ -1095,11 +875,11 @@ CannotResolveAmbiguousPatternSynonym defs -> vcat [ fsep $ pwords "Cannot resolve overloaded pattern synonym" ++ [prettyTCM x <> comma] ++ pwords "since candidates have different shapes:" - , nest 2 $ vcat $ map prDef (toList defs) + , nest 2 $ vcat $ map prDef (NonEmpty.toList defs) , fsep $ pwords "(hint: overloaded pattern synonyms must be equal up to variable and constructor names)" ] where - (x, _) = headNe defs + (x, _) = NonEmpty.head defs prDef (x, (xs, p)) = prettyA (A.PatternSynDef x xs p) ("at" <+> pretty r) where r = nameBindingSite $ qnameName x @@ -1122,10 +902,10 @@ pwords "Could mean any one of:" ) $$ nest 2 (vcat $ map pretty' ps) where - pretty_p :: TCM Doc + pretty_p :: MonadPretty m => m Doc pretty_p = pretty p - pretty' :: C.Pattern -> TCM Doc + pretty' :: MonadPretty m => C.Pattern -> m Doc pretty' p' = do p1 <- pretty_p p2 <- pretty p' @@ -1189,7 +969,7 @@ (case sectLevel sect of Nothing -> "" Just Unrelated -> ", unrelated" - Just (Related n) -> ", level " ++ show n) ++ + Just (Related l) -> ", level " ++ toStringWithoutDotZero l) ++ ")") Boxes.// strut @@ -1297,6 +1077,7 @@ , inTopContext $ addContext ("_" :: String) $ prettyTCM cxt' ] where cxt' = cxt `abstract` raise (size cxt) (nameCxt names) + nameCxt :: [Name] -> I.Telescope nameCxt [] = EmptyTel nameCxt (x : xs) = ExtendTel (defaultDom (El __DUMMY_SORT__ $ I.var 0)) $ NoAbs (P.prettyShow x) $ nameCxt xs @@ -1324,7 +1105,7 @@ , vcat $ map f xs ] where - f (x, fs) = pretty x <> ": " <+> fsep (map pretty fs) + f (x, fs) = (pretty x <> ": ") <+> fsep (map pretty fs) MultiplePolarityPragmas xs -> fsep $ pwords "Multiple polarity pragmas for" ++ map pretty xs @@ -1343,13 +1124,13 @@ | n > 0 && not (null args) = parens | otherwise = id - prettyArg :: Arg (I.Pattern' a) -> TCM Doc + prettyArg :: MonadPretty m => Arg (I.Pattern' a) -> m Doc prettyArg (Arg info x) = case getHiding info of Hidden -> braces $ prettyPat 0 x Instance{} -> dbraces $ prettyPat 0 x NotHidden -> prettyPat 1 x - prettyPat :: Integer -> (I.Pattern' a) -> TCM Doc + prettyPat :: MonadPretty m => Integer -> (I.Pattern' a) -> m Doc prettyPat _ (I.VarP _ _) = "_" prettyPat _ (I.DotP _ _) = "._" prettyPat n (I.ConP c _ args) = @@ -1358,17 +1139,17 @@ prettyPat n (I.DefP o q args) = mpar n args $ prettyTCM q <+> fsep (map (prettyArg . fmap namedThing) args) - prettyPat _ (I.LitP l) = prettyTCM l + prettyPat _ (I.LitP _ l) = prettyTCM l prettyPat _ (I.ProjP _ p) = "." <> prettyTCM p prettyPat _ (I.IApplyP _ _ _ _) = "_" -notCmp :: Comparison -> TCM Doc +notCmp :: MonadPretty m => Comparison -> m Doc notCmp cmp = "!" <> prettyTCM cmp -- | Print two terms that are supposedly unequal. -- If they print to the same identifier, add some explanation -- why they are different nevertheless. -prettyInEqual :: Term -> Term -> TCM (Doc, Doc, Doc) +prettyInEqual :: MonadPretty m => Term -> Term -> m (Doc, Doc, Doc) prettyInEqual t1 t2 = do d1 <- prettyTCM t1 d2 <- prettyTCM t2 @@ -1388,18 +1169,18 @@ (I.Con{}, I.Var{}) -> varCon _ -> empty where - varDef, varCon, generic :: TCM Doc + varDef, varCon, generic :: MonadPretty m => m Doc varDef = parens $ fwords "because one is a variable and one a defined identifier" varCon = parens $ fwords "because one is a variable and one a constructor" generic = parens $ fwords $ "although these terms are looking the same, " ++ "they contain different but identically rendered identifiers somewhere" - varVar :: Int -> Int -> TCM Doc + varVar :: MonadPretty m => Int -> Int -> m Doc varVar i j = parens $ fwords $ "because one has de Bruijn index " ++ show i ++ " and the other " ++ show j class PrettyUnequal a where - prettyUnequal :: a -> TCM Doc -> a -> TCM Doc + prettyUnequal :: MonadPretty m => a -> m Doc -> a -> m Doc instance PrettyUnequal Term where prettyUnequal t1 ncmp t2 = do @@ -1417,8 +1198,12 @@ IrrelevantDatatype t -> enterClosure t $ \ t -> fsep $ pwords "Cannot split on argument of irrelevant datatype" ++ [prettyTCM t] - ErasedDatatype t -> enterClosure t $ \ t -> fsep $ - pwords "Cannot branch on erased argument of datatype" ++ [prettyTCM t] + ErasedDatatype causedByWithoutK t -> enterClosure t $ \ t -> fsep $ + pwords "Cannot branch on erased argument of datatype" ++ + [prettyTCM t] ++ + if causedByWithoutK + then pwords "because the K rule is turned off" + else [] CoinductiveDatatype t -> enterClosure t $ \ t -> fsep $ pwords "Cannot pattern match on the coinductive type" ++ [prettyTCM t] @@ -1431,17 +1216,26 @@ UnificationStuck c tel cIxs gIxs errs | length cIxs /= length gIxs -> __IMPOSSIBLE__ - | otherwise -> vcat $ - [ fsep $ pwords "I'm not sure if there should be a case for the constructor" ++ - [prettyTCM c <> ","] ++ - pwords "because I get stuck when trying to solve the following" ++ - pwords "unification problems (inferred index ≟ expected index):" - ] ++ - zipWith (\c g -> nest 2 $ addContext tel $ prettyTCM c <+> "≟" <+> prettyTCM g) cIxs gIxs ++ - if null errs then [] else - [ fsep $ pwords "Possible" ++ pwords (singPlural errs "reason" "reasons") ++ + | otherwise -> vcat . concat $ + [ [ fsep . concat $ + [ pwords "I'm not sure if there should be a case for the constructor" + , [prettyTCM c <> ","] + , pwords "because I get stuck when trying to solve the following" + , pwords "unification problems (inferred index ≟ expected index):" + ] + ] + , zipWith prEq cIxs gIxs + , if null errs then [] else + [ fsep $ pwords "Possible" ++ pwords (P.singPlural errs "reason" "reasons") ++ pwords "why unification failed:" ] ++ map (nest 2 . prettyTCM) errs + ] + where + -- Andreas, 2019-08-08, issue #3943 + -- To not print hidden indices just as {_}, we strip the Arg and print + -- the hiding information manually. + prEq cIx gIx = addContext tel $ nest 2 $ hsep [ pr cIx , "≟" , pr gIx ] + pr arg = prettyRelevance arg . prettyHiding arg id <$> prettyTCM (unArg arg) CosplitCatchall -> fsep $ pwords "Cannot split into projections because not all clauses have a projection copattern" @@ -1456,7 +1250,7 @@ CannotCreateMissingClause f cl msg t -> fsep ( pwords "Cannot generate inferred clause for" ++ [prettyTCM f <> "."] ++ pwords "Case to handle:") $$ nest 2 (vcat $ [display cl]) - $$ (pure msg <+> enterClosure t displayAbs <> ".") + $$ ((pure msg <+> enterClosure t displayAbs) <> ".") where displayAbs (Abs x t) = addContext x $ prettyTCM t displayAbs (NoAbs x t) = prettyTCM t @@ -1498,140 +1292,16 @@ pwords "=" ++ [prettyTCM u] ++ pwords "of type" ++ [prettyTCM a] ++ pwords "because K has been disabled." + UnifyUnusableModality tel a i u mod -> addContext tel $ fsep $ + pwords "Cannot solve variable " ++ [prettyTCM (var i)] ++ + pwords "of type " ++ [prettyTCM a] ++ + pwords "with solution " ++ [prettyTCM u] ++ + pwords "because the solution cannot be used at" ++ + [ text (verbalize $ getRelevance mod) <> "," + , text $ verbalize $ getQuantity mod ] ++ + pwords "modality" -instance PrettyTCM Call where - prettyTCM c = withContextPrecedence TopCtx $ case c of - CheckClause t cl -> do - reportSLn "error.checkclause" 60 $ "prettyTCM CheckClause: cl = " ++ show (deepUnscope cl) - clc <- abstractToConcrete_ cl - reportSLn "error.checkclause" 40 $ "cl (Concrete) = " ++ show clc - fsep $ - pwords "when checking that the clause" - ++ [prettyA cl] ++ pwords "has type" ++ [prettyTCM t] - CheckPattern p tel t -> addContext tel $ fsep $ - pwords "when checking that the pattern" - ++ [prettyA p] ++ pwords "has type" ++ [prettyTCM t] - - CheckLetBinding b -> fsep $ - pwords "when checking the let binding" ++ [prettyA b] - - InferExpr e -> fsep $ pwords "when inferring the type of" ++ [prettyA e] - - CheckExprCall cmp e t -> fsep $ - pwords "when checking that the expression" - ++ [prettyA e] ++ pwords "has type" ++ [prettyTCM t] - - IsTypeCall e s -> fsep $ - pwords "when checking that the expression" - ++ [prettyA e] ++ pwords "is a type of sort" ++ [prettyTCM s] - - IsType_ e -> fsep $ - pwords "when checking that the expression" - ++ [prettyA e] ++ pwords "is a type" - - CheckProjection _ x t -> fsep $ - pwords "when checking the projection" ++ - [ sep [ prettyTCM x <+> ":" - , nest 2 $ prettyTCM t ] ] - - CheckArguments r es t0 t1 -> fsep $ - pwords "when checking that" ++ - map hPretty es ++ - pwords (singPlural es "is a valid argument" "are valid arguments") ++ - pwords "to a function of type" ++ - [prettyTCM t0] - - CheckTargetType r infTy expTy -> sep - [ "when checking that the inferred type of an application" - , nest 2 $ prettyTCM infTy - , "matches the expected type" - , nest 2 $ prettyTCM expTy ] - - CheckRecDef _ x ps cs -> - fsep $ pwords "when checking the definition of" ++ [prettyTCM x] - - CheckDataDef _ x ps cs -> - fsep $ pwords "when checking the definition of" ++ [prettyTCM x] - - CheckConstructor d _ _ (A.Axiom _ _ _ _ c _) -> fsep $ - pwords "when checking the constructor" ++ [prettyTCM c] ++ - pwords "in the declaration of" ++ [prettyTCM d] - - CheckConstructor{} -> __IMPOSSIBLE__ - - CheckConstructorFitsIn c t s -> fsep $ - pwords "when checking that the type" ++ [prettyTCM t] ++ - pwords "of the constructor" ++ [prettyTCM c] ++ - pwords "fits in the sort" ++ [prettyTCM s] ++ - pwords "of the datatype." - - CheckFunDefCall _ f _ -> - fsep $ pwords "when checking the definition of" ++ [prettyTCM f] - - CheckPragma _ p -> - fsep $ pwords "when checking the pragma" - ++ [prettyA $ RangeAndPragma noRange p] - - CheckPrimitive _ x e -> fsep $ - pwords "when checking that the type of the primitive function" ++ - [prettyTCM x] ++ pwords "is" ++ [prettyA e] - - CheckWithFunctionType a -> fsep $ - pwords "when checking that the type" ++ - [prettyTCM a] ++ pwords "of the generated with function is well-formed" - - CheckDotPattern e v -> fsep $ - pwords "when checking that the given dot pattern" ++ [prettyA e] ++ - pwords "matches the inferred value" ++ [prettyTCM v] - - CheckPatternShadowing c -> fsep $ - pwords "when checking the clause" ++ [prettyA c] - - CheckNamedWhere m -> fsep $ - pwords "when checking the named where block" ++ [prettyA m] - - InferVar x -> - fsep $ pwords "when inferring the type of" ++ [prettyTCM x] - - InferDef x -> - fsep $ pwords "when inferring the type of" ++ [prettyTCM x] - - CheckIsEmpty r t -> - fsep $ pwords "when checking that" ++ [prettyTCM t] ++ - pwords "has no constructors" - - ScopeCheckExpr e -> fsep $ pwords "when scope checking" ++ [pretty e] - - ScopeCheckDeclaration d -> - fwords ("when scope checking the declaration" ++ suffix) $$ - nest 2 (vcat $ map pretty ds) - where - ds = D.notSoNiceDeclarations d - suffix = case ds of - [_] -> "" - _ -> "s" - - ScopeCheckLHS x p -> - fsep $ pwords "when scope checking the left-hand side" ++ [pretty p] ++ - pwords "in the definition of" ++ [pretty x] - - NoHighlighting -> empty - - SetRange r -> fsep (pwords "when doing something at") <+> prettyTCM r - - CheckSectionApplication _ m1 modapp -> fsep $ - pwords "when checking the module application" ++ - [prettyA $ A.Apply info m1 modapp initCopyInfo defaultImportDir] - where - info = A.ModuleInfo noRange noRange Nothing Nothing Nothing - - ModuleContents -> fsep $ pwords "when retrieving the contents of a module" - - where - hPretty :: Arg (Named_ Expr) -> TCM Doc - hPretty a = withContextPrecedence (ArgumentCtx PreferParen) $ pretty =<< abstractToConcreteHiding a a - --------------------------------------------------------------------------- -- * Natural language --------------------------------------------------------------------------- @@ -1655,10 +1325,17 @@ instance Verbalize Quantity where verbalize = \case - Quantity0 -> "erased" - Quantity1 -> "linear" - Quantityω -> "unrestricted" + Quantity0{} -> "erased" + Quantity1{} -> "linear" + Quantityω{} -> "unrestricted" +instance Verbalize Cohesion where + verbalize r = + case r of + Flat -> "flat" + Continuous -> "continuous" + Squash -> "squashed" + -- | Indefinite article. data Indefinite a = Indefinite a @@ -1669,6 +1346,3 @@ w@(c:cs) | c `elem` ['a','e','i','o'] -> "an " ++ w | otherwise -> "a " ++ w -- Aarne Ranta would whip me if he saw this. - -singPlural :: Sized a => a -> c -> c -> c -singPlural xs singular plural = if size xs == 1 then singular else plural diff --git a/src/full/Agda/TypeChecking/Errors.hs-boot b/src/full/Agda/TypeChecking/Errors.hs-boot --- a/src/full/Agda/TypeChecking/Errors.hs-boot +++ b/src/full/Agda/TypeChecking/Errors.hs-boot @@ -1,14 +1,11 @@ module Agda.TypeChecking.Errors where -import Agda.TypeChecking.Monad.Base -import Agda.Syntax.Position +import Agda.Syntax.Abstract.Name -import Agda.Utils.Pretty +import Agda.TypeChecking.Monad.Base -- Misplaced SPECIALISE pragma: -- {-# SPECIALIZE prettyError :: TCErr -> TCM String #-} prettyError :: MonadTCM tcm => TCErr -> tcm String -prettyWarning :: MonadTCM tcm => Warning -> tcm Doc - -sayWhen :: Range -> Maybe (Closure Call) -> TCM Doc -> TCM Doc +topLevelModuleDropper :: (MonadTCEnv m, ReadTCState m) => m (QName -> QName) diff --git a/src/full/Agda/TypeChecking/EtaContract.hs b/src/full/Agda/TypeChecking/EtaContract.hs --- a/src/full/Agda/TypeChecking/EtaContract.hs +++ b/src/full/Agda/TypeChecking/EtaContract.hs @@ -1,22 +1,18 @@ -{-# LANGUAGE CPP #-} -- | Compute eta short normal forms. module Agda.TypeChecking.EtaContract where -import Control.Monad.Reader - import Agda.Syntax.Common import Agda.Syntax.Internal import Agda.Syntax.Internal.Generic import Agda.TypeChecking.Substitute import Agda.TypeChecking.Free import Agda.TypeChecking.Monad -import Agda.TypeChecking.Reduce.Monad () +import Agda.TypeChecking.Reduce.Monad () --instance only import {-# SOURCE #-} Agda.TypeChecking.Records import {-# SOURCE #-} Agda.TypeChecking.Datatypes import Agda.Utils.Monad -#include "undefined.h" import Agda.Utils.Impossible -- TODO: move to Agda.Syntax.Internal.SomeThing @@ -108,6 +104,7 @@ -- E.g. \ .x -> f .(subst P eq x) can in general not be contracted to f. -- -- (isIrrelevant info || isVar0 tyty v) && sameHiding i info + && sameModality i info && not (freeIn 0 u) then return $ strengthen __IMPOSSIBLE__ u else fallback @@ -115,8 +112,12 @@ where isVar0 _ (Var 0 []) = True -- Andreas, 2016-01-08 If --type-in-type, all levels are equal. - isVar0 True Level{} = True - isVar0 tyty (Level (Max [Plus 0 l])) = case l of + -- Jesper, 2019-10-15 issue #3073 + -- Contracting level arguments is not sound unless the domain type + -- is in fact @Level@, e.g. @\(A : Set) → F lzero@ should not be + -- eta-contracted to @F@. + -- isVar0 True Level{} = True + isVar0 tyty (Level (Max 0 [Plus 0 l])) = case l of NeutralLevel _ v -> isVar0 tyty v UnreducedLevel v -> isVar0 tyty v BlockedLevel{} -> False diff --git a/src/full/Agda/TypeChecking/EtaExpand.hs b/src/full/Agda/TypeChecking/EtaExpand.hs --- a/src/full/Agda/TypeChecking/EtaExpand.hs +++ b/src/full/Agda/TypeChecking/EtaExpand.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} -- | Compute eta long normal forms. module Agda.TypeChecking.EtaExpand where @@ -12,13 +11,10 @@ import Agda.TypeChecking.Reduce import Agda.TypeChecking.Substitute -import Agda.Utils.Monad - -#include "undefined.h" -import Agda.Utils.Impossible - -- | Eta-expand a term if its type is a function type or an eta-record type. -etaExpandOnce :: Type -> Term -> TCM Term +etaExpandOnce + :: (MonadReduce m, MonadTCEnv m, HasOptions m, HasConstInfo m, MonadDebug m) + => Type -> Term -> m Term etaExpandOnce a v = reduce a >>= \case El _ (Pi a b) -> return $ Lam ai $ mkAbs (absName b) $ raise 1 v `apply` [ Arg ai $ var 0 ] @@ -34,9 +30,11 @@ -- | Eta-expand functions and expressions of eta-record -- type wherever possible. deepEtaExpand :: Term -> Type -> TCM Term -deepEtaExpand = checkInternal' etaExpandAction +deepEtaExpand v a = checkInternal' etaExpandAction v CmpLeq a -etaExpandAction :: Action +etaExpandAction + :: (MonadReduce m, MonadTCEnv m, HasOptions m, HasConstInfo m, MonadDebug m) + => Action m etaExpandAction = Action { preAction = etaExpandOnce , postAction = \ _ -> return diff --git a/src/full/Agda/TypeChecking/Forcing.hs b/src/full/Agda/TypeChecking/Forcing.hs --- a/src/full/Agda/TypeChecking/Forcing.hs +++ b/src/full/Agda/TypeChecking/Forcing.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE TypeFamilies #-} {-| A constructor argument is forced if it appears as pattern variable @@ -37,6 +36,10 @@ proj (suc n) (suc i) = n @ +This module implements the analysis of which constructor arguments are forced. The process of moving +the binding site of forced arguments is implemented in the unifier (see the Solution step of +Agda.TypeChecking.Rules.LHS.Unify.unifyStep). + Forcing is a concept from pattern matching and thus builds on the concept of equality (I) used there (closed terms, extensional) which is different from the equality (II) used in conversion checking and the @@ -56,42 +59,40 @@ -} -module Agda.TypeChecking.Forcing where +module Agda.TypeChecking.Forcing + ( computeForcingAnnotations, + isForced, + nextIsForced ) where -import Control.Arrow (first, second) +import Control.Arrow (first) import Control.Monad import Control.Monad.Trans.Maybe -import Control.Monad.Writer (WriterT(..), tell) -import Data.Foldable hiding (any) -import Data.Traversable -import Data.Semigroup hiding (Arg) +import Control.Monad.Writer (WriterT(..), tell, lift) +import Data.Foldable as Fold hiding (any) import Data.Maybe import Data.List ((\\)) import Data.Function (on) +import Data.Monoid import Agda.Interaction.Options import Agda.Syntax.Common +import Agda.Syntax.Position import Agda.Syntax.Internal import Agda.Syntax.Internal.Pattern import Agda.TypeChecking.Monad -import Agda.TypeChecking.Irrelevance import Agda.TypeChecking.Records import Agda.TypeChecking.Reduce import Agda.TypeChecking.Substitute import Agda.TypeChecking.Telescope import Agda.TypeChecking.Pretty hiding ((<>)) -import Agda.TypeChecking.Telescope -import Agda.Utils.Function -import Agda.Utils.PartialOrd -import Agda.Utils.Pretty (prettyShow) +import Agda.Utils.Functor import Agda.Utils.List import Agda.Utils.Monad import Agda.Utils.Size -#include "undefined.h" import Agda.Utils.Impossible -- | Given the type of a constructor (excluding the parameters), @@ -100,8 +101,7 @@ -- are in normal form. computeForcingAnnotations :: QName -> Type -> TCM [IsForced] computeForcingAnnotations c t = - ifM (not . optForcing <$> commandLineOptions) - (return []) $ do + ifNotM (optForcing <$> pragmaOptions) {-then-} (return []) $ {-else-} do -- Andreas, 2015-03-10 Normalization prevents Issue 1454. -- t <- normalise t -- Andreas, 2015-03-28 Issue 1469: Normalization too costly. @@ -116,19 +116,24 @@ Def _ us -> us _ -> __IMPOSSIBLE__ n = size tel + xs :: [(Modality, Nat)] xs = forcedVariables vs -- #2819: We can only mark an argument as forced if it appears in the -- type with a relevance below (i.e. more relevant) than the one of the -- constructor argument. Otherwise we can't actually get the value from -- the type. Also the argument shouldn't be irrelevant, since in that -- case it isn't really forced. - isForced m i = getRelevance m /= Irrelevant && - any (\ (m', j) -> i == j && related m' POLE m) xs + isForced :: Modality -> Nat -> Bool + isForced m i = and + [ hasQuantity0 m || noUserQuantity m -- User can disable forcing by giving quantity explicitly. + , getRelevance m /= Irrelevant + , any (\ (m', j) -> i == j && m' `moreUsableModality` m) xs + ] forcedArgs = [ if isForced m i then Forced else NotForced | (i, m) <- zip (downFrom n) $ map getModality (telToList tel) ] - reportSLn "tc.force" 60 $ unlines + reportS "tc.force" 60 [ "Forcing analysis for " ++ show c , " xs = " ++ show (map snd xs) , " forcedArgs = " ++ show forcedArgs @@ -144,7 +149,7 @@ instance ForcedVariables a => ForcedVariables [a] where --- Note the 'a' does not include the 'Arg' in 'Apply'. +-- Note that the 'a' does not include the 'Arg' in 'Apply'. instance ForcedVariables a => ForcedVariables (Elim' a) where forcedVariables (Apply x) = forcedVariables x forcedVariables IApply{} = [] -- No forced variables in path applications @@ -169,171 +174,3 @@ nextIsForced [] = (NotForced, []) nextIsForced (f:fs) = (f, fs) ------------------------------------------------------------------------------ --- * Forcing translation ------------------------------------------------------------------------------ - --- | Move bindings for forced variables to unforced positions. -forcingTranslation :: [NamedArg DeBruijnPattern] -> TCM [NamedArg DeBruijnPattern] -forcingTranslation ps = do - (qs, rebind) <- dotForcedPatterns ps - case rebind of - Nothing -> return ps - Just rebind -> do - reportSDoc "tc.force" 50 $ "forcingTranslation" vcat - [ "patterns:" pretty ps - , "dotted: " pretty qs - , "rebind: " pretty rebind ] - rs <- foldM rebindForcedPattern qs rebind - when (not $ null rebind) $ reportSDoc "tc.force" 50 $ nest 2 $ "result: " pretty rs - -- Repeat translation as long as we're making progress (Issue 3410) - forcingTranslation rs - --- | Applies the forcing translation in order to update modalities of forced --- arguments in the telescope. This is used before checking a right-hand side --- in order to make sure all uses of forced arguments agree with the --- relevance of the position where the variable will ultimately be bound. --- Precondition: the telescope types the bound variables of the patterns. -forceTranslateTelescope :: Telescope -> [NamedArg DeBruijnPattern] -> TCM Telescope -forceTranslateTelescope delta qs = do - qs' <- forcingTranslation qs - let xms = patternVarModalities qs - xms' = patternVarModalities qs' - old = xms \\ xms' - new = xms' \\ xms - if null new then return delta else do - reportSLn "tc.force" 40 $ "Updating modalities of forced arguments\n" ++ - " from: " ++ show old ++ "\n" ++ - " to: " ++ show new - let mods = map (first dbPatVarIndex) new - ms = map (`lookup` mods) $ downFrom $ size delta - delta' = telFromList $ zipWith (maybe id setModality) ms $ telToList delta - reportSDoc "tc.force" 60 $ nest 2 $ "delta' =" prettyTCM delta' - return delta' - --- | Rebind a forced pattern in a non-forced position. The forced pattern has --- already been dotted by 'dotForcedPatterns', so the remaining task is to --- find a dot pattern in an unforced position that can be turned into a --- proper match of the forced pattern. --- --- For instance (with patterns prettified to ease readability): --- --- rebindForcedPattern [.(suc n), cons .n x xs] n = [suc n, cons .n x xs] --- -rebindForcedPattern :: [NamedArg DeBruijnPattern] -> DeBruijnPattern -> TCM [NamedArg DeBruijnPattern] -rebindForcedPattern ps toRebind = do - reportSDoc "tc.force" 50 $ hsep ["rebinding", pretty toRebind, "in"] pretty ps - ps' <- go $ zip (repeat NotForced) ps - reportSDoc "tc.force" 50 $ nest 2 $ hsep ["result:", pretty ps'] - return ps' - where - targetDotP = patternToTerm toRebind - - go [] = __IMPOSSIBLE__ -- unforcing cannot fail - go ((Forced, p) : ps) = (p :) <$> go ps - go ((NotForced, p) : ps) | namedArg p `rebinds` toRebind - = return $ p : map snd ps - go ((NotForced, p) : ps) = -- (#3544) A previous rebinding might have already rebound our pattern - case namedArg p of - VarP{} -> (p :) <$> go ps - DotP _ v -> mkPat v >>= \ case - Nothing -> (p :) <$> go ps - Just q' -> return $ fmap (q' <$) p : map snd ps - ConP c i qs -> do - fqs <- withForced c qs - qps <- go (fqs ++ ps) - let (qs', ps') = splitAt (length qs) qps - return $ fmap (ConP c i qs' <$) p : ps' - DefP o q qs -> do - fs <- defForced <$> getConstInfo q - fqs <- return $ zip (fs ++ repeat NotForced) qs - qps <- go (fqs ++ ps) - let (qs', ps') = splitAt (length qs) qps - return $ fmap (DefP o q qs' <$) p : ps' - LitP{} -> (p :) <$> go ps - ProjP{} -> (p :) <$> go ps - IApplyP{} -> (p :) <$> go ps - - withForced :: ConHead -> [a] -> TCM [(IsForced, a)] - withForced c qs = do - fs <- defForced <$> getConstInfo (conName c) - return $ zip (fs ++ repeat NotForced) qs - - -- Try to turn a term in a dot pattern into a pattern matching q - mkPat :: Term -> TCM (Maybe DeBruijnPattern) - mkPat v = mkPat' (NotForced, v) - - mkPat' :: (IsForced, Term) -> TCM (Maybe DeBruijnPattern) - mkPat' (Forced, _) = return Nothing - mkPat' (NotForced, v) | targetDotP == v = return (Just toRebind) - mkPat' (NotForced, v) = - case v of - Con c co es -> do - let vs = fromMaybe __IMPOSSIBLE__ $ allApplyElims es - fvs <- withForced c vs - let fvs' = [ (f,) <$> a | (f, a) <- fvs ] :: [Arg (IsForced, Term)] - -- It takes a bit of juggling to apply mkPat' under the the 'Arg's, but since it - -- type checks, it's pretty much guaranteed to be the right thing. - mps :: [Maybe (Arg DeBruijnPattern)] <- mapM (runMaybeT . traverse (MaybeT . mkPat')) fvs' - case break (isJust . snd) (zip vs mps) of - (mvs1, (_, Just p) : mvs2) -> do - let vs1 = map fst mvs1 - vs2 = map fst mvs2 - ci = (toConPatternInfo co) { conPLazy = True } - dots = (map . fmap) dotP - return $ Just $ ConP c ci $ doname $ dots vs1 ++ [p] ++ dots vs2 - _ -> return Nothing - _ -> return Nothing - where - doname = (map . fmap) unnamed - --- | Check if the first pattern rebinds the second pattern. Almost equality, --- but allows the first pattern to have a variable where the second pattern --- has a dot pattern. Used to fix #3544. -rebinds :: DeBruijnPattern -> DeBruijnPattern -> Bool -VarP{} `rebinds` DotP{} = True -VarP _ x `rebinds` VarP _ y = dbPatVarIndex x == dbPatVarIndex y -DotP _ u `rebinds` DotP _ v = u == v -ConP c _ ps `rebinds` ConP c' _ qs = c == c' && and (zipWith (rebinds `on` namedArg) ps qs) -LitP l `rebinds` LitP l' = l == l' -ProjP _ f `rebinds` ProjP _ g = f == g -IApplyP _ u v x `rebinds` IApplyP _ u' v' y = u == u' && v == v' && x == y -DefP _ f ps `rebinds` DefP _ g qs = f == g && and (zipWith (rebinds `on` namedArg) ps qs) -_ `rebinds` _ = False - --- | Dot all forced patterns and return a list of patterns that need to be --- undotted elsewhere. Patterns that need to be undotted are those that bind --- variables or does some actual (non-eta) matching. -dotForcedPatterns :: [NamedArg DeBruijnPattern] -> TCM ([NamedArg DeBruijnPattern], Maybe [DeBruijnPattern]) -dotForcedPatterns ps = runWriterT $ (traverse . traverse . traverse) (forced NotForced) ps - where - forced :: IsForced -> DeBruijnPattern -> WriterT (Maybe [DeBruijnPattern]) TCM DeBruijnPattern - forced f p = - case p of - DotP{} -> return p - ProjP{} -> return p - _ | f == Forced -> do - properMatch <- isProperMatch p - dotP (patternToTerm p) <$ tell (Just [p | properMatch || length p > 0]) - VarP{} -> return p - LitP{} -> return p - ConP c i ps -> do - fs <- defForced <$> getConstInfo (conName c) - ConP c i <$> zipWithM forcedArg (fs ++ repeat NotForced) ps - DefP o q ps -> do - fs <- defForced <$> getConstInfo q - DefP o q <$> zipWithM forcedArg (fs ++ repeat NotForced) ps - IApplyP{} -> return p - - forcedArg f = (traverse . traverse) (forced f) - - isProperMatch LitP{} = return True - isProperMatch IApplyP{} = return False - isProperMatch VarP{} = return False - isProperMatch ProjP{} = return False - isProperMatch DotP{} = return False - isProperMatch (ConP c i ps) = - ifM (isEtaCon $ conName c) - (anyM ps (isProperMatch . namedArg)) - (return True) - isProperMatch DefP{} = return True -- Andrea, TODO check semantics diff --git a/src/full/Agda/TypeChecking/Free.hs b/src/full/Agda/TypeChecking/Free.hs --- a/src/full/Agda/TypeChecking/Free.hs +++ b/src/full/Agda/TypeChecking/Free.hs @@ -1,4 +1,6 @@ {-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE UndecidableInstances #-} + -- | Computing the free variables of a term. -- -- The distinction between rigid and strongly rigid occurrences comes from: @@ -15,261 +17,202 @@ -- Also, function types and lambdas do not establish strong rigidity. -- Only inductive constructors do so. -- (See issue 1271). +-- +-- If you need the occurrence information for all free variables, you can use +-- @freeVars@ which has amoungst others this instance +-- @ +-- freeVars :: Term -> VarMap +-- @ +-- From @VarMap@, specific information can be extracted, e.g., +-- @ +-- relevantVars :: VarMap -> VarSet +-- relevantVars = filterVarMap isRelevant +-- @ +-- +-- To just check the status of a single free variable, there are more +-- efficient methods, e.g., +-- @ +-- freeIn :: Nat -> Term -> Bool +-- @ +-- +-- Tailored optimized variable checks can be implemented as semimodules to 'VarOcc', +-- see, for example, 'VarCounts' or 'SingleFlexRig'. module Agda.TypeChecking.Free - ( FreeVars(..) - , VarCounts(..) + ( VarCounts(..) , Free , IsVarSet(..) , IgnoreSorts(..) - , runFree , rigidVars, relevantVars, allVars - , allFreeVars, allFreeVarsWithOcc + , freeVars, freeVars', filterVarMap, filterVarMapToList + , runFree, rigidVars, stronglyRigidVars, unguardedVars, allVars + , allFreeVars , allRelevantVars, allRelevantVarsIgnoring , freeIn, freeInIgnoringSorts, isBinderUsed , relevantIn, relevantInIgnoringSortAnn - , Occurrence(..) - , VarOcc(..) - , occurrence + , FlexRig'(..), FlexRig + , LensFlexRig(..), isFlexible, isUnguarded, isStronglyRigid, isWeaklyRigid + , VarOcc'(..), VarOcc + , varOccurrenceIn + , flexRigOccurrenceIn , closed - , freeVars -- only for testing - , freeVars' , MetaSet + , insertMetaSet, foldrMetaSet ) where import Prelude hiding (null) -import Control.Monad.Reader -import Data.Maybe -import Data.Monoid ( Monoid, mempty, mappend, mconcat ) + + +import Data.Monoid ( Monoid, mempty, mappend) import Data.Semigroup ( Semigroup, (<>), Any(..), All(..) ) import Data.IntSet (IntSet) -import qualified Data.IntSet as Set +import qualified Data.IntSet as IntSet import Data.IntMap (IntMap) -import qualified Data.IntMap as Map -import Data.Set (Set) -import Data.Proxy +import qualified Data.IntMap as IntMap + + import qualified Agda.Benchmarking as Bench -import Agda.Syntax.Common hiding (Arg, Dom, NamedArg) +import Agda.Syntax.Common hiding (Arg, NamedArg) import Agda.Syntax.Internal import Agda.TypeChecking.Free.Lazy - ( Free(..) , FreeEnv(..), initFreeEnv - , VarOcc(..), topVarOcc, TheVarMap, theVarMap, IgnoreSorts(..), Variable, SingleVar - , MetaSet, IsVarSet(..), runFreeM - ) -import qualified Agda.TypeChecking.Free.Lazy as Free + -- ( Free(..) , FreeEnv(..), initFreeEnv + -- , FlexRig, FlexRig'(..) + -- , VarOcc(..), topVarOcc, TheVarMap, theVarMap, IgnoreSorts(..), Variable, SingleVar + -- , MetaSet, insertMetaSet, foldrMetaSet + -- , IsVarSet(..), runFreeM + -- ) -import Agda.Utils.Null import Agda.Utils.Singleton -type VarSet = IntSet - --- | Free variables of a term, (disjointly) partitioned into strongly and --- and weakly rigid variables, flexible variables and irrelevant variables. -data FreeVars = FV - { stronglyRigidVars :: VarSet - -- ^ Variables under only and at least one inductive constructor(s). - , unguardedVars :: VarSet - -- ^ Variables at top or only under inductive record constructors - -- λs and Πs. - -- The purpose of recording these separately is that they - -- can still become strongly rigid if put under a constructor - -- whereas weakly rigid ones stay weakly rigid. - , weaklyRigidVars :: VarSet - -- ^ Ordinary rigid variables, e.g., in arguments of variables or functions. - , flexibleVars :: IntMap MetaSet - -- ^ Variables occuring in arguments of metas. - -- These are only potentially free, depending how the meta variable is instantiated. - -- The set contains the id's of the meta variables that this variable is an argument to. - , irrelevantVars :: VarSet - -- ^ Variables in irrelevant arguments and under a @DontCare@, i.e., - -- in irrelevant positions. - } deriving (Eq, Show) - -mapSRV, mapUGV, mapWRV, mapIRV - :: (VarSet -> VarSet) -> FreeVars -> FreeVars -mapSRV f fv = fv { stronglyRigidVars = f $ stronglyRigidVars fv } -mapUGV f fv = fv { unguardedVars = f $ unguardedVars fv } -mapWRV f fv = fv { weaklyRigidVars = f $ weaklyRigidVars fv } -mapIRV f fv = fv { irrelevantVars = f $ irrelevantVars fv } - -mapFXV :: (IntMap MetaSet -> IntMap MetaSet) -> FreeVars -> FreeVars -mapFXV f fv = fv { flexibleVars = f $ flexibleVars fv } +--------------------------------------------------------------------------- +-- * Simple variable set implementations. --- | Rigid variables: either strongly rigid, unguarded, or weakly rigid. -rigidVars :: FreeVars -> VarSet -rigidVars fv = Set.unions - [ stronglyRigidVars fv - , unguardedVars fv - , weaklyRigidVars fv - ] +type VarSet = IntSet --- | All but the irrelevant variables. -relevantVars :: FreeVars -> VarSet -relevantVars fv = Set.unions [rigidVars fv, Map.keysSet (flexibleVars fv)] +-- In most cases we don't care about the VarOcc. --- | @allVars fv@ includes irrelevant variables. -allVars :: FreeVars -> VarSet -allVars fv = Set.unions [relevantVars fv, irrelevantVars fv] +instance IsVarSet () VarSet where withVarOcc _ = id +instance IsVarSet () [Int] where withVarOcc _ = id +instance IsVarSet () Any where withVarOcc _ = id +instance IsVarSet () All where withVarOcc _ = id -data Occurrence - = NoOccurrence - | Irrelevantly - | StronglyRigid -- ^ Under at least one and only inductive constructors. - | Unguarded -- ^ In top position, or only under inductive record constructors. - | WeaklyRigid -- ^ In arguments to variables and definitions. - | Flexible MetaSet -- ^ In arguments of metas. - deriving (Eq,Show) +--------------------------------------------------------------------------- +-- * Plain variable occurrence counting. --- | Compute an occurrence of a single variable in a piece of internal syntax. -occurrence :: Free a => Nat -> a -> Occurrence -occurrence x v = occurrenceFV x $ freeVars v +newtype VarCounts = VarCounts { varCounts :: IntMap Int } --- | Extract occurrence of a single variable from computed free variables. -occurrenceFV :: Nat -> FreeVars -> Occurrence -occurrenceFV x fv - | x `Set.member` stronglyRigidVars fv = StronglyRigid - | x `Set.member` unguardedVars fv = Unguarded - | x `Set.member` weaklyRigidVars fv = WeaklyRigid - | Just ms <- Map.lookup x (flexibleVars fv) = Flexible ms - | x `Set.member` irrelevantVars fv = Irrelevantly - | otherwise = NoOccurrence +instance Semigroup VarCounts where + VarCounts fv1 <> VarCounts fv2 = VarCounts (IntMap.unionWith (+) fv1 fv2) --- | Mark variables as flexible. Useful when traversing arguments of metas. -flexible :: MetaSet -> FreeVars -> FreeVars -flexible ms fv = - fv { stronglyRigidVars = Set.empty - , unguardedVars = Set.empty - , weaklyRigidVars = Set.empty - , flexibleVars = Map.unionsWith mappend - [ Map.fromSet (const ms) (rigidVars fv) - , fmap (mappend ms) (flexibleVars fv) ] - } +instance Monoid VarCounts where + mempty = VarCounts IntMap.empty + mappend = (<>) --- | Mark rigid variables as non-strongly. Useful when traversing arguments of variables. -weakly :: FreeVars -> FreeVars -weakly fv = fv - { stronglyRigidVars = Set.empty - , unguardedVars = Set.empty - , weaklyRigidVars = rigidVars fv - } +instance IsVarSet () VarCounts where + withVarOcc _ = id --- | Mark unguarded variables as strongly rigid. Useful when traversing arguments of inductive constructors. -strongly :: FreeVars -> FreeVars -strongly fv = fv - { stronglyRigidVars = stronglyRigidVars fv `Set.union` unguardedVars fv - , unguardedVars = Set.empty - } +instance Singleton Variable VarCounts where + singleton i = VarCounts $ IntMap.singleton i 1 --- | What happens to the variables occurring under a constructor? -underConstructor :: ConHead -> FreeVars -> FreeVars -underConstructor (ConHead c i fs) = - case (i,fs) of - -- Coinductive (record) constructors admit infinite cycles: - (CoInductive, _) -> weakly - -- Inductive data constructors do not admit infinite cycles: - (Inductive, []) -> strongly - -- Inductive record constructors do not admit infinite cycles, - -- but this cannot be proven inside Agda. - -- Thus, unification should not prove it either. - (Inductive, (_:_)) -> id +--------------------------------------------------------------------------- +-- * Collecting free variables (generic). --- | Mark all free variables as irrelevant. -irrelevantly :: FreeVars -> FreeVars -irrelevantly fv = empty { irrelevantVars = allVars fv } +-- | Collect all free variables together with information about their occurrence. +-- +-- Doesn't go inside solved metas, but collects the variables from a +-- metavariable application @X ts@ as @flexibleVars@. +{-# SPECIALIZE freeVars :: Free a => a -> VarMap #-} +freeVars :: (IsVarSet a c, Singleton Variable c, Free t) => t -> c +freeVars = freeVarsIgnore IgnoreNot --- | Pointwise union. -union :: FreeVars -> FreeVars -> FreeVars -union (FV sv1 gv1 rv1 fv1 iv1) (FV sv2 gv2 rv2 fv2 iv2) = - FV (Set.union sv1 sv2) (Set.union gv1 gv2) (Set.union rv1 rv2) (Map.unionWith mappend fv1 fv2) (Set.union iv1 iv2) +freeVarsIgnore :: (IsVarSet a c, Singleton Variable c, Free t) => + IgnoreSorts -> t -> c +freeVarsIgnore = runFree singleton -unions :: [FreeVars] -> FreeVars -unions = foldr union empty +-- Specialization to typical monoids +{-# SPECIALIZE runFree :: Free a => SingleVar Any -> IgnoreSorts -> a -> Any #-} +-- Specialization to Term +{-# SPECIALIZE runFree :: SingleVar Any -> IgnoreSorts -> Term -> Any #-} -instance Null FreeVars where - empty = FV Set.empty Set.empty Set.empty Map.empty Set.empty - null (FV a b c d e) = null a && null b && null c && null d && null e +-- | Compute free variables. +runFree :: (IsVarSet a c, Free t) => SingleVar c -> IgnoreSorts -> t -> c +runFree single i t = -- bench $ -- Benchmarking is expensive (4% on std-lib) + runFreeM single i (freeVars' t) + where + bench = Bench.billToPure [ Bench.Typing , Bench.Free ] --- | Free variable sets form a monoid under 'union'. -instance Semigroup FreeVars where - (<>) = union +--------------------------------------------------------------------------- +-- * Occurrence computation for a single variable. -instance Monoid FreeVars where - mempty = empty - mappend = (<>) - mconcat = unions +-- ** Full free occurrence info for a single variable. --- | @delete x fv@ deletes variable @x@ from variable set @fv@. -delete :: Nat -> FreeVars -> FreeVars -delete n (FV sv gv rv fv iv) = FV (Set.delete n sv) (Set.delete n gv) (Set.delete n rv) (Map.delete n fv) (Set.delete n iv) +-- | Get the full occurrence information of a free variable. +varOccurrenceIn :: Free a => Nat -> a -> Maybe VarOcc +varOccurrenceIn = varOccurrenceIn' IgnoreNot -instance Singleton Variable FreeVars where - singleton i = mapUGV (Set.insert i) mempty +varOccurrenceIn' :: Free a => IgnoreSorts -> Nat -> a -> Maybe VarOcc +varOccurrenceIn' ig x t = theSingleVarOcc $ runFree sg ig t + where + sg y = if x == y then oneSingleVarOcc else mempty -instance IsVarSet FreeVars where - withVarOcc (VarOcc o r) = goOcc o . goRel r - where - goOcc o = case o of - Free.Flexible ms -> flexible ms - Free.WeaklyRigid -> weakly - Free.Unguarded -> id - Free.StronglyRigid -> strongly - goRel r = case r of - Relevant -> id - NonStrict -> id -- we don't track non-strict in FreeVars - Irrelevant -> irrelevantly +-- | "Collection" just keeping track of the occurrence of a single variable. +-- 'Nothing' means variable does not occur freely. +newtype SingleVarOcc = SingleVarOcc { theSingleVarOcc :: Maybe VarOcc } --- In most cases we don't care about the VarOcc. +oneSingleVarOcc :: SingleVarOcc +oneSingleVarOcc = SingleVarOcc $ Just $ oneVarOcc -instance IsVarSet VarSet where withVarOcc _ = id -instance IsVarSet [Int] where withVarOcc _ = id -instance IsVarSet Any where withVarOcc _ = id -instance IsVarSet All where withVarOcc _ = id +-- | Hereditary Semigroup instance for 'Maybe'. +-- (The default instance for 'Maybe' may not be the hereditary one.) +instance Semigroup SingleVarOcc where + SingleVarOcc Nothing <> s = s + s <> SingleVarOcc Nothing = s + SingleVarOcc (Just o) <> SingleVarOcc (Just o') = SingleVarOcc $ Just $ o <> o' -newtype VarCounts = VarCounts { varCounts :: IntMap Int } +instance Monoid SingleVarOcc where + mempty = SingleVarOcc Nothing + mappend = (<>) -instance Semigroup VarCounts where - VarCounts fv1 <> VarCounts fv2 = VarCounts (Map.unionWith (+) fv1 fv2) +instance IsVarSet MetaSet SingleVarOcc where + withVarOcc o = SingleVarOcc . fmap (composeVarOcc o) . theSingleVarOcc -instance Monoid VarCounts where - mempty = VarCounts Map.empty - mappend = (<>) +-- ** Flexible /rigid occurrence info for a single variable. -instance IsVarSet VarCounts where withVarOcc _ = id +-- | Get the full occurrence information of a free variable. +flexRigOccurrenceIn :: Free a => Nat -> a -> Maybe (FlexRig' ()) +flexRigOccurrenceIn = flexRigOccurrenceIn' IgnoreNot -instance Singleton Variable VarCounts where - singleton i = VarCounts $ Map.singleton i 1 +flexRigOccurrenceIn' :: Free a => IgnoreSorts -> Nat -> a -> Maybe (FlexRig' ()) +flexRigOccurrenceIn' ig x t = theSingleFlexRig $ runFree sg ig t + where + sg y = if x == y then oneSingleFlexRig else mempty --- * Collecting free variables. +-- | "Collection" just keeping track of the occurrence of a single variable. +-- 'Nothing' means variable does not occur freely. +newtype SingleFlexRig = SingleFlexRig { theSingleFlexRig :: Maybe (FlexRig' ()) } -bench :: a -> a -bench = Bench.billToPure [ Bench.Typing , Bench.Free ] +oneSingleFlexRig :: SingleFlexRig +oneSingleFlexRig = SingleFlexRig $ Just $ oneFlexRig --- | Doesn't go inside solved metas, but collects the variables from a --- metavariable application @X ts@ as @flexibleVars@. -{-# SPECIALIZE freeVars :: Free a => a -> FreeVars #-} -freeVars :: (IsVarSet c, Singleton Variable c, Free a) => a -> c -freeVars = freeVarsIgnore IgnoreNot +-- | Hereditary Semigroup instance for 'Maybe'. +-- (The default instance for 'Maybe' may not be the hereditary one.) +instance Semigroup SingleFlexRig where + SingleFlexRig Nothing <> s = s + s <> SingleFlexRig Nothing = s + SingleFlexRig (Just o) <> SingleFlexRig (Just o') = SingleFlexRig $ Just $ addFlexRig o o' -{-# SPECIALIZE freeVarsIgnore :: Free a => IgnoreSorts -> a -> FreeVars #-} -freeVarsIgnore :: (IsVarSet c, Singleton Variable c, Free a) => - IgnoreSorts -> a -> c -freeVarsIgnore = runFree singleton +instance Monoid SingleFlexRig where + mempty = SingleFlexRig Nothing + mappend = (<>) --- Specialization to typical monoids -{-# SPECIALIZE runFree :: Free a => SingleVar Any -> IgnoreSorts -> a -> Any #-} -{-# SPECIALIZE runFree :: Free a => SingleVar FreeVars -> IgnoreSorts -> a -> FreeVars #-} --- Specialization to Term -{-# SPECIALIZE runFree :: SingleVar Any -> IgnoreSorts -> Term -> Any #-} -{-# SPECIALIZE runFree :: SingleVar FreeVars -> IgnoreSorts -> Term -> FreeVars #-} +instance IsVarSet () SingleFlexRig where + withVarOcc o = SingleFlexRig . fmap (composeFlexRig $ () <$ varFlexRig o) . theSingleFlexRig --- | Compute free variables. -runFree :: (IsVarSet c, Free a) => SingleVar c -> IgnoreSorts -> a -> c -runFree single i t = -- bench $ -- Benchmarking is expensive (4% on std-lib) - runFreeM single i (freeVars' t) +-- ** Plain free occurrence. -- | Check if a variable is free, possibly ignoring sorts. freeIn' :: Free a => IgnoreSorts -> Nat -> a -> Bool @@ -282,47 +225,103 @@ freeInIgnoringSorts :: Free a => Nat -> a -> Bool freeInIgnoringSorts = freeIn' IgnoreAll -freeInIgnoringSortAnn :: Free a => Nat -> a -> Bool -freeInIgnoringSortAnn = freeIn' IgnoreInAnnotations +-- UNUSED Liang-Ting Chen 2019-07-16 +--freeInIgnoringSortAnn :: Free a => Nat -> a -> Bool +--freeInIgnoringSortAnn = freeIn' IgnoreInAnnotations -newtype RelevantIn a = RelevantIn {getRelevantIn :: a} +-- | Is the variable bound by the abstraction actually used? +isBinderUsed :: Free a => Abs a -> Bool +isBinderUsed NoAbs{} = False +isBinderUsed (Abs _ x) = 0 `freeIn` x + +-- ** Relevant free occurrence. + +newtype RelevantIn c = RelevantIn {getRelevantIn :: c} deriving (Semigroup, Monoid) -instance IsVarSet a => IsVarSet (RelevantIn a) where +instance IsVarSet a c => IsVarSet a (RelevantIn c) where -- UndecidableInstances withVarOcc o x - | isIrrelevant (varRelevance o) = mempty + | isIrrelevant o = mempty | otherwise = RelevantIn $ withVarOcc o $ getRelevantIn x -relevantIn' :: Free a => IgnoreSorts -> Nat -> a -> Bool +relevantIn' :: Free t => IgnoreSorts -> Nat -> t -> Bool relevantIn' ig x t = getAny . getRelevantIn $ runFree (RelevantIn . Any . (x ==)) ig t -relevantInIgnoringSortAnn :: Free a => Nat -> a -> Bool +relevantInIgnoringSortAnn :: Free t => Nat -> t -> Bool relevantInIgnoringSortAnn = relevantIn' IgnoreInAnnotations -relevantIn :: Free a => Nat -> a -> Bool +relevantIn :: Free t => Nat -> t -> Bool relevantIn = relevantIn' IgnoreAll --- | Is the variable bound by the abstraction actually used? -isBinderUsed :: Free a => Abs a -> Bool -isBinderUsed NoAbs{} = False -isBinderUsed (Abs _ x) = 0 `freeIn` x +--------------------------------------------------------------------------- +-- * Occurrences of all free variables. -- | Is the term entirely closed (no free variables)? -closed :: Free a => a -> Bool +closed :: Free t => t -> Bool closed t = getAll $ runFree (const $ All False) IgnoreNot t -- | Collect all free variables. -allFreeVars :: Free a => a -> VarSet -allFreeVars = runFree Set.singleton IgnoreNot - --- | Collect all free variables together with information about their occurrence. -allFreeVarsWithOcc :: Free a => a -> TheVarMap -allFreeVarsWithOcc = theVarMap . runFree (singleton . (,topVarOcc)) IgnoreNot +allFreeVars :: Free t => t -> VarSet +allFreeVars = runFree IntSet.singleton IgnoreNot -- | Collect all relevant free variables, possibly ignoring sorts. -allRelevantVarsIgnoring :: Free a => IgnoreSorts -> a -> VarSet -allRelevantVarsIgnoring ig = getRelevantIn . runFree (RelevantIn . Set.singleton) ig +allRelevantVarsIgnoring :: Free t => IgnoreSorts -> t -> VarSet +allRelevantVarsIgnoring ig = getRelevantIn . runFree (RelevantIn . IntSet.singleton) ig -- | Collect all relevant free variables, excluding the "unused" ones. -allRelevantVars :: Free a => a -> VarSet +allRelevantVars :: Free t => t -> VarSet allRelevantVars = allRelevantVarsIgnoring IgnoreNot + +--------------------------------------------------------------------------- +-- * Backwards-compatible interface to 'freeVars'. + +filterVarMap :: (VarOcc -> Bool) -> VarMap -> VarSet +filterVarMap f = IntMap.keysSet . IntMap.filter f . theVarMap + +filterVarMapToList :: (VarOcc -> Bool) -> VarMap -> [Variable] +filterVarMapToList f = map fst . filter (f . snd) . IntMap.toList . theVarMap + +-- | Variables under only and at least one inductive constructor(s). +stronglyRigidVars :: VarMap -> VarSet +stronglyRigidVars = filterVarMap $ \case + VarOcc StronglyRigid _ -> True + _ -> False + +-- | Variables at top or only under inductive record constructors +-- λs and Πs. +-- The purpose of recording these separately is that they +-- can still become strongly rigid if put under a constructor +-- whereas weakly rigid ones stay weakly rigid. +unguardedVars :: VarMap -> VarSet +unguardedVars = filterVarMap $ \case + VarOcc Unguarded _ -> True + _ -> False + +-- UNUSED Liang-Ting Chen 2019-07-16 +---- | Ordinary rigid variables, e.g., in arguments of variables or functions. +--weaklyRigidVars :: VarMap -> VarSet +--weaklyRigidVars = filterVarMap $ \case +-- VarOcc WeaklyRigid _ -> True +-- _ -> False + +-- | Rigid variables: either strongly rigid, unguarded, or weakly rigid. +rigidVars :: VarMap -> VarSet +rigidVars = filterVarMap $ \case + VarOcc o _ -> o `elem` [ WeaklyRigid, Unguarded, StronglyRigid ] + +-- UNUSED Liang-Ting Chen 2019-07-16 +-- | Variables occuring in arguments of metas. +-- These are only potentially free, depending how the meta variable is instantiated. +-- The set contains the id's of the meta variables that this variable is an argument to. +--flexibleVars :: VarMap -> IntMap MetaSet +--flexibleVars (VarMap m) = (`IntMap.mapMaybe` m) $ \case +-- VarOcc (Flexible ms) _ -> Just ms +-- _ -> Nothing +-- +---- | Variables in irrelevant arguments and under a @DontCare@, i.e., +---- in irrelevant positions. +--irrelevantVars :: VarMap -> VarSet +--irrelevantVars = filterVarMap isIrrelevant + +allVars :: VarMap -> VarSet +allVars = IntMap.keysSet . theVarMap diff --git a/src/full/Agda/TypeChecking/Free/Lazy.hs b/src/full/Agda/TypeChecking/Free/Lazy.hs --- a/src/full/Agda/TypeChecking/Free/Lazy.hs +++ b/src/full/Agda/TypeChecking/Free/Lazy.hs @@ -1,5 +1,6 @@ {-# LANGUAGE GeneralizedNewtypeDeriving #-} -{-# LANGUAGE UndecidableInstances #-} +{-# LANGUAGE UndecidableInstances #-} +{-# LANGUAGE TypeFamilies #-} -- | Computing the free variables of a term lazily. -- @@ -10,7 +11,7 @@ -- Worst-case complexity does not change (i.e. the case when a variable -- does not occur), but best case-complexity does matter. For instance, -- see 'Agda.TypeChecking.Substitute.mkAbs': each time we construct --- a dependent function type, we check it is actually dependent. +-- a dependent function type, we check whether it is actually dependent. -- -- The distinction between rigid and strongly rigid occurrences comes from: -- Jason C. Reed, PhD thesis, 2009, page 96 (see also his LFMTP 2009 paper) @@ -26,59 +27,175 @@ -- Also, function types and lambdas do not establish strong rigidity. -- Only inductive constructors do so. -- (See issue 1271). +-- +-- For further reading on semirings and semimodules for variable occurrence, +-- see e.g. Conor McBrides "I got plenty of nuttin'" (Wadlerfest 2016). +-- There, he treats the "quantity" dimension of variable occurrences. +-- +-- The semiring has an additive operation for combining occurrences of subterms, +-- and a multiplicative operation of representing function composition. E.g. +-- if variable @x@ appears @o@ in term @u@, but @u@ appears in context @q@ in +-- term @t@ then occurrence of variable @x@ coming from @u@ is accounted for +-- as @q o@ in @t@. +-- +-- Consider example @(λ{ x → (x,x)}) y@: +-- +-- * Variable @x@ occurs once unguarded in @x@. +-- +-- * It occurs twice unguarded in the aggregation @x@ @x@ +-- +-- * Inductive constructor @,@ turns this into two strictly rigid occurrences. +-- +-- If @,@ is a record constructor, then we stay unguarded. +-- +-- * The function @({λ x → (x,x)})@ provides a context for variable @y@. +-- This context can be described as weakly rigid with quantity two. +-- +-- * The final occurrence of @y@ is obtained as composing the context with +-- the occurrence of @y@ in itself (which is the unit for composition). +-- Thus, @y@ occurs weakly rigid with quantity two. +-- +-- It is not a given that the context can be described in the same way +-- as the variable occurrence. However, for quantity it is the case +-- and we obtain a semiring of occurrences with 0, 1, and even ω, which +-- is an absorptive element for addition. module Agda.TypeChecking.Free.Lazy where import Control.Applicative hiding (empty) import Control.Monad.Reader -import Data.Foldable (foldMap) + +import Data.Foldable (Foldable, foldMap) import Data.IntMap (IntMap) import qualified Data.IntMap as IntMap +import Data.IntSet (IntSet) +import qualified Data.IntSet as IntSet import Data.Monoid ( Monoid, mempty, mappend, mconcat ) import Data.Semigroup ( Semigroup, (<>) ) -import Data.Set (Set) + + import Agda.Syntax.Common import Agda.Syntax.Internal --- import Agda.TypeChecking.Irrelevance - import Agda.Utils.Functor +import Agda.Utils.Lens import Agda.Utils.Monad +import Agda.Utils.Null import Agda.Utils.Singleton import Agda.Utils.Size -type MetaSet = Set MetaId +--------------------------------------------------------------------------- +-- * Set of meta variables. +-- | A set of meta variables. Forms a monoid under union. + +newtype MetaSet = MetaSet { theMetaSet :: IntSet } + deriving (Eq, Show, Null, Semigroup, Monoid) + +instance Singleton MetaId MetaSet where + singleton = MetaSet . singleton . metaId + +insertMetaSet :: MetaId -> MetaSet -> MetaSet +insertMetaSet (MetaId m) (MetaSet ms) = MetaSet $ IntSet.insert m ms + +foldrMetaSet :: (MetaId -> a -> a) -> a -> MetaSet -> a +foldrMetaSet f e ms = IntSet.foldr (f . MetaId) e $ theMetaSet ms + +--------------------------------------------------------------------------- +-- * Flexible and rigid occurrences (semigroup) + -- | Depending on the surrounding context of a variable, -- it's occurrence can be classified as flexible or rigid, -- with finer distinctions. -- -- The constructors are listed in increasing order (wrt. information content). -data FlexRig - = Flexible MetaSet -- ^ In arguments of metas. +data FlexRig' a + = Flexible a -- ^ In arguments of metas. -- The set of metas is used by ''Agda.TypeChecking.Rewriting.NonLinMatch'' -- to generate the right blocking information. + -- The semantics is that the status of a variable occurrence may change + -- if one of the metas in the set gets solved. We may say the occurrence + -- is tainted by the meta variables in the set. | WeaklyRigid -- ^ In arguments to variables and definitions. - | Unguarded -- ^ In top position, or only under inductive record constructors. + | Unguarded -- ^ In top position, or only under inductive record constructors (unit). | StronglyRigid -- ^ Under at least one and only inductive constructors. - deriving (Eq, Ord, Show) + deriving (Eq, Show, Functor, Foldable) --- | 'FlexRig' composition. For accumulating the context of a variable. +type FlexRig = FlexRig' MetaSet + +class LensFlexRig a o | o -> a where + lensFlexRig :: Lens' (FlexRig' a) o + +instance LensFlexRig a (FlexRig' a) where + lensFlexRig f x = f x + +isFlexible :: LensFlexRig a o => o -> Bool +isFlexible o = case o ^. lensFlexRig of + Flexible {} -> True + _ -> False + +isUnguarded :: LensFlexRig a o => o -> Bool +isUnguarded o = case o ^. lensFlexRig of + Unguarded -> True + _ -> False + +isWeaklyRigid :: LensFlexRig a o => o -> Bool +isWeaklyRigid o = case o ^. lensFlexRig of + WeaklyRigid -> True + _ -> False + +isStronglyRigid :: LensFlexRig a o => o -> Bool +isStronglyRigid o = case o ^. lensFlexRig of + StronglyRigid -> True + _ -> False + +-- | 'FlexRig' aggregation (additive operation of the semiring). +-- For combining occurrences of the same variable in subterms. +-- This is a refinement of the 'max' operation for 'FlexRig' +-- which would work if 'Flexible' did not have the 'MetaSet' as an argument. +-- Now, to aggregate two 'Flexible' occurrences, we union the involved 'MetaSet's. + +addFlexRig :: Semigroup a => FlexRig' a -> FlexRig' a -> FlexRig' a +addFlexRig = curry $ \case + -- StronglyRigid is dominant + (StronglyRigid, _) -> StronglyRigid + (_, StronglyRigid) -> StronglyRigid + -- Next is Unguarded + (Unguarded, _) -> Unguarded + (_, Unguarded) -> Unguarded + -- Then WeaklyRigid + (WeaklyRigid, _) -> WeaklyRigid + (_, WeaklyRigid) -> WeaklyRigid + -- Least is Flexible. We union the meta sets, as the variable + -- is tainted by all of the involved meta variable. + (Flexible ms1, Flexible ms2) -> Flexible $ ms1 <> ms2 + +-- | Unit for 'addFlexRig'. +zeroFlexRig :: Monoid a => FlexRig' a +zeroFlexRig = Flexible mempty + +-- | Absorptive for 'addFlexRig'. +omegaFlexRig :: FlexRig' a +omegaFlexRig = StronglyRigid + +-- | 'FlexRig' composition (multiplicative operation of the semiring). +-- For accumulating the context of a variable. -- -- 'Flexible' is dominant. Once we are under a meta, we are flexible --- regardless what else comes. +-- regardless what else comes. We taint all variable occurrences +-- under a meta by this meta. -- -- 'WeaklyRigid' is next in strength. Destroys strong rigidity. -- -- 'StronglyRigid' is still dominant over 'Unguarded'. -- -- 'Unguarded' is the unit. It is the top (identity) context. -composeFlexRig :: FlexRig -> FlexRig -> FlexRig -composeFlexRig o o' = - case (o, o') of - (Flexible ms1, Flexible ms2) -> Flexible $ ms1 `mappend` ms2 +-- +composeFlexRig :: Semigroup a => FlexRig' a -> FlexRig' a -> FlexRig' a +composeFlexRig = curry $ \case + (Flexible ms1, Flexible ms2) -> Flexible $ ms1 <> ms2 (Flexible ms1, _) -> Flexible ms1 (_, Flexible ms2) -> Flexible ms2 (WeaklyRigid, _) -> WeaklyRigid @@ -87,81 +204,178 @@ (_, StronglyRigid) -> StronglyRigid (Unguarded, Unguarded) -> Unguarded --- -- | 'FlexRig' supremum. Extract the most information about a variable. --- -- --- -- We make this the default 'Monoid' for 'FlexRig'. --- instance Monoid FlexRig where --- mempty = minBound --- mappend = max +-- | Unit for 'composeFlexRig'. +oneFlexRig :: FlexRig' a +oneFlexRig = Unguarded +--------------------------------------------------------------------------- +-- * Multi-dimensional feature vector for variable occurrence (semigroup) + -- | Occurrence of free variables is classified by several dimensions. --- Currently, we have 'FlexRig' and 'Relevance'. -data VarOcc = VarOcc - { varFlexRig :: FlexRig - , varRelevance :: Relevance +-- Currently, we have 'FlexRig' and 'Modality'. +data VarOcc' a = VarOcc + { varFlexRig :: FlexRig' a + , varModality :: Modality } - deriving (Eq, Show) + deriving (Show) +type VarOcc = VarOcc' MetaSet --- | When we extract information about occurrence, we care most about --- about 'StronglyRigid' 'Relevant' occurrences. -maxVarOcc :: VarOcc -> VarOcc -> VarOcc -maxVarOcc (VarOcc o r) (VarOcc o' r') = VarOcc (max o o') (min r r') +-- | Equality up to origin. +instance Eq a => Eq (VarOcc' a) where + VarOcc fr m == VarOcc fr' m' = fr == fr' && sameModality m m' -topVarOcc :: VarOcc -topVarOcc = VarOcc StronglyRigid Relevant +instance LensModality (VarOcc' a) where + getModality = varModality + mapModality f (VarOcc x r) = VarOcc x $ f r -botVarOcc :: VarOcc -botVarOcc = VarOcc (Flexible mempty) Irrelevant +instance LensRelevance (VarOcc' a) where +instance LensQuantity (VarOcc' a) where --- | First argument is the outer occurrence and second is the inner. -composeVarOcc :: VarOcc -> VarOcc -> VarOcc -composeVarOcc (VarOcc o r) (VarOcc o' r') = VarOcc (composeFlexRig o o') (max r r') +-- | Access to 'varFlexRig' in 'VarOcc'. +instance LensFlexRig a (VarOcc' a) where + lensFlexRig f (VarOcc fr m) = f fr <&> \ fr' -> VarOcc fr' m +-- lensFlexRig :: Lens' (FlexRig' a) (VarOcc' a) +-- lensFlexRig f (VarOcc fr m) = f fr <&> \ fr' -> VarOcc fr' m -instance LensRelevance VarOcc where - getRelevance = varRelevance - setRelevance rel (VarOcc x _) = VarOcc x rel --- | Any representation of a set of variables need to be able to be modified by +-- | The default way of aggregating free variable info from subterms is by adding +-- the variable occurrences. For instance, if we have a pair @(t₁,t₂)@ then +-- and @t₁@ has @o₁@ the occurrences of a variable @x@ +-- and @t₂@ has @o₂@ the occurrences of the same variable, then +-- @(t₁,t₂)@ has @mappend o₁ o₂@ occurrences of that variable. +-- +-- From counting 'Quantity', we extrapolate this to 'FlexRig' and 'Relevance': +-- we care most about about 'StronglyRigid' 'Relevant' occurrences. +-- E.g., if @t₁@ has a 'StronglyRigid' occurrence and @t₂@ a 'Flexible' occurrence, +-- then @(t₁,t₂)@ still has a 'StronglyRigid' occurrence. +-- Analogously, @Relevant@ occurrences count most, as we wish e.g. to forbid +-- relevant occurrences of variables that are declared to be irrelevant. +-- +-- 'VarOcc' forms a semiring, and this monoid is the addition of the semiring. + +instance Semigroup a => Semigroup (VarOcc' a) where + VarOcc o m <> VarOcc o' m' = VarOcc (addFlexRig o o') (addModality m m') + +-- | The neutral element for variable occurrence aggregation is least serious +-- occurrence: flexible, irrelevant. +-- This is also the absorptive element for 'composeVarOcc', if we ignore +-- the 'MetaSet' in 'Flexible'. +instance (Semigroup a, Monoid a) => Monoid (VarOcc' a) where + mempty = VarOcc (Flexible mempty) zeroModality + mappend = (<>) + +-- | The absorptive element of variable occurrence under aggregation: +-- strongly rigid, relevant. +topVarOcc :: VarOcc' a +topVarOcc = VarOcc StronglyRigid topModality + +-- | First argument is the outer occurrence (context) and second is the inner. +-- This multiplicative operation is to modify an occurrence under a context. +composeVarOcc :: Semigroup a => VarOcc' a -> VarOcc' a -> VarOcc' a +composeVarOcc (VarOcc o m) (VarOcc o' m') = VarOcc (composeFlexRig o o') (m <> m') + -- We use the multipicative modality monoid (composition). + +oneVarOcc :: VarOcc' a +oneVarOcc = VarOcc Unguarded mempty + +--------------------------------------------------------------------------- +-- * Storing variable occurrences (semimodule). + +-- | Any representation @c@ of a set of variables need to be able to be modified by -- a variable occurrence. This is to ensure that free variable analysis is -- compositional. For instance, it should be possible to compute `fv (v [u/x])` -- from `fv v` and `fv u`. -class (Semigroup a, Monoid a) => IsVarSet a where +-- +-- In algebraic terminology, a variable set @a@ needs to be (almost) a left semimodule +-- to the semiring 'VarOcc'. +class (Singleton MetaId a, Semigroup a, Monoid a, Semigroup c, Monoid c) => IsVarSet a c | c -> a where -- | Laws -- * Respects monoid operations: -- ``` -- withVarOcc o mempty == mempty -- withVarOcc o (x <> y) == withVarOcc o x <> withVarOcc o y -- ``` - -- * Respects VarOcc composition + -- * Respects VarOcc composition: -- ``` + -- withVarOcc oneVarOcc = id -- withVarOcc (composeVarOcc o1 o2) = withVarOcc o1 . withVarOcc o2 -- ``` - withVarOcc :: VarOcc -> a -> a + -- * Respects VarOcc aggregation: + -- ``` + -- withVarOcc (o1 <> o2) x = withVarOcc o1 x <> withVarOcc o2 x + -- ``` + -- Since the corresponding unit law may fail, + -- ``` + -- withVarOcc mempty x = mempty + -- ``` + -- it is not quite a semimodule. + withVarOcc :: VarOcc' a -> c -> c -type TheVarMap = IntMap VarOcc -newtype VarMap = VarMap { theVarMap :: TheVarMap } - deriving (Show, Singleton (Variable, VarOcc)) +-- | Representation of a variable set as map from de Bruijn indices +-- to 'VarOcc'. +type TheVarMap' a = IntMap (VarOcc' a) +newtype VarMap' a = VarMap { theVarMap :: TheVarMap' a } + deriving (Eq, Show) -mapVarMap :: (TheVarMap -> TheVarMap) -> VarMap -> VarMap +type TheVarMap = TheVarMap' MetaSet +type VarMap = VarMap' MetaSet + +-- | A "set"-style 'Singleton' instance with default/initial variable occurrence. +instance Singleton Variable (VarMap' a) where + singleton i = VarMap $ IntMap.singleton i oneVarOcc + +mapVarMap :: (TheVarMap' a -> TheVarMap' b) -> VarMap' a -> VarMap' b mapVarMap f = VarMap . f . theVarMap -instance Semigroup VarMap where - VarMap m <> VarMap m' = VarMap $ IntMap.unionWith maxVarOcc m m' +lookupVarMap :: Variable -> VarMap' a -> Maybe (VarOcc' a) +lookupVarMap i = IntMap.lookup i . theVarMap -- Andreas & Jesper, 2018-05-11, issue #3052: -- | Proper monoid instance for @VarMap@ rather than inheriting the broken one from IntMap. --- We combine two occurrences of a variable using 'maxVarOcc'. -instance Monoid VarMap where +-- We combine two occurrences of a variable using 'mappend'. +instance Semigroup a => Semigroup (VarMap' a) where + VarMap m <> VarMap m' = VarMap $ IntMap.unionWith (<>) m m' + +instance Semigroup a => Monoid (VarMap' a) where mempty = VarMap IntMap.empty mappend = (<>) - mconcat = VarMap . IntMap.unionsWith maxVarOcc . map theVarMap + mconcat = VarMap . IntMap.unionsWith (<>) . map theVarMap + -- mconcat = VarMap . IntMap.unionsWith mappend . coerce -- ghc 8.6.5 does not seem to like this coerce -instance IsVarSet VarMap where +instance (Singleton MetaId a, Semigroup a, Monoid a) => IsVarSet a (VarMap' a) where withVarOcc o = mapVarMap $ fmap $ composeVarOcc o --- * Collecting free variables. +--------------------------------------------------------------------------- +-- * Simple flexible/rigid variable collection. + +-- | Keep track of 'FlexRig' for every variable, but forget the involved meta vars. +type TheFlexRigMap = IntMap (FlexRig' ()) +newtype FlexRigMap = FlexRigMap { theFlexRigMap :: TheFlexRigMap } + deriving (Show, Singleton (Variable, FlexRig' ())) + +mapFlexRigMap :: (TheFlexRigMap -> TheFlexRigMap) -> FlexRigMap -> FlexRigMap +mapFlexRigMap f = FlexRigMap . f . theFlexRigMap + +instance Semigroup FlexRigMap where + FlexRigMap m <> FlexRigMap m' = FlexRigMap $ IntMap.unionWith addFlexRig m m' + +instance Monoid FlexRigMap where + mempty = FlexRigMap IntMap.empty + mappend = (<>) + mconcat = FlexRigMap . IntMap.unionsWith addFlexRig . map theFlexRigMap + +-- | Compose everything with the 'varFlexRig' part of the 'VarOcc'. +instance IsVarSet () FlexRigMap where + withVarOcc o = mapFlexRigMap $ fmap $ composeFlexRig $ () <$ varFlexRig o + +instance Singleton MetaId () where + singleton _ = () + +--------------------------------------------------------------------------- +-- * Environment for collecting free variables. + -- | Where should we skip sorts in free variable analysis? data IgnoreSorts @@ -172,94 +386,128 @@ -- | The current context. -data FreeEnv c = FreeEnv - { feIgnoreSorts :: !IgnoreSorts - -- ^ Ignore free variables in sorts. - , feFlexRig :: !FlexRig +data FreeEnv' a b c = FreeEnv + { feExtra :: !b + -- ^ Additional context, e.g., whether to ignore free variables in sorts. + , feFlexRig :: !(FlexRig' a) -- ^ Are we flexible or rigid? - , feRelevance :: !Relevance - -- ^ What is the current relevance? - , feSingleton :: Maybe Variable -> c + , feModality :: !Modality + -- ^ What is the current relevance and quantity? + , feSingleton :: Maybe Variable -> c -- ^ Method to return a single variable. } type Variable = Int type SingleVar c = Variable -> c +type FreeEnv c = FreeEnv' MetaSet IgnoreSorts c + +-- | Ignore free variables in sorts. +feIgnoreSorts :: FreeEnv' a IgnoreSorts c -> IgnoreSorts +feIgnoreSorts = feExtra + +instance LensFlexRig a (FreeEnv' a b c) where + lensFlexRig f e = f (feFlexRig e) <&> \ fr -> e { feFlexRig = fr } + +instance LensModality (FreeEnv' a b c) where + getModality = feModality + mapModality f e = e { feModality = f (feModality e) } + +instance LensRelevance (FreeEnv' a b c) where +instance LensQuantity (FreeEnv' a b c) where + -- | The initial context. -initFreeEnv :: Monoid c => SingleVar c -> FreeEnv c -initFreeEnv sing = FreeEnv - { feIgnoreSorts = IgnoreNot +initFreeEnv :: Monoid c => b -> SingleVar c -> FreeEnv' a b c +initFreeEnv e sing = FreeEnv + { feExtra = e , feFlexRig = Unguarded - , feRelevance = Relevant + , feModality = mempty -- multiplicative monoid , feSingleton = maybe mempty sing } -type FreeM c = Reader (FreeEnv c) c +type FreeT a b m c = ReaderT (FreeEnv' a b c) m c +type FreeM a c = Reader (FreeEnv' a IgnoreSorts c) c -- | Run function for FreeM. -runFreeM :: IsVarSet c => SingleVar c -> IgnoreSorts -> FreeM c -> c -runFreeM single i m = runReader m $ (initFreeEnv single) { feIgnoreSorts = i } +runFreeM :: IsVarSet a c => SingleVar c -> IgnoreSorts -> FreeM a c -> c +runFreeM single i m = runReader m $ initFreeEnv i single -instance Semigroup c => Semigroup (FreeM c) where +instance (Applicative m, Semigroup c) => Semigroup (FreeT a b m c) where (<>) = liftA2 (<>) -instance (Semigroup c, Monoid c) => Monoid (FreeM c) where +instance (Functor m, Applicative m, Monad m, Semigroup c, Monoid c) => Monoid (FreeT a b m c) where mempty = pure mempty mappend = (<>) mconcat = mconcat <.> sequence --- instance Singleton a c => Singleton a (FreeM c) where --- singleton = pure . singleton - -- | Base case: a variable. -variable :: IsVarSet c => Int -> FreeM c +variable :: (Monad m, IsVarSet a c) => Int -> FreeT a b m c variable n = do o <- asks feFlexRig - r <- asks feRelevance + r <- asks feModality s <- asks feSingleton - pure $ withVarOcc (VarOcc o r) (s $ Just n) + return $ withVarOcc (VarOcc o r) (s $ Just n) -- | Subtract, but return Nothing if result is negative. subVar :: Int -> Maybe Variable -> Maybe Variable -subVar n x = x >>= \ i -> (i - n) <$ guard (n <= i) +-- subVar n x = x >>= \ i -> (i - n) <$ guard (n <= i) +subVar n x = do + i <- x + guard $ i >= n + return $ i - n -- | Going under a binder. -bind :: FreeM a -> FreeM a -bind = bind' 1 +underBinder :: MonadReader (FreeEnv' a b c) m => m z -> m z +underBinder = underBinder' 1 -bind' :: Nat -> FreeM a -> FreeM a -bind' n = local $ \ e -> e { feSingleton = feSingleton e . subVar n } +-- | Going under @n@ binders. +underBinder' :: MonadReader (FreeEnv' a b c) m => Nat -> m z -> m z +underBinder' n = local $ \ e -> e { feSingleton = feSingleton e . subVar n } --- | Changing the 'FlexRig' context. -go :: FlexRig -> FreeM a -> FreeM a -go o = local $ \ e -> e { feFlexRig = composeFlexRig o $ feFlexRig e } +-- | Changing the 'Modality'. +underModality :: (MonadReader r m, LensModality r, LensModality o) => o -> m z -> m z +underModality = local . mapModality . composeModality . getModality -- | Changing the 'Relevance'. -goRel :: Relevance-> FreeM a -> FreeM a -goRel r = local $ \ e -> e { feRelevance = composeRelevance r $ feRelevance e } +underRelevance :: (MonadReader r m, LensRelevance r, LensRelevance o) => o -> m z -> m z +underRelevance = local . mapRelevance . composeRelevance . getRelevance +-- | Changing the 'FlexRig' context. +underFlexRig :: (MonadReader r m, LensFlexRig a r, Semigroup a, LensFlexRig a o) => o -> m z -> m z +underFlexRig = local . over lensFlexRig . composeFlexRig . view lensFlexRig + -- | What happens to the variables occurring under a constructor? -underConstructor :: ConHead -> FreeM a -> FreeM a +underConstructor :: (MonadReader r m, LensFlexRig a r, Semigroup a) => ConHead -> m z -> m z underConstructor (ConHead c i fs) = case (i,fs) of -- Coinductive (record) constructors admit infinite cycles: - (CoInductive, _) -> go WeaklyRigid - -- Inductive data constructors do not admit infinite cycles: - (Inductive, []) -> go StronglyRigid - -- Inductive record constructors do not admit infinite cycles, - -- but this cannot be proven inside Agda. - -- Thus, unification should not prove it either. - (Inductive, (_:_)) -> id + (CoInductive, _) -> underFlexRig WeaklyRigid + -- Inductive constructors do not admit infinite cycles: + (Inductive, _) -> underFlexRig StronglyRigid + -- Ulf, 2019-10-18: Now the termination checker treats inductive recursive records + -- the same as datatypes, so absense of infinite cycles can be proven in Agda, and thus + -- the unifier is allowed to do it too. Test case: test/Succeed/Issue1271a.agda + -- WAS: + -- -- Inductive record constructors do not admit infinite cycles, + -- -- but this cannot be proven inside Agda. + -- -- Thus, unification should not prove it either. + -- (Inductive, (_:_)) -> id +--------------------------------------------------------------------------- +-- * Recursively collecting free variables. + -- | Gather free variables in a collection. -class Free a where +class Free t where -- Misplaced SPECIALIZE pragma: -- {-# SPECIALIZE freeVars' :: a -> FreeM Any #-} -- So you cannot specialize all instances in one go. :( - freeVars' :: IsVarSet c => a -> FreeM c + freeVars' :: IsVarSet a c => t -> FreeM a c + default freeVars' :: (t ~ f b, Foldable f, Free b) => IsVarSet a c => t -> FreeM a c + freeVars' = foldMap freeVars' + + instance Free Term where -- SPECIALIZE instance does not work as well, see -- https://ghc.haskell.org/trac/ghc/ticket/10434#ticket @@ -267,13 +515,13 @@ -- {-# SPECIALIZE freeVars' :: Term -> FreeM Any #-} -- {-# SPECIALIZE freeVars' :: Term -> FreeM All #-} -- {-# SPECIALIZE freeVars' :: Term -> FreeM VarSet #-} - freeVars' t = case t of - Var n ts -> variable n `mappend` do go WeaklyRigid $ freeVars' ts + freeVars' t = case unSpine t of -- #4484: unSpine to avoid projected variables being treated as StronglyRigid + Var n ts -> variable n `mappend` do underFlexRig WeaklyRigid $ freeVars' ts -- λ is not considered guarding, as -- we cannot prove that x ≡ λy.x is impossible. Lam _ t -> freeVars' t Lit _ -> mempty - Def _ ts -> go WeaklyRigid $ freeVars' ts -- because we are not in TCM + Def _ ts -> underFlexRig WeaklyRigid $ freeVars' ts -- because we are not in TCM -- we cannot query whether we are dealing with a data/record (strongly r.) -- or a definition by pattern matching (weakly rigid) -- thus, we approximate, losing that x = List x is unsolvable @@ -285,11 +533,11 @@ Pi a b -> freeVars' (a,b) Sort s -> freeVars' s Level l -> freeVars' l - MetaV m ts -> go (Flexible $ singleton m) $ freeVars' ts - DontCare mt -> goRel Irrelevant $ freeVars' mt + MetaV m ts -> underFlexRig (Flexible $ singleton m) $ freeVars' ts + DontCare mt -> underModality (Modality Irrelevant mempty mempty) $ freeVars' mt Dummy{} -> mempty -instance Free a => Free (Type' a) where +instance Free t => Free (Type' t) where freeVars' (El s t) = ifM ((IgnoreNot ==) <$> asks feIgnoreSorts) {- then -} (freeVars' (s, t)) @@ -303,57 +551,59 @@ Prop a -> freeVars' a Inf -> mempty SizeUniv -> mempty - PiSort s1 s2 -> go WeaklyRigid $ freeVars' (s1, s2) - UnivSort s -> go WeaklyRigid $ freeVars' s - MetaS x es -> go (Flexible $ singleton x) $ freeVars' es - DefS _ es -> go WeaklyRigid $ freeVars' es + PiSort a s -> underFlexRig (Flexible mempty) (freeVars' $ unDom a) `mappend` + underFlexRig WeaklyRigid (freeVars' (getSort a, s)) + FunSort s1 s2 -> freeVars' s1 `mappend` freeVars' s2 + UnivSort s -> underFlexRig WeaklyRigid $ freeVars' s + MetaS x es -> underFlexRig (Flexible $ singleton x) $ freeVars' es + DefS _ es -> underFlexRig WeaklyRigid $ freeVars' es DummyS{} -> mempty instance Free Level where - freeVars' (Max as) = freeVars' as + freeVars' (Max _ as) = freeVars' as instance Free PlusLevel where - freeVars' ClosedLevel{} = mempty freeVars' (Plus _ l) = freeVars' l instance Free LevelAtom where freeVars' l = case l of - MetaLevel m vs -> go (Flexible $ singleton m) $ freeVars' vs + MetaLevel m vs -> underFlexRig (Flexible $ singleton m) $ freeVars' vs NeutralLevel _ v -> freeVars' v BlockedLevel _ v -> freeVars' v UnreducedLevel v -> freeVars' v -instance Free a => Free [a] where - freeVars' = foldMap freeVars' +instance Free t => Free [t] where +instance Free t => Free (Maybe t) where +instance Free t => Free (WithHiding t) where -instance Free a => Free (Maybe a) where - freeVars' = foldMap freeVars' +instance (Free t, Free u) => Free (t, u) where + freeVars' (t, u) = freeVars' t `mappend` freeVars' u -instance (Free a, Free b) => Free (a, b) where - freeVars' (x,y) = freeVars' x `mappend` freeVars' y +instance (Free t, Free u, Free v) => Free (t, u, v) where + freeVars' (t, u, v) = freeVars' t `mappend` freeVars' u `mappend` freeVars' v -instance Free a => Free (Elim' a) where - freeVars' (Apply a) = freeVars' a +instance Free t => Free (Elim' t) where + freeVars' (Apply t) = freeVars' t freeVars' (Proj{} ) = mempty - freeVars' (IApply x y r) = mconcat $ map freeVars' [x,y,r] + freeVars' (IApply x y r) = freeVars' (x,y,r) -instance Free a => Free (Arg a) where - freeVars' a = goRel (getRelevance a) $ freeVars' $ unArg a +instance Free t => Free (Arg t) where + freeVars' t = underModality (getModality t) $ freeVars' $ unArg t -instance Free a => Free (Dom a) where - freeVars' = freeVars' . unDom +instance Free t => Free (Dom t) where + freeVars' d = freeVars' (domTactic d, unDom d) -instance Free a => Free (Abs a) where - freeVars' (Abs _ b) = bind $ freeVars' b +instance Free t => Free (Abs t) where + freeVars' (Abs _ b) = underBinder $ freeVars' b freeVars' (NoAbs _ b) = freeVars' b -instance Free a => Free (Tele a) where +instance Free t => Free (Tele t) where freeVars' EmptyTel = mempty - freeVars' (ExtendTel a tel) = freeVars' (a, tel) + freeVars' (ExtendTel t tel) = freeVars' (t, tel) instance Free Clause where - freeVars' cl = bind' (size $ clauseTel cl) $ freeVars' $ clauseBody cl + freeVars' cl = underBinder' (size $ clauseTel cl) $ freeVars' $ clauseBody cl instance Free EqualityView where freeVars' (OtherType t) = freeVars' t - freeVars' (EqualityType s _eq l t a b) = freeVars' s `mappend` freeVars' (l ++ [t, a, b]) + freeVars' (EqualityType s _eq l t a b) = freeVars' (s, l, [t, a, b]) diff --git a/src/full/Agda/TypeChecking/Free/Old.hs b/src/full/Agda/TypeChecking/Free/Old.hs deleted file mode 100644 --- a/src/full/Agda/TypeChecking/Free/Old.hs +++ /dev/null @@ -1,357 +0,0 @@ - --- | Computing the free variables of a term. --- --- This is the old version of ''Agda.TypeChecking.Free'', using --- 'IntSet's for the separate variable categories. --- We keep it as a specification. --- --- The distinction between rigid and strongly rigid occurrences comes from: --- Jason C. Reed, PhD thesis, 2009, page 96 (see also his LFMTP 2009 paper) --- --- The main idea is that x = t(x) is unsolvable if x occurs strongly rigidly --- in t. It might have a solution if the occurrence is not strongly rigid, e.g. --- --- x = \f -> suc (f (x (\ y -> k))) has x = \f -> suc (f (suc k)) --- --- [Jason C. Reed, PhD thesis, page 106] --- --- Under coinductive constructors, occurrences are never strongly rigid. --- Also, function types and lambdas do not establish strong rigidity. --- Only inductive constructors do so. --- (See issue 1271). - -module Agda.TypeChecking.Free.Old - ( FreeVars(..) - , Free - , IgnoreSorts(..) - , freeVars - , freeVarsIgnore - , allVars - , relevantVars - , rigidVars - , freeIn, isBinderUsed - , freeInIgnoringSorts, freeInIgnoringSortAnn - , relevantIn, relevantInIgnoringSortAnn - , Occurrence(..) - , occurrence - ) where - -import Control.Applicative hiding (empty) -import Control.Monad.Reader - -import Data.Foldable (foldMap) -import Data.Monoid ( Monoid, mempty, mappend, mconcat ) -import Data.Semigroup ( Semigroup, (<>) ) - -import Agda.Syntax.Common -import Agda.Syntax.Internal - -import Agda.Utils.Functor -import Agda.Utils.Monad -import Agda.Utils.Size -import Agda.Utils.VarSet (VarSet) -import qualified Agda.Utils.VarSet as Set - --- | Free variables of a term, (disjointly) partitioned into strongly and --- and weakly rigid variables, flexible variables and irrelevant variables. -data FreeVars = FV - { stronglyRigidVars :: VarSet - -- ^ Variables under only and at least one inductive constructor(s). - , unguardedVars :: VarSet - -- ^ Variables at top or only under inductive record constructors - -- λs and Πs. - -- The purpose of recording these separately is that they - -- can still become strongly rigid if put under a constructor - -- whereas weakly rigid ones stay weakly rigid. - , weaklyRigidVars :: VarSet - -- ^ Ordinary rigid variables, e.g., in arguments of variables. - , flexibleVars :: VarSet - -- ^ Variables occuring in arguments of metas. - -- These are only potentially free, depending how the meta variable is instantiated. - , irrelevantVars :: VarSet - -- ^ Variables in irrelevant arguments and under a @DontCare@, i.e., - -- in irrelevant positions. - } deriving (Eq, Show) - --- | Rigid variables: either strongly rigid, unguarded, or weakly rigid. -rigidVars :: FreeVars -> VarSet -rigidVars fv = Set.unions - [ stronglyRigidVars fv - , unguardedVars fv - , weaklyRigidVars fv - ] - --- | All but the irrelevant variables. -relevantVars :: FreeVars -> VarSet -relevantVars fv = Set.unions [rigidVars fv, flexibleVars fv] - --- | @allVars fv@ includes irrelevant variables. -allVars :: FreeVars -> VarSet -allVars fv = Set.unions [relevantVars fv, irrelevantVars fv] - -data Occurrence - = NoOccurrence - | Irrelevantly - | StronglyRigid -- ^ Under at least one and only inductive constructors. - | Unguarded -- ^ In top position, or only under inductive record constructors. - | WeaklyRigid -- ^ In arguments to variables and definitions. - | Flexible -- ^ In arguments of metas. - deriving (Eq,Show) - -{- NO LONGER --- | @occurrence x fv@ ignores irrelevant variables in @fv@ --} -occurrence :: Nat -> FreeVars -> Occurrence -occurrence x fv - | x `Set.member` stronglyRigidVars fv = StronglyRigid - | x `Set.member` unguardedVars fv = Unguarded - | x `Set.member` weaklyRigidVars fv = WeaklyRigid - | x `Set.member` flexibleVars fv = Flexible - | x `Set.member` irrelevantVars fv = Irrelevantly - | otherwise = NoOccurrence - --- | Mark variables as flexible. Useful when traversing arguments of metas. -flexible :: FreeVars -> FreeVars -flexible fv = - fv { stronglyRigidVars = Set.empty - , unguardedVars = Set.empty - , weaklyRigidVars = Set.empty - , flexibleVars = relevantVars fv - } - --- | Mark rigid variables as non-strongly. Useful when traversion arguments of variables. -weakly :: FreeVars -> FreeVars -weakly fv = fv - { stronglyRigidVars = Set.empty - , unguardedVars = Set.empty - , weaklyRigidVars = rigidVars fv - } - --- | Mark unguarded variables as strongly rigid. Useful when traversion arguments of inductive constructors. -strongly :: FreeVars -> FreeVars -strongly fv = fv - { stronglyRigidVars = stronglyRigidVars fv `Set.union` unguardedVars fv - , unguardedVars = Set.empty - } - --- | What happens to the variables occurring under a constructor? -underConstructor :: ConHead -> FreeVars -> FreeVars -underConstructor (ConHead c i fs) = - case (i,fs) of - -- Coinductive (record) constructors admit infinite cycles: - (CoInductive, _) -> weakly - -- Inductive data constructors do not admit infinite cycles: - (Inductive, []) -> strongly - -- Inductive record constructors do not admit infinite cycles, - -- but this cannot be proven inside Agda. - -- Thus, unification should not prove it either. - (Inductive, (_:_)) -> id - --- | Mark all free variables as irrelevant. -irrelevantly :: FreeVars -> FreeVars -irrelevantly fv = empty { irrelevantVars = allVars fv } - --- | Pointwise union. -union :: FreeVars -> FreeVars -> FreeVars -union (FV sv1 gv1 rv1 fv1 iv1) (FV sv2 gv2 rv2 fv2 iv2) = - FV (Set.union sv1 sv2) (Set.union gv1 gv2) (Set.union rv1 rv2) (Set.union fv1 fv2) (Set.union iv1 iv2) - -unions :: [FreeVars] -> FreeVars -unions = foldr union empty - -empty :: FreeVars -empty = FV Set.empty Set.empty Set.empty Set.empty Set.empty - --- | Free variable sets form a monoid under 'union'. -instance Semigroup FreeVars where - (<>) = union - -instance Monoid FreeVars where - mempty = empty - mappend = (<>) - mconcat = unions - --- | @delete x fv@ deletes variable @x@ from variable set @fv@. -delete :: Nat -> FreeVars -> FreeVars -delete n (FV sv gv rv fv iv) = FV (Set.delete n sv) (Set.delete n gv) (Set.delete n rv) (Set.delete n fv) (Set.delete n iv) - --- | @subtractFV n fv@ subtracts $n$ from each free variable in @fv@. -subtractFV :: Nat -> FreeVars -> FreeVars -subtractFV n (FV sv gv rv fv iv) = FV (Set.subtract n sv) (Set.subtract n gv) (Set.subtract n rv) (Set.subtract n fv) (Set.subtract n iv) - --- | A single unguarded variable. -singleton :: Nat -> FreeVars -singleton x = empty { unguardedVars = Set.singleton x } - --- * Collecting free variables. - --- | Where should we skip sorts in free variable analysis? -data IgnoreSorts - = IgnoreNot -- ^ Do not skip. - | IgnoreInAnnotations -- ^ Skip when annotation to a type. - | IgnoreAll -- ^ Skip unconditionally. - deriving (Eq, Show) - -data FreeConf = FreeConf - { fcIgnoreSorts :: !IgnoreSorts - -- ^ Ignore free variables in sorts. - , fcContext :: !Int - -- ^ Under how many binders have we stepped? - } - -initFreeConf :: FreeConf -initFreeConf = FreeConf - { fcIgnoreSorts = IgnoreNot - , fcContext = 0 - } - --- | Doesn't go inside solved metas, but collects the variables from a --- metavariable application @X ts@ as @flexibleVars@. -freeVars :: Free a => a -> FreeVars -freeVars t = freeVars' t `runReader` initFreeConf - -freeVarsIgnore :: Free a => IgnoreSorts -> a -> FreeVars -freeVarsIgnore i t = freeVars' t `runReader` initFreeConf{ fcIgnoreSorts = i } - --- | Return type of fold over syntax. -type FreeT = Reader FreeConf FreeVars - -instance Semigroup FreeT where - (<>) = liftA2 mappend - -instance Monoid FreeT where - mempty = pure mempty - mappend = (<>) - mconcat = mconcat <.> sequence - --- | Base case: a variable. -variable :: Int -> FreeT -variable n = do - m <- (n -) <$> asks fcContext - if m >= 0 then pure $ singleton m else mempty - --- | Going under a binder. -bind :: FreeT -> FreeT -bind = bind' 1 - --- | Going under n binders. -bind' :: Nat -> FreeT -> FreeT -bind' n = local $ \ e -> e { fcContext = n + fcContext e } - -class Free a where - freeVars' :: a -> FreeT - -instance Free Term where - freeVars' t = case t of - Var n ts -> variable n `mappend` do weakly <$> freeVars' ts - -- λ is not considered guarding, as - -- we cannot prove that x ≡ λy.x is impossible. - Lam _ t -> freeVars' t - Lit _ -> mempty - Def _ ts -> weakly <$> freeVars' ts -- because we are not in TCM - -- we cannot query whether we are dealing with a data/record (strongly r.) - -- or a definition by pattern matching (weakly rigid) - -- thus, we approximate, losing that x = List x is unsolvable - Con c _ ts -> underConstructor c <$> freeVars' ts - -- Pi is not guarding, since we cannot prove that A ≡ B → A is impossible. - -- Even as we do not permit infinite type expressions, - -- we cannot prove their absence (as Set is not inductive). - -- Also, this is incompatible with univalence (HoTT). - Pi a b -> freeVars' (a,b) - Sort s -> freeVars' s - Level l -> freeVars' l - MetaV _ ts -> flexible <$> freeVars' ts - DontCare mt -> irrelevantly <$> freeVars' mt - Dummy{} -> mempty - -instance Free Type where - freeVars' (El s t) = - ifM ((IgnoreNot ==) <$> asks fcIgnoreSorts) - {- then -} (freeVars' (s, t)) - {- else -} (freeVars' t) - -instance Free Sort where - freeVars' s = - ifM ((IgnoreAll ==) <$> asks fcIgnoreSorts) mempty $ {- else -} - case s of - Type a -> freeVars' a - Prop a -> freeVars' a - Inf -> mempty - SizeUniv -> mempty - PiSort s1 s2 -> weakly <$> freeVars' (s1, s2) - UnivSort s -> weakly <$> freeVars' s - MetaS x es -> flexible <$> freeVars' es - DefS _ es -> weakly <$> freeVars' es - DummyS{} -> mempty - -instance Free Level where - freeVars' (Max as) = freeVars' as - -instance Free PlusLevel where - freeVars' ClosedLevel{} = mempty - freeVars' (Plus _ l) = freeVars' l - -instance Free LevelAtom where - freeVars' l = case l of - MetaLevel _ vs -> flexible <$> freeVars' vs - NeutralLevel _ v -> freeVars' v - BlockedLevel _ v -> freeVars' v - UnreducedLevel v -> freeVars' v - -instance Free a => Free [a] where - freeVars' = foldMap freeVars' - -instance Free a => Free (Maybe a) where - freeVars' = foldMap freeVars' - -instance (Free a, Free b) => Free (a,b) where - freeVars' (x,y) = freeVars' x `mappend` freeVars' y - -instance Free a => Free (Elim' a) where - freeVars' (Apply a) = freeVars' a - freeVars' (Proj{} ) = mempty - freeVars' (IApply x y r) = mconcat $ map freeVars' [x,y,r] - -instance Free a => Free (Arg a) where - freeVars' a = f <$> freeVars' (unArg a) - where f = case getRelevance a of - Irrelevant -> irrelevantly - _ -> id - - -instance Free a => Free (Dom a) where - freeVars' = freeVars' . unDom - -instance Free a => Free (Abs a) where - freeVars' (Abs _ b) = bind $ freeVars' b - freeVars' (NoAbs _ b) = freeVars' b - -instance Free a => Free (Tele a) where - freeVars' EmptyTel = mempty - freeVars' (ExtendTel a tel) = freeVars' (a, tel) - -instance Free Clause where - freeVars' cl = bind' (size $ clauseTel cl) $ freeVars' $ clauseBody cl - -freeIn :: Free a => Nat -> a -> Bool -freeIn v t = v `Set.member` allVars (freeVars t) - -freeInIgnoringSorts :: Free a => Nat -> a -> Bool -freeInIgnoringSorts v t = - v `Set.member` allVars (freeVarsIgnore IgnoreAll t) - -freeInIgnoringSortAnn :: Free a => Nat -> a -> Bool -freeInIgnoringSortAnn v t = - v `Set.member` allVars (freeVarsIgnore IgnoreInAnnotations t) - -relevantInIgnoringSortAnn :: Free a => Nat -> a -> Bool -relevantInIgnoringSortAnn v t = - v `Set.member` relevantVars (freeVarsIgnore IgnoreInAnnotations t) - -relevantIn :: Free a => Nat -> a -> Bool -relevantIn v t = v `Set.member` relevantVars (freeVarsIgnore IgnoreAll t) - --- | Is the variable bound by the abstraction actually used? -isBinderUsed :: Free a => Abs a -> Bool -isBinderUsed NoAbs{} = False -isBinderUsed (Abs _ x) = 0 `freeIn` x diff --git a/src/full/Agda/TypeChecking/Free/Precompute.hs b/src/full/Agda/TypeChecking/Free/Precompute.hs --- a/src/full/Agda/TypeChecking/Free/Precompute.hs +++ b/src/full/Agda/TypeChecking/Free/Precompute.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE TypeFamilies #-} -- | Precompute free variables in a term (and store in 'ArgInfo'). module Agda.TypeChecking.Free.Precompute @@ -12,11 +11,9 @@ import Agda.Syntax.Common import Agda.Syntax.Internal -import Agda.Utils.Functor -import Agda.Utils.Impossible -#include "undefined.h" + type FV = Writer IntSet precomputeFreeVars_ :: PrecomputeFreeVars a => a -> a @@ -83,17 +80,17 @@ Prop a -> Prop <$> precomputeFreeVars a Inf -> pure s SizeUniv -> pure s - PiSort s1 s2 -> uncurry PiSort <$> precomputeFreeVars (s1, s2) + PiSort a s -> uncurry PiSort <$> precomputeFreeVars (a, s) + FunSort s1 s2 -> uncurry FunSort <$> precomputeFreeVars (s1, s2) UnivSort s -> UnivSort <$> precomputeFreeVars s MetaS x es -> MetaS x <$> precomputeFreeVars es DefS d es -> DefS d <$> precomputeFreeVars es DummyS{} -> pure s instance PrecomputeFreeVars Level where - precomputeFreeVars (Max ls) = Max <$> precomputeFreeVars ls + precomputeFreeVars (Max n ls) = Max n <$> precomputeFreeVars ls instance PrecomputeFreeVars PlusLevel where - precomputeFreeVars l@ClosedLevel{} = pure l precomputeFreeVars (Plus n l) = Plus n <$> precomputeFreeVars l instance PrecomputeFreeVars LevelAtom where diff --git a/src/full/Agda/TypeChecking/Free/Reduce.hs b/src/full/Agda/TypeChecking/Free/Reduce.hs --- a/src/full/Agda/TypeChecking/Free/Reduce.hs +++ b/src/full/Agda/TypeChecking/Free/Reduce.hs @@ -13,8 +13,6 @@ import Data.IntMap (IntMap) import qualified Data.IntSet as IntSet import Data.IntSet (IntSet) -import qualified Data.Set as Set -import Data.Set (Set) import Data.Traversable (traverse) import Agda.Syntax.Common @@ -44,7 +42,7 @@ -- Initially, all variables are marked as `NotFree`. This is changed -- to `MaybeFree` when we find an occurrence. let mxs = IntMap.fromSet (const NotFree) xs - (a, mxs) <- runStateT (runReaderT (forceNotFreeR $ precomputeFreeVars_ a) Set.empty) mxs + (a, mxs) <- runStateT (runReaderT (forceNotFreeR $ precomputeFreeVars_ a) mempty) mxs return (mxs, a) type MonadFreeRed m = @@ -121,7 +119,7 @@ Var x <$> forceNotFree' es Def f es -> Def f <$> forceNotFree' es Con c h es -> Con c h <$> forceNotFree' es - MetaV x es -> local (Set.insert x) $ + MetaV x es -> local (insertMetaSet x) $ MetaV x <$> forceNotFree' es Lam h b -> Lam h <$> forceNotFree' b Pi a b -> Pi <$> forceNotFree' a <*> forceNotFree' b -- Dom and Abs do reduceIf so not needed here @@ -132,16 +130,14 @@ Dummy{} -> return t instance ForceNotFree Level where - forceNotFree' (Max as) = Max <$> forceNotFree' as + forceNotFree' (Max m as) = Max m <$> forceNotFree' as instance ForceNotFree PlusLevel where - forceNotFree' l = case l of - ClosedLevel{} -> return l - Plus k a -> Plus k <$> forceNotFree' a + forceNotFree' (Plus k a) = Plus k <$> forceNotFree' a instance ForceNotFree LevelAtom where forceNotFree' l = case l of - MetaLevel x es -> local (Set.insert x) $ + MetaLevel x es -> local (insertMetaSet x) $ MetaLevel x <$> forceNotFree' es BlockedLevel x t -> BlockedLevel x <$> forceNotFree' t NeutralLevel b t -> NeutralLevel b <$> forceNotFree' t @@ -154,6 +150,7 @@ Type l -> Type <$> forceNotFree' l Prop l -> Prop <$> forceNotFree' l PiSort a b -> PiSort <$> forceNotFree' a <*> forceNotFree' b + FunSort a b -> FunSort <$> forceNotFree' a <*> forceNotFree' b UnivSort s -> UnivSort <$> forceNotFree' s MetaS x es -> MetaS x <$> forceNotFree' es DefS d es -> DefS d <$> forceNotFree' es diff --git a/src/full/Agda/TypeChecking/Functions.hs b/src/full/Agda/TypeChecking/Functions.hs --- a/src/full/Agda/TypeChecking/Functions.hs +++ b/src/full/Agda/TypeChecking/Functions.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} module Agda.TypeChecking.Functions ( etaExpandClause @@ -13,7 +12,6 @@ import Agda.TypeChecking.Monad.Base import Agda.TypeChecking.Monad.Context import Agda.TypeChecking.Monad.Debug -import Agda.TypeChecking.Monad.Options import Agda.TypeChecking.Level import Agda.TypeChecking.Pretty import Agda.TypeChecking.Reduce @@ -26,7 +24,6 @@ import Agda.Utils.Monad import Agda.Utils.Size -#include "undefined.h" -- | Expand a clause to the maximal arity, by inserting variable -- patterns and applying the body to variables. @@ -41,9 +38,9 @@ etaExpandClause :: MonadTCM tcm => Clause -> tcm Clause etaExpandClause clause = liftTCM $ do case clause of - Clause _ _ ctel ps _ Nothing _ _ -> return clause - Clause _ _ ctel ps Nothing (Just t) _ _ -> return clause - Clause rl rf ctel ps (Just body) (Just t) catchall unreachable -> do + Clause _ _ ctel ps _ Nothing _ _ _ _ -> return clause + Clause _ _ ctel ps Nothing (Just t) _ _ _ _ -> return clause + Clause rl rf ctel ps (Just body) (Just t) catchall recursive unreachable ell -> do -- Get the telescope to expand the clause with. TelV tel0 t' <- telView $ unArg t @@ -65,7 +62,7 @@ , " xs = " <+> text (prettyShow xs) , " new tel = " <+> prettyTCM ctel' ] - return $ Clause rl rf ctel' ps' (Just body') (Just (t $> t')) catchall unreachable + return $ Clause rl rf ctel' ps' (Just body') (Just (t $> t')) catchall recursive unreachable ell where -- Get all initial lambdas of the body. peekLambdas :: Term -> [Arg ArgName] diff --git a/src/full/Agda/TypeChecking/Generalize.hs b/src/full/Agda/TypeChecking/Generalize.hs --- a/src/full/Agda/TypeChecking/Generalize.hs +++ b/src/full/Agda/TypeChecking/Generalize.hs @@ -1,11 +1,12 @@ -{-# LANGUAGE CPP #-} module Agda.TypeChecking.Generalize ( generalizeType , generalizeType' , generalizeTelescope ) where -import Control.Arrow ((***), first, second) +import Prelude hiding (null) + +import Control.Arrow (first) import Control.Monad import Data.IntSet (IntSet) import qualified Data.IntSet as IntSet @@ -13,21 +14,19 @@ import qualified Data.Set as Set import Data.Map (Map) import qualified Data.Map as Map -import Data.List (nub, partition, init, sortBy) +import Data.List (partition, sortBy) import Data.Monoid import Data.Function (on) -import Data.Traversable import Agda.Syntax.Common import Agda.Syntax.Concrete.Name (LensInScope(..)) import Agda.Syntax.Position import Agda.Syntax.Internal import Agda.Syntax.Internal.Generic -import Agda.Syntax.Literal -import Agda.Syntax.Scope.Monad (bindVariable) -import Agda.Syntax.Scope.Base (Binder(..)) +import Agda.Syntax.Internal.MetaVars +import Agda.Syntax.Scope.Monad (bindVariable, outsideLocalVars) +import Agda.Syntax.Scope.Base (BindingSource(..)) import Agda.TypeChecking.Monad -import Agda.TypeChecking.Abstract import Agda.TypeChecking.Constraints import Agda.TypeChecking.Conversion import Agda.TypeChecking.Free @@ -45,21 +44,19 @@ import Agda.Utils.Except import Agda.Utils.Functor import Agda.Utils.Impossible -import Agda.Utils.Lens +import Agda.Utils.List (hasElem) import Agda.Utils.Maybe import Agda.Utils.Monad +import Agda.Utils.Null import Agda.Utils.Size -import Agda.Utils.Singleton import Agda.Utils.Permutation -import qualified Agda.Utils.Graph.TopSort as Graph -#include "undefined.h" -- | Generalize a telescope over a set of generalizable variables. generalizeTelescope :: Map QName Name -> (forall a. (Telescope -> TCM a) -> TCM a) -> ([Maybe Name] -> Telescope -> TCM a) -> TCM a generalizeTelescope vars typecheckAction ret | Map.null vars = typecheckAction (ret []) generalizeTelescope vars typecheckAction ret = billTo [Typing, Generalize] $ withGenRecVar $ \ genRecMeta -> do - let s = Set.fromList (Map.keys vars) + let s = Map.keysSet vars ((cxtNames, tel, letbinds), namedMetas, allmetas) <- createMetasAndTypeCheck s $ typecheckAction $ \ tel -> do cxt <- take (size tel) <$> getContext @@ -122,7 +119,7 @@ reportSDoc "tc.generalize" 40 $ vcat [ "generalized" - , nest 2 $ "t =" <+> escapeContext 1 (prettyTCM t') ] + , nest 2 $ "t =" <+> escapeContext __IMPOSSIBLE__ 1 (prettyTCM t') ] return (genTelNames, t', userdata) @@ -152,6 +149,9 @@ -- this telescope to the current context. computeGeneralization :: Type -> Map MetaId name -> IntSet -> TCM (Telescope, [Maybe name], Substitution) computeGeneralization genRecMeta nameMap allmetas = postponeInstanceConstraints $ do + + reportSDoc "tc.generalize" 10 $ "computing generalization for type" <+> prettyTCM genRecMeta + -- Pair metas with their metaInfo mvs <- mapM ((\ x -> (x,) <$> lookupMeta x) . MetaId) $ IntSet.toList allmetas @@ -159,6 +159,9 @@ ((++) <$> useTC stAwakeConstraints <*> useTC stSleepingConstraints) + reportSDoc "tc.generalize" 30 $ nest 2 $ + "constrainedMetas = " <+> prettyList_ (map prettyTCM $ Set.toList constrainedMetas) + let isConstrained x = Set.member x constrainedMetas -- Note: Always generalize named metas even if they are constrained. We -- freeze them so they won't be instantiated by the constraint, and we do @@ -175,17 +178,22 @@ (openSortMetas, generalizableOpen) = partition isSort generalizableOpen' nongeneralizableOpen = filter isOpen nongeneralizable + reportSDoc "tc.generalize" 30 $ nest 2 $ vcat + [ "generalizable = " <+> prettyList_ (map (prettyTCM . fst) generalizable) + , "generalizableOpen = " <+> prettyList_ (map (prettyTCM . fst) generalizableOpen) + , "openSortMetas = " <+> prettyList_ (map (prettyTCM . fst) openSortMetas) + ] + -- Issue 3301: We can't generalize over sorts - case openSortMetas of - [] -> return () - ms -> warning $ CantGeneralizeOverSorts (map fst ms) + unlessNull openSortMetas $ \ ms -> + warning $ CantGeneralizeOverSorts $ map fst ms -- Any meta in the solution of a generalizable meta should be generalized over (if possible). cp <- viewTC eCurrentCheckpoint let canGeneralize x | isConstrained x = return False canGeneralize x = do mv <- lookupMeta x - msub <- enterClosure (miClosRange $ mvInfo mv) $ \ _ -> + msub <- enterClosure mv $ \ _ -> checkpointSubstitution' cp let sameContext = -- We can only generalize if the metavariable takes the context variables of the @@ -228,12 +236,20 @@ let (alsoGeneralize, reallyDontGeneralize) = partition (`Set.member` inherited) $ map fst nongeneralizableOpen generalizeOver = map fst generalizableOpen ++ alsoGeneralize - shouldGeneralize = (`Set.member` Set.fromList generalizeOver) + shouldGeneralize = (generalizeOver `hasElem`) + reportSDoc "tc.generalize" 30 $ nest 2 $ vcat + [ "alsoGeneralize = " <+> prettyList_ (map prettyTCM alsoGeneralize) + , "reallyDontGeneralize = " <+> prettyList_ (map prettyTCM reallyDontGeneralize) + ] + + reportSDoc "tc.generalize" 10 $ "we're generalizing over" <+> prettyList_ (map prettyTCM generalizeOver) + -- Sort metas in dependency order. Include open metas that we are not -- generalizing over, since they will need to be pruned appropriately (see -- Issue 3672). - allSortedMetas <- sortMetas (generalizeOver ++ reallyDontGeneralize) + allSortedMetas <- fromMaybeM (typeError GeneralizeCyclicDependency) $ + dependencySortMetas (generalizeOver ++ reallyDontGeneralize) let sortedMetas = filter shouldGeneralize allSortedMetas let dropCxt err = updateContext (strengthenS err 1) (drop 1) @@ -242,10 +258,19 @@ (genRecName, genRecCon, genRecFields) <- dropCxt __IMPOSSIBLE__ $ createGenRecordType genRecMeta sortedMetas + reportSDoc "tc.generalize" 30 $ vcat $ + [ "created genRecordType" + , nest 2 $ "genRecName = " <+> prettyTCM genRecName + , nest 2 $ "genRecCon = " <+> prettyTCM genRecCon + , nest 2 $ "genRecFields = " <+> prettyList_ (map prettyTCM genRecFields) + ] + -- Solve the generalizable metas. Each generalizable meta is solved by projecting the -- corresponding field from the genTel record. cxtTel <- getContextTelescope let solve m field = do + reportSDoc "tc.generalize" 30 $ "solving generalized meta" <+> + prettyTCM m <+> ":=" <+> prettyTCM (Var 0 [Proj ProjSystem field]) -- m should not be instantiated, but if we don't check constraints -- properly it could be (#3666 and #3667). Fail hard instead of -- generating bogus types. @@ -263,7 +288,9 @@ mv <- lookupMeta m let info = getArgInfo $ miGeneralizable $ mvInfo mv HasType{ jMetaType = t } = mvJudgement mv - return [(Arg info $ miNameSuggestion $ mvInfo mv, piApply t args)] + perm = mvPermutation mv + t' <- piApplyM t $ permute (takeP (length args) perm) args + return [(Arg info $ miNameSuggestion $ mvInfo mv, t')] let genTel = buildGeneralizeTel genRecCon teleTypes reportSDoc "tc.generalize" 40 $ vcat @@ -326,7 +353,7 @@ prePrune x = do cp <- viewTC eCurrentCheckpoint mv <- lookupMeta x - (i, _A) <- enterClosure (miClosRange $ mvInfo mv) $ \ _ -> do + (i, _A) <- enterClosure mv $ \ _ -> do δ <- checkpointSubstitution cp _A <- case mvJudgement mv of IsSort{} -> return Nothing @@ -366,7 +393,7 @@ , "uρ⁻¹ =" <+> pretty uρ' ] -- To solve it we enter the context of x again - enterClosure (miClosRange $ mvInfo mv) $ \ _ -> do + enterClosure mv $ \ _ -> do -- v is x applied to the context variables v <- case _A of Nothing -> Sort . MetaS x . map Apply <$> getMetaContextArgs mv @@ -380,7 +407,7 @@ mv <- lookupMeta x -- The reason we are doing all this inside the closure of x is so that if x is an interaction -- meta we get the right context for the pruned interaction meta. - enterClosure (miClosRange $ mvInfo mv) $ \ _ -> + enterClosure mv $ \ _ -> -- If we can't find the generalized record, it's already been pruned and we don't have to do -- anything. whenJustM (findGenRec mv) $ \ i -> do @@ -461,8 +488,8 @@ (y, u) <- updateContext ρ (const newCxt) $ localScope $ do -- First, we add the named variables to the scope, to allow - -- them to be used in holes (#3341). - addNamedVariablesToScope rΘ + -- them to be used in holes (#3341). These should go outside Δ (#3735). + outsideLocalVars i $ addNamedVariablesToScope rΘ -- Now we can create the new meta newMetaFromOld mv ρ _A @@ -517,25 +544,25 @@ Just _A -> do let _Aρ = applySubst ρ _A newNamedValueMeta DontRunMetaOccursCheck - (miNameSuggestion $ mvInfo mv) _Aρ + (miNameSuggestion $ mvInfo mv) + (jComparison $ mvJudgement mv) _Aρ -- If x is a hole, update the hole to point to y instead. setInteractionPoint x y = whenJust (Map.lookup x interactionPoints) (`connectInteractionPoint` y) doPrune :: MetaId -> MetaVariable -> Maybe Type -> Term -> Term -> TCM () - doPrune x mv _A v u = - case _A of - _ | isOpen -> assign DirEq x (getArgs v) u + doPrune x mv mt v u = + case mt of + _ | isOpen -> assign DirEq x (getArgs v) u $ maybe AsTypes AsTermsOf mt Nothing -> equalSort (unwrapSort v) (unwrapSort u) - Just _A -> equalTerm _A v u + Just t -> equalTerm t v u where isOpen = isOpenMeta $ mvInstantiation mv - getArgs v = case v of - Sort (MetaS _ es) -> unApply es - MetaV _ es -> unApply es + getArgs = \case + Sort (MetaS _ es) -> fromMaybe __IMPOSSIBLE__ $ allApplyElims es + MetaV _ es -> fromMaybe __IMPOSSIBLE__ $ allApplyElims es _ -> __IMPOSSIBLE__ - where unApply es = fromMaybe __IMPOSSIBLE__ $ allApplyElims es unwrapSort (Sort s) = s unwrapSort _ = __IMPOSSIBLE__ @@ -656,10 +683,10 @@ argTel = telFromList $ map hideExplicit $ take nGen $ telToList tel args <- newTelMeta argTel + metaType <- piApplyM ty args - let metaType = piApply ty args - name = show (nameConcrete $ qnameName x) - (m, term) <- newNamedValueMeta DontRunMetaOccursCheck name metaType + let name = show (nameConcrete $ qnameName x) + (m, term) <- newNamedValueMeta DontRunMetaOccursCheck name CmpLeq metaType -- Freeze the meta to prevent named generalizable metas to be instantiated. updateMetaVar m $ \ mv -> mv { mvFrozen = Frozen } @@ -690,26 +717,6 @@ , genvalTerm = term , genvalType = metaType }) --- | Sort metas in dependency order. -sortMetas :: [MetaId] -> TCM [MetaId] -sortMetas metas = do - metaGraph <- concat <$> do - forM metas $ \ m -> do - deps <- allMetas (\ m' -> if m' `elem` metas then singleton m' else mempty) <$> getType m - return [ (m, m') | m' <- Set.toList deps ] - - caseMaybe (Graph.topSort metas metaGraph) - (typeError GeneralizeCyclicDependency) - return - - where - -- Sort metas don't have types, but we still want to sort them. - getType m = do - mv <- lookupMeta m - case mvJudgement mv of - IsSort{} -> return Nothing - HasType{ jMetaType = t } -> Just <$> instantiateFull t - -- | Create a not-yet correct record type for the generalized telescope. It's not yet correct since -- we haven't computed the telescope yet, and we need the record type to do it. createGenRecordType :: Type -> [MetaId] -> TCM (QName, ConHead, [QName]) @@ -717,20 +724,21 @@ current <- currentModule let freshQName s = qualify current <$> freshName_ (s :: String) mkFieldName = freshQName . (generalizedFieldName ++) <=< getMetaNameSuggestion - genRecFields <- mapM (defaultArg <.> mkFieldName) sortedMetas + genRecFields <- mapM (defaultDom <.> mkFieldName) sortedMetas genRecName <- freshQName "GeneralizeTel" genRecCon <- freshQName "mkGeneralizeTel" <&> \ con -> ConHead { conName = con , conInductive = Inductive - , conFields = genRecFields } - forM_ (zip sortedMetas genRecFields) $ \ (meta, fld) -> do + , conFields = map argFromDom genRecFields } + projIx <- succ . size <$> getContext + inTopContext $ forM_ (zip sortedMetas genRecFields) $ \ (meta, fld) -> do fieldTy <- getMetaType meta - let field = unArg fld - addConstant field $ defaultDefn (argInfo fld) field fieldTy $ + let field = unDom fld + addConstant field $ defaultDefn (getArgInfo fld) field fieldTy $ let proj = Projection { projProper = Just genRecName , projOrig = field , projFromType = defaultArg genRecName - , projIndex = 1 + , projIndex = projIx , projLams = ProjLams [defaultArg "gtel"] } in Function { funClauses = [] , funCompiled = Nothing @@ -745,7 +753,6 @@ , funTerminates = Just True , funExtLam = Nothing , funWith = Nothing - , funCopatternLHS = False , funCovering = [] } addConstant (conName genRecCon) $ defaultDefn defaultArgInfo (conName genRecCon) __DUMMY_TYPE__ $ -- Filled in later @@ -755,9 +762,10 @@ , conData = genRecName , conAbstr = ConcreteDef , conInd = Inductive - , conComp = (emptyCompKit, Nothing) + , conComp = emptyCompKit + , conProj = Nothing , conForced = [] - , conErased = [] + , conErased = Nothing } let dummyTel 0 = EmptyTel dummyTel n = ExtendTel (defaultDom __DUMMY_TYPE__) $ Abs "_" $ dummyTel (n - 1) @@ -772,14 +780,17 @@ , recEtaEquality' = Inferred YesEta , recInduction = Nothing , recAbstr = ConcreteDef - , recComp = emptyCompKit } - reportSDoc "tc.generalize" 40 $ vcat + , recComp = emptyCompKit + } + reportSDoc "tc.generalize" 20 $ vcat + [ text "created genRec" <+> prettyList_ (map (text . show . unDom) genRecFields) ] + reportSDoc "tc.generalize" 80 $ vcat [ text "created genRec" <+> text (show genRecFields) ] -- Solve the genRecMeta args <- getContextArgs let genRecTy = El genRecSort $ Def genRecName $ map Apply args noConstraints $ equalType genRecTy genRecMeta - return (genRecName, genRecCon, map unArg genRecFields) + return (genRecName, genRecCon, map unDom genRecFields) -- | Once we have the generalized telescope we can fill in the missing details of the record type. fillInGenRecordDetails :: QName -> ConHead -> [QName] -> Type -> Telescope -> TCM () @@ -792,7 +803,7 @@ abstract cxtTel (El s $ Pi (defaultDom recTy) (Abs "r" $ unDom ty)) : mkFieldTypes flds (absApp ftel proj) where - s = PiSort (getSort recTy) (Abs "r" $ getSort ty) + s = PiSort (defaultDom recTy) (Abs "r" $ getSort ty) proj = Var 0 [Proj ProjSystem fld] mkFieldTypes _ _ = __IMPOSSIBLE__ let fieldTypes = mkFieldTypes fields (raise 1 fieldTel) diff --git a/src/full/Agda/TypeChecking/IApplyConfluence.hs b/src/full/Agda/TypeChecking/IApplyConfluence.hs --- a/src/full/Agda/TypeChecking/IApplyConfluence.hs +++ b/src/full/Agda/TypeChecking/IApplyConfluence.hs @@ -1,10 +1,10 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE NondecreasingIndentation #-} module Agda.TypeChecking.IApplyConfluence where import Prelude hiding (null, (!!)) -- do not use partial functions like !! import Control.Monad +import Control.Arrow (first,second) import Control.Monad.Reader import Control.Monad.Trans ( lift ) @@ -19,46 +19,34 @@ import Agda.Syntax.Common import Agda.Syntax.Position +import Agda.Syntax.Internal.Generic -- import Agda.Syntax.Literal import Agda.Syntax.Internal import Agda.Syntax.Internal.Pattern import Agda.Interaction.Options -import Agda.TypeChecking.Names import Agda.TypeChecking.Primitive hiding (Nat) -import Agda.TypeChecking.Primitive.Cubical +-- import Agda.TypeChecking.Primitive.Cubical import Agda.TypeChecking.Monad import Agda.TypeChecking.Monad.Builtin -import Agda.TypeChecking.Conversion (tryConversion, equalType, equalTermOnFace) +import Agda.TypeChecking.Conversion (equalTermOnFace) import Agda.TypeChecking.Pretty -import Agda.TypeChecking.Substitute -import Agda.TypeChecking.Reduce import Agda.TypeChecking.Records -import Agda.TypeChecking.Telescope +import Agda.TypeChecking.Reduce import Agda.TypeChecking.Telescope.Path +import Agda.TypeChecking.Telescope +import Agda.TypeChecking.Conversion +import Agda.TypeChecking.Substitute -import Agda.Utils.Either -import Agda.Utils.Except - ( ExceptT - , MonadError(catchError, throwError) - , runExceptT - ) -import Agda.Utils.Function -import Agda.Utils.Functor -import Agda.Utils.List -import Agda.Utils.Maybe import Agda.Utils.Monad import Agda.Utils.Null -import Agda.Utils.Permutation -import Agda.Utils.Pretty (prettyShow) +import Agda.Utils.Maybe import Agda.Utils.Size -import Agda.Utils.Tuple -import Agda.Utils.Lens - -#include "undefined.h" import Agda.Utils.Impossible +import Agda.Utils.Functor + checkIApplyConfluence_ :: QName -> TCM () checkIApplyConfluence_ f = whenM (optCubical <$> pragmaOptions) $ do -- Andreas, 2019-03-27, iapply confluence should only be checked when --cubical. @@ -75,30 +63,187 @@ modifySignature $ updateDefinition f $ updateTheDef $ updateCovering (const []) - forM_ cls $ checkIApplyConfluence f + traceCall (CheckFunDefCall (getRange f) f []) $ + forM_ cls $ checkIApplyConfluence f _ -> return () -- | @addClause f (Clause {namedClausePats = ps})@ checks that @f ps@ -- reduces in a way that agrees with @IApply@ reductions. -checkIApplyConfluence :: QName -> Closure Clause -> TCM () -checkIApplyConfluence f clos = do - enterClosure clos $ \ cl -> - case cl of +checkIApplyConfluence :: QName -> Clause -> TCM () +checkIApplyConfluence f cl = case cl of Clause {clauseBody = Nothing} -> return () Clause {clauseType = Nothing} -> __IMPOSSIBLE__ - cl@Clause { clauseTel = tel + cl@Clause { clauseTel = clTel , namedClausePats = ps , clauseType = Just t , clauseBody = Just body } -> setCurrentRange (getRange f) $ do let trhs = unArg t - reportSDoc "tc.cover.iapply" 40 $ "tel =" <+> prettyTCM tel + reportSDoc "tc.cover.iapply" 40 $ "tel =" <+> prettyTCM clTel reportSDoc "tc.cover.iapply" 40 $ "ps =" <+> pretty ps ps <- normaliseProjP ps forM_ (iApplyVars ps) $ \ i -> do unview <- intervalUnview' - let phi = unview $ IMax (argN $ var $ i) $ argN $ unview (INeg $ argN $ var i) + let phi = unview $ IMax (argN $ unview (INeg $ argN $ var i)) $ argN $ var i let es = patternsToElims ps let lhs = Def f es - equalTermOnFace phi trhs lhs body + + reportSDoc "tc.iapply" 40 $ text "clause:" <+> pretty ps <+> "->" <+> pretty body + reportSDoc "tc.iapply" 20 $ "body =" <+> prettyTCM body + + addContext clTel $ equalTermOnFace phi trhs lhs body + + case body of + MetaV m es_m' | Just es_m <- allApplyElims es_m' -> + caseMaybeM (isInteractionMeta m) (return ()) $ \ ii -> do + cs' <- do + reportSDoc "tc.iapply.ip" 20 $ "clTel =" <+> prettyTCM clTel + mv <- lookupMeta m + enterClosure (getMetaInfo mv) $ \ _ -> do -- mTel ⊢ + ty <- getMetaType m + mTel <- getContextTelescope + reportSDoc "tc.iapply.ip" 20 $ "size mTel =" <+> pretty (size mTel) + reportSDoc "tc.iapply.ip" 20 $ "size es_m =" <+> pretty (size es_m) + + unless (size mTel == size es_m) $ reportSDoc "tc.iapply.ip" 20 $ "funny number of elims" <+> text (show (size mTel, size es_m)) + unless (size mTel <= size es_m) $ __IMPOSSIBLE__ + let over = if size mTel == size es_m then NotOverapplied else Overapplied + + -- extend telescope to handle extra elims + TelV mTel1 _ <- telViewUpToPath (size es_m) ty + reportSDoc "tc.iapply.ip" 20 $ "mTel1 =" <+> prettyTCM mTel1 + + addContext (mTel1 `apply` teleArgs mTel) $ do + mTel <- getContextTelescope + + addContext clTel $ do -- mTel.clTel ⊢ + () <- reportSDoc "tc.iapply.ip" 40 $ "mTel.clTel =" <+> (prettyTCM =<< getContextTelescope) + forallFaceMaps phi __IMPOSSIBLE__ $ \ alpha -> do + -- mTel.clTel' ⊢ + -- mTel.clTel ⊢ alpha : mTel.clTel' + reportSDoc "tc.iapply.ip" 40 $ "mTel.clTel' =" <+> (prettyTCM =<< getContextTelescope) + + -- TelV tel _ <- telViewUpTo (size es) ty + reportSDoc "tc.iapply.ip" 40 $ "i0S =" <+> pretty alpha + reportSDoc "tc.iapply.ip" 20 $ fsep ["es :", pretty es] + reportSDoc "tc.iapply.ip" 20 $ fsep ["es_alpha :", pretty (alpha `applySubst` es) ] + + -- reducing path applications on endpoints in lhs + let + loop t@(Def _ es) = loop' t es + loop t@(Var _ es) = loop' t es + loop t@(Con _ _ es) = loop' t es + loop t@(MetaV _ es) = loop' t es + loop t = return t + loop' t es = ignoreBlocking <$> (reduceIApply' (pure . notBlocked) (pure . notBlocked $ t) es) + lhs <- liftReduce $ traverseTermM loop (Def f (alpha `applySubst` es)) + + let + idG = raise (size clTel) $ (teleElims mTel []) + + reportSDoc "tc.iapply.ip" 20 $ fsep ["lhs :", pretty lhs] + reportSDoc "tc.iapply.ip" 40 $ "cxt1 =" <+> (prettyTCM =<< getContextTelescope) + reportSDoc "tc.iapply.ip" 40 $ prettyTCM $ alpha `applySubst` ValueCmpOnFace CmpEq phi trhs lhs (MetaV m idG) + + unifyElims (teleArgs mTel) (alpha `applySubst` es_m) $ \ sigma eqs -> do + -- mTel.clTel'' ⊢ + -- mTel ⊢ clTel' ≃ clTel''.[eqs] + -- mTel.clTel'' ⊢ sigma : mTel.clTel' + reportSDoc "tc.iapply.ip" 40 $ "cxt2 =" <+> (prettyTCM =<< getContextTelescope) + reportSDoc "tc.iapply.ip" 40 $ "sigma =" <+> pretty sigma + reportSDoc "tc.iapply.ip" 20 $ "eqs =" <+> pretty eqs + + buildClosure $ IPBoundary + { ipbEquations = eqs + , ipbValue = sigma `applySubst` lhs + , ipbMetaApp = alpha `applySubst` MetaV m es_m' + , ipbOverapplied = over + } + + -- WAS: + -- fmap (over,) $ buildClosure $ (eqs + -- , sigma `applySubst` + -- (ValueCmp CmpEq (AsTermsOf (alpha `applySubst` trhs)) lhs (alpha `applySubst` MetaV m es_m))) + + let f ip = ip { ipClause = case ipClause ip of + ipc@IPClause{ipcBoundary = b} + -> ipc {ipcBoundary = b ++ cs'} + ipc@IPNoClause{} -> ipc} + modifyInteractionPoints (Map.adjust f ii) + _ -> return () + + +-- | current context is of the form Γ.Δ +unifyElims :: Args + -- ^ variables to keep Γ ⊢ x_n .. x_0 : Γ + -> Args + -- ^ variables to solve Γ.Δ ⊢ ts : Γ + -> (Substitution -> [(Term,Term)] -> TCM a) + -- Γ.Δ' ⊢ σ : Γ.Δ + -- Γ.Δ' new current context. + -- Γ.Δ' ⊢ [(x = u)] + -- Γ.Δ', [(x = u)] ⊢ id_g = ts[σ] : Γ + -> TCM a +unifyElims vs ts k = do + dom <- getContext + let (binds' , eqs' ) = candidate (map unArg vs) (map unArg ts) + (binds'', eqss') = + unzip $ map (\ (j,t:ts) -> ((j,t),map (,var j) ts)) $ Map.toList $ Map.fromListWith (++) (map (second (:[])) binds') + cod = codomain s (map fst binds) dom + binds = map (second (raise (size cod - size vs))) binds'' + eqs = map (first (raise $ size dom - size vs)) $ eqs' ++ concat eqss' + s = bindS binds + updateContext s (codomain s (map fst binds)) $ do + k s (s `applySubst` eqs) + where + candidate :: [Term] -> [Term] -> ([(Nat,Term)],[(Term,Term)]) + candidate (i:is) (Var j []:ts) = first ((j,i):) (candidate is ts) + candidate (i:is) (t:ts) = second ((i,t):) (candidate is ts) + candidate [] [] = ([],[]) + candidate _ _ = __IMPOSSIBLE__ + + + bindS binds = parallelS (for [0..maximum (-1:map fst binds)] $ (\ i -> fromMaybe (deBruijnVar i) (List.lookup i binds))) + + codomain :: Substitution + -> [Nat] -- ^ support + -> Context -> Context + codomain s vs cxt = map snd $ filter (\ (i,c) -> i `List.notElem` vs) $ zip [0..] cxt' + where + cxt' = zipWith (\ n d -> dropS n s `applySubst` d) [1..] cxt + + +-- | Like @unifyElims@ but @Γ@ is from the the meta's @MetaInfo@ and +-- the context extension @Δ@ is taken from the @Closure@. +unifyElimsMeta :: MetaId -> Args -> Closure Constraint -> ([(Term,Term)] -> Constraint -> TCM a) -> TCM a +unifyElimsMeta m es_m cl k = ifM (not . optCubical <$> pragmaOptions) (enterClosure cl $ k []) $ do + mv <- lookupMeta m + enterClosure (getMetaInfo mv) $ \ _ -> do -- mTel ⊢ + ty <- metaType m + mTel0 <- getContextTelescope + unless (size mTel0 == size es_m) $ reportSDoc "tc.iapply.ip.meta" 20 $ "funny number of elims" <+> text (show (size mTel0, size es_m)) + unless (size mTel0 <= size es_m) $ __IMPOSSIBLE__ -- meta has at least enough arguments to fill its creation context. + + -- if we have more arguments we extend the telescope accordingly. + TelV mTel1 _ <- telViewUpToPath (size es_m) ty + addContext (mTel1 `apply` teleArgs mTel0) $ do + mTel <- getContextTelescope + -- invariant: size mTel == size es_m + (c,cxt) <- enterClosure cl $ \ c -> (c,) <$> getContextTelescope + reportSDoc "tc.iapply.ip.meta" 20 $ prettyTCM cxt + + addContext cxt $ do + + reportSDoc "tc.iapply.ip.meta" 20 $ "es_m" <+> prettyTCM es_m + + reportSDoc "tc.iapply.ip.meta" 20 $ "trying unifyElims" + + unifyElims (teleArgs mTel) es_m $ \ sigma eqs -> do + + reportSDoc "tc.iapply.ip.meta" 20 $ "gotten a substitution" + + reportSDoc "tc.iapply.ip.meta" 20 $ "sigma:" <+> prettyTCM sigma + reportSDoc "tc.iapply.ip.meta" 20 $ "sigma:" <+> pretty sigma + + k eqs (sigma `applySubst` c) diff --git a/src/full/Agda/TypeChecking/Implicit.hs b/src/full/Agda/TypeChecking/Implicit.hs --- a/src/full/Agda/TypeChecking/Implicit.hs +++ b/src/full/Agda/TypeChecking/Implicit.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE PatternSynonyms #-} {-| Functions for inserting implicit arguments at the right places. @@ -12,25 +11,26 @@ import Agda.TypeChecking.Irrelevance import {-# SOURCE #-} Agda.TypeChecking.MetaVars +import {-# SOURCE #-} Agda.TypeChecking.Rules.Term (unquoteTactic) import Agda.TypeChecking.Monad import Agda.TypeChecking.Reduce import Agda.TypeChecking.Substitute import Agda.TypeChecking.Pretty +import Agda.Utils.Functor +import Agda.Utils.Maybe import Agda.Utils.Tuple -#include "undefined.h" -import Agda.Utils.Impossible - --- | @implicitArgs n expand t@ generates up to @n@ implicit arguments +-- | @implicitArgs n expand t@ generates up to @n@ implicit argument -- metas (unbounded if @n<0@), as long as @t@ is a function type -- and @expand@ holds on the hiding info of its domain. implicitArgs - :: Int -- ^ @n@, the maximum number of implicts to be inserted. + :: (MonadReduce m, MonadMetaSolver m, MonadDebug m, MonadTCM m) + => Int -- ^ @n@, the maximum number of implicts to be inserted. -> (Hiding -> Bool) -- ^ @expand@, the predicate to test whether we should keep inserting. -> Type -- ^ The (function) type @t@ we are eliminating. - -> TCM (Args, Type) -- ^ The eliminating arguments and the remaining type. + -> m (Args, Type) -- ^ The eliminating arguments and the remaining type. implicitArgs n expand t = mapFst (map (fmap namedThing)) <$> do implicitNamedArgs n (\ h x -> expand h) t @@ -39,18 +39,19 @@ -- and @expand@ holds on the hiding and name info of its domain. implicitNamedArgs - :: Int -- ^ @n@, the maximum number of implicts to be inserted. + :: (MonadReduce m, MonadMetaSolver m, MonadDebug m, MonadTCM m) + => Int -- ^ @n@, the maximum number of implicts to be inserted. -> (Hiding -> ArgName -> Bool) -- ^ @expand@, the predicate to test whether we should keep inserting. -> Type -- ^ The (function) type @t@ we are eliminating. - -> TCM (NamedArgs, Type) -- ^ The eliminating arguments and the remaining type. + -> m (NamedArgs, Type) -- ^ The eliminating arguments and the remaining type. implicitNamedArgs 0 expand t0 = return ([], t0) implicitNamedArgs n expand t0 = do t0' <- reduce t0 reportSDoc "tc.term.args" 30 $ "implicitNamedArgs" <+> prettyTCM t0' reportSDoc "tc.term.args" 80 $ "implicitNamedArgs" <+> text (show t0') case unEl t0' of - Pi Dom{domInfo = info, domName = name, unDom = a} b - | let x = maybe "_" rangedThing name, expand (getHiding info) x -> do + Pi dom@Dom{domInfo = info, domTactic = tac, unDom = a} b + | let x = bareNameWithDefault "_" dom, expand (getHiding info) x -> do info' <- if hidden info then return info else do reportSDoc "tc.term.args.ifs" 15 $ "inserting instance meta for type" <+> prettyTCM a @@ -60,48 +61,54 @@ ] return $ makeInstance info - (_, v) <- newMetaArg info' x a - let narg = Arg info (Named (Just $ unranged x) v) + (_, v) <- newMetaArg info' x CmpLeq a + whenJust tac $ \ tac -> liftTCM $ unquoteTactic tac v a + let narg = Arg info (Named (Just $ WithOrigin Inserted $ unranged x) v) mapFst (narg :) <$> implicitNamedArgs (n-1) expand (absApp b v) _ -> return ([], t0') -- | Create a metavariable according to the 'Hiding' info. newMetaArg - :: ArgInfo -- ^ Kind/relevance of meta. - -> ArgName -- ^ Name suggestion for meta. - -> Type -- ^ Type of meta. - -> TCM (MetaId, Term) -- ^ The created meta as id and as term. -newMetaArg info x a = do - applyModalityToContext info $ + :: MonadMetaSolver m + => ArgInfo -- ^ Kind/relevance of meta. + -> ArgName -- ^ Name suggestion for meta. + -> Comparison -- ^ Check (@CmpLeq@) or infer (@CmpEq@) the type. + -> Type -- ^ Type of meta. + -> m (MetaId, Term) -- ^ The created meta as id and as term. +newMetaArg info x cmp a = do + prp <- isPropM a + let irrelevantIfProp = if prp then applyRelevanceToContext Irrelevant else id + applyModalityToContext info $ irrelevantIfProp $ newMeta (getHiding info) (argNameToString x) a where - newMeta :: Hiding -> String -> Type -> TCM (MetaId, Term) - newMeta Instance{} = newInstanceMeta - newMeta Hidden = newNamedValueMeta RunMetaOccursCheck - newMeta NotHidden = newNamedValueMeta RunMetaOccursCheck + newMeta :: MonadMetaSolver m => Hiding -> String -> Type -> m (MetaId, Term) + newMeta Instance{} n = newInstanceMeta n + newMeta Hidden n = newNamedValueMeta RunMetaOccursCheck n cmp + newMeta NotHidden n = newNamedValueMeta RunMetaOccursCheck n cmp -- | Create a questionmark according to the 'Hiding' info. newInteractionMetaArg - :: ArgInfo -- ^ Kind/relevance of meta. - -> ArgName -- ^ Name suggestion for meta. - -> Type -- ^ Type of meta. + :: ArgInfo -- ^ Kind/relevance of meta. + -> ArgName -- ^ Name suggestion for meta. + -> Comparison -- ^ Check (@CmpLeq@) or infer (@CmpEq@) the type. + -> Type -- ^ Type of meta. -> TCM (MetaId, Term) -- ^ The created meta as id and as term. -newInteractionMetaArg info x a = do +newInteractionMetaArg info x cmp a = do applyModalityToContext info $ newMeta (getHiding info) (argNameToString x) a where newMeta :: Hiding -> String -> Type -> TCM (MetaId, Term) - newMeta Instance{} = newInstanceMeta - newMeta Hidden = newNamedValueMeta' RunMetaOccursCheck - newMeta NotHidden = newNamedValueMeta' RunMetaOccursCheck + newMeta Instance{} n = newInstanceMeta n + newMeta Hidden n = newNamedValueMeta' RunMetaOccursCheck n cmp + newMeta NotHidden n = newNamedValueMeta' RunMetaOccursCheck n cmp --------------------------------------------------------------------------- -- | Possible results of 'insertImplicit'. data ImplicitInsertion - = ImpInsert [Hiding] -- ^ Success: this many implicits have to be inserted (list can be empty). + = ImpInsert [Dom ()] -- ^ Success: this many implicits have to be inserted (list can be empty). | BadImplicits -- ^ Error: hidden argument where there should have been a non-hidden argument. | NoSuchName ArgName -- ^ Error: bad named argument. deriving (Show) @@ -118,10 +125,9 @@ :: NamedArg e -- ^ Next given argument @a@. -> [Dom a] -- ^ Expected arguments @ts@. -> ImplicitInsertion -insertImplicit a doms = insertImplicit' a $ map name doms - where - name dom = x <$ argFromDom dom - where x = maybe "_" rangedThing $ domName dom +insertImplicit a doms = insertImplicit' a $ + for doms $ \ dom -> + dom $> bareNameWithDefault "_" dom -- | If the next given argument is @a@ and the expected arguments are @ts@ -- @insertImplicit' a ts@ returns the prefix of @ts@ that precedes @a@. @@ -130,18 +136,18 @@ -- insertImplicit' :: NamedArg e -- ^ Next given argument @a@. - -> [Arg ArgName] -- ^ Expected arguments @ts@. + -> [Dom ArgName] -- ^ Expected arguments @ts@. -> ImplicitInsertion insertImplicit' _ [] = BadImplicits insertImplicit' a ts -- If @a@ is visible, then take the non-visible prefix of @ts@. - | visible a = ImpInsert $ takeWhile notVisible $ map getHiding ts + | visible a = ImpInsert $ takeWhile notVisible $ map void ts -- If @a@ is named, take prefix of @ts@ until the name of @a@ (with correct hiding). -- If the name is not found, throw exception 'NoSuchName'. - | Just x <- rangedThing <$> nameOf (unArg a) = maybe (NoSuchName x) ImpInsert $ - takeHiddenUntil (\ t -> x == unArg t && sameHiding a t) ts + | Just x <- bareNameOf a = maybe (NoSuchName x) ImpInsert $ + takeHiddenUntil (\ t -> x == unDom t && sameHiding a t) ts -- If @a@ is neither visible nor named, take prefix of @ts@ with different hiding than @a@. | otherwise = maybe BadImplicits ImpInsert $ @@ -153,10 +159,10 @@ -- If @p@ never holds, 'Nothing' is returned. -- -- Precondition: @p@ should imply @not . visible@. - takeHiddenUntil :: (Arg ArgName -> Bool) -> [Arg ArgName] -> Maybe [Hiding] + takeHiddenUntil :: (Dom ArgName -> Bool) -> [Dom ArgName] -> Maybe [Dom ()] takeHiddenUntil p ts = case ts2 of [] -> Nothing -- Predicate was never true - (t : _) -> if visible t then Nothing else Just $ map getHiding ts1 + (t : _) -> if visible t then Nothing else Just $ map void ts1 where (ts1, ts2) = break (\ t -> p t || visible t) ts diff --git a/src/full/Agda/TypeChecking/Injectivity.hs b/src/full/Agda/TypeChecking/Injectivity.hs --- a/src/full/Agda/TypeChecking/Injectivity.hs +++ b/src/full/Agda/TypeChecking/Injectivity.hs @@ -1,16 +1,53 @@ -{-# LANGUAGE CPP #-} +{- | +"Injectivity", or more precisely, "constructor headedness", is a +property of functions defined by pattern matching that helps us solve +constraints involving blocked applications of such functions. +"Blocked" shall mean here that pattern matching is blocked on a meta +variable, and constructor headedness lets us learn more about that +meta variable. + +Consider the simple example: +@ + isZero : Nat -> Bool + isZero zero = true + isZero (suc n) = false +@ +This function is constructor-headed, meaning that all rhss are headed +by a distinct constructor. Thus, on a constraint like +@ + isZero ?X = false : Bool +@ +involving an application of @isZero@ that is blocked on meta variable @?X@, +we can exploit injectivity and learn that @?X = suc ?Y@ for a new +meta-variable @?Y@. + +Which functions qualify for injectivity? + +1. The function needs to have at least one non-absurd clause that has +a proper match, meaning that the function can actually be blocked on a +meta. Proper matches are these patterns: + + - data constructor (@ConP@, but not record constructor) + - literal (@LitP@) + - HIT-patterns (@DefP@) + +Projection patterns (@ProjP@) are excluded because metas cannot occupy their place! + +2. All the clauses that satisfy (1.) need to be headed by a distinct constructor. + +-} + module Agda.TypeChecking.Injectivity where import Prelude hiding (mapM) import Control.Applicative -import Control.Arrow (first, second) +import Control.Monad.Fail import Control.Monad.State hiding (mapM, forM) import Control.Monad.Reader hiding (mapM, forM) import Control.Monad.Trans.Maybe -import Data.Map (Map) import qualified Data.Map as Map import qualified Data.Set as Set import Data.Maybe @@ -22,28 +59,25 @@ import Agda.Syntax.Internal import Agda.Syntax.Internal.Pattern +import Agda.TypeChecking.Irrelevance (isIrrelevantOrPropM) import Agda.TypeChecking.Monad import Agda.TypeChecking.Monad.Builtin import Agda.TypeChecking.Substitute import Agda.TypeChecking.Reduce -import Agda.TypeChecking.Primitive import {-# SOURCE #-} Agda.TypeChecking.MetaVars import {-# SOURCE #-} Agda.TypeChecking.Conversion -import Agda.TypeChecking.Pretty hiding ((<>)) -import Agda.TypeChecking.Constraints +import Agda.TypeChecking.Pretty import Agda.TypeChecking.Polarity import Agda.TypeChecking.Warnings -import Agda.Utils.Except ( MonadError(catchError, throwError) ) +import Agda.Utils.Except ( MonadError ) import Agda.Utils.Functor -import Agda.Utils.Lens import Agda.Utils.List import Agda.Utils.Maybe import Agda.Utils.Monad import Agda.Utils.Permutation import Agda.Utils.Pretty ( prettyShow ) -#include "undefined.h" import Agda.Utils.Impossible headSymbol :: Term -> TCM (Maybe TermHead) @@ -76,7 +110,8 @@ GeneralizableVar{} -> __IMPOSSIBLE__ Constructor{} -> __IMPOSSIBLE__ AbstractDefn{}-> __IMPOSSIBLE__ - Con c _ _ -> Just . ConsHead <$> canonicalName (conName c) + -- Andreas, 2019-07-10, issue #3900: canonicalName needs ignoreAbstractMode + Con c _ _ -> ignoreAbstractMode $ Just . ConsHead <$> canonicalName (conName c) Sort _ -> return (Just SortHead) Pi _ _ -> return (Just PiHead) Var i [] -> return (Just $ VarHead i) -- Only naked variables. Otherwise substituting a neutral term is not guaranteed to stay neutral. @@ -86,11 +121,13 @@ Level{} -> return Nothing MetaV{} -> return Nothing DontCare{} -> return Nothing - Dummy s -> __IMPOSSIBLE_VERBOSE__ s + Dummy s _ -> __IMPOSSIBLE_VERBOSE__ s -- | Do a full whnf and treat neutral terms as rigid. Used on the arguments to -- an injective functions and to the right-hand side. -headSymbol' :: Term -> TCM (Maybe TermHead) +headSymbol' + :: (MonadReduce m, MonadError TCErr m, MonadDebug m, HasBuiltins m) + => Term -> m (Maybe TermHead) headSymbol' v = do v <- traverse constructorForm =<< reduceB v case v of @@ -106,7 +143,7 @@ Level{} -> return Nothing MetaV{} -> return Nothing DontCare{} -> return Nothing - Dummy s -> __IMPOSSIBLE_VERBOSE__ s + Dummy s _ -> __IMPOSSIBLE_VERBOSE__ s -- | Does deBruijn variable i correspond to a top-level argument, and if so -- which one (index from the left). @@ -127,20 +164,24 @@ where f' (h, c) = (`Map.singleton` c) <$> f h c checkInjectivity :: QName -> [Clause] -> TCM FunctionInverse -checkInjectivity f cs - | pointless cs = do - reportSLn "tc.inj.check.pointless" 20 $ +checkInjectivity f cs0 + | null $ filter properlyMatchingClause cs = do + reportSLn "tc.inj.check.pointless" 35 $ "Injectivity of " ++ prettyShow (A.qnameToConcrete f) ++ " would be pointless." return NotInjective + | otherwise = checkInjectivity' f cs where - -- Is it pointless to use injectivity for this function? - pointless [] = True - pointless (_:_:_) = False - pointless [cl] = not $ any (properlyMatching . namedArg) $ namedClausePats cl - -- Andreas, 2014-06-12 - -- If we only have record patterns, it is also pointless. - -- We need at least one proper match. -checkInjectivity f cs = fromMaybe NotInjective <.> runMaybeT $ do + -- We can filter out absurd clauses. + cs = filter (isJust . clauseBody) cs0 + -- We cannot filter out clauses that have no proper match, because + -- these could be catch-all clauses. + -- However, we need at least one proper match to get injectivity started. + properlyMatchingClause = + any (properlyMatching' False False . namedArg) . namedClausePats + +-- | Precondition: all the given clauses are non-absurd and contain a proper match. +checkInjectivity' :: QName -> [Clause] -> TCM FunctionInverse +checkInjectivity' f cs = fromMaybe NotInjective <.> runMaybeT $ do reportSLn "tc.inj.check" 40 $ "Checking injectivity of " ++ prettyShow f let varToArg :: Clause -> TermHead -> MaybeT TCM TermHead @@ -148,8 +189,12 @@ varToArg _ h = return h -- We don't need to consider absurd clauses - let computeHead c@Clause{ clauseBody = Just body } = do - h <- varToArg c =<< lift (fromMaybe UnknownHead <$> addContext (clauseTel c) (headSymbol body)) + let computeHead c@Clause{ clauseBody = Just body , clauseType = Just tbody } = do + h <- ifM (isIrrelevantOrPropM tbody) (return UnknownHead) $ + varToArg c =<< do + lift $ fromMaybe UnknownHead <$> do + addContext (clauseTel c) $ + headSymbol body return [Map.singleton h [c]] computeHead _ = return [] @@ -172,10 +217,12 @@ -- | If a clause is over-applied we can't trust the head (Issue 2944). For -- instance, the clause might be `f ps = u , v` and the actual call `f vs -- .fst`. In this case the head will be the head of `u` rather than `_,_`. -checkOverapplication :: Elims -> InversionMap Clause -> TCM (InversionMap Clause) +checkOverapplication + :: forall m. (HasConstInfo m) + => Elims -> InversionMap Clause -> m (InversionMap Clause) checkOverapplication es = updateHeads overapplied where - overapplied :: TermHead -> [Clause] -> TCM TermHead + overapplied :: TermHead -> [Clause] -> m TermHead overapplied h cs | all (not . isOverapplied) cs = return h overapplied h cs = ifM (isSuperRigid h) (return h) (return UnknownHead) @@ -206,17 +253,21 @@ -- proper heads. These might still be `VarHead`, but in that case they refer to -- deBruijn variables. Checks that the instantiated heads are still rigid and -- distinct. -instantiateVarHeads :: QName -> Elims -> InversionMap c -> TCM (Maybe (InversionMap c)) +instantiateVarHeads + :: forall m c. (MonadReduce m, MonadError TCErr m, MonadDebug m, HasBuiltins m) + => QName -> Elims -> InversionMap c -> m (Maybe (InversionMap c)) instantiateVarHeads f es m = runMaybeT $ updateHeads (const . instHead) m where - instHead :: TermHead -> MaybeT TCM TermHead + instHead :: TermHead -> MaybeT m TermHead instHead h@(VarHead i) | Just (Apply arg) <- es !!! i = MaybeT $ headSymbol' (unArg arg) | otherwise = empty -- impossible? instHead h = return h -- | Argument should be in weak head normal form. -functionInverse :: Term -> TCM InvView +functionInverse + :: (MonadReduce m, MonadError TCErr m, HasBuiltins m, HasConstInfo m) + => Term -> m InvView functionInverse v = case v of Def f es -> do inv <- defInverse <$> getConstInfo f @@ -231,11 +282,9 @@ data InvView = Inv QName [Elim] (InversionMap Clause) | NoInv -data MaybeAbort = Abort | KeepGoing - -- | Precondition: The first argument must be blocked and the second must be -- neutral. -useInjectivity :: CompareDirection -> Type -> Term -> Term -> TCM () +useInjectivity :: MonadConversion m => CompareDirection -> CompareAs -> Term -> Term -> m () useInjectivity dir ty blk neu = locallyTC eInjectivityDepth succ $ do inv <- functionInverse blk -- Injectivity might cause non-termination for unsatisfiable constraints @@ -252,7 +301,7 @@ | otherwise -> do reportSDoc "tc.inj.use" 30 $ fsep $ pwords "useInjectivity on" ++ - [ prettyTCM blk, prettyTCM cmp, prettyTCM neu, ":", prettyTCM ty ] + [ prettyTCM blk, prettyTCM cmp, prettyTCM neu, prettyTCM ty] let canReduceToSelf = Map.member (ConsHead f) hdMap || Map.member UnknownHead hdMap allUnique = all isUnique hdMap isUnique [_] = True @@ -295,7 +344,7 @@ where err = typeError $ app (\ u v -> UnequalTerms cmp u v ty) blk neu where fallback = addConstraint $ app (ValueCmp cmp ty) blk neu - success blk' = app (compareTerm cmp ty) blk' neu + success blk' = app (compareAs cmp ty) blk' neu (cmp, app) = case dir of DirEq -> (CmpEq, id) @@ -304,7 +353,9 @@ -- | The second argument should be a blocked application and the third argument -- the inverse of the applied function. -invertFunction :: Comparison -> Term -> InvView -> TermHead -> TCM () -> TCM () -> (Term -> TCM ()) -> TCM () +invertFunction + :: MonadConversion m + => Comparison -> Term -> InvView -> TermHead -> m () -> m () -> (Term -> m ()) -> m () invertFunction _ _ NoInv _ fallback _ _ = fallback invertFunction cmp blk (Inv f blkArgs hdMap) hd fallback err success = do fTy <- defType <$> getConstInfo f @@ -316,7 +367,7 @@ case fromMaybe [] $ Map.lookup hd hdMap <> Map.lookup UnknownHead hdMap of [] -> err _:_:_ -> fallback - [cl@Clause{ clauseTel = tel }] -> maybeAbort $ do + [cl@Clause{ clauseTel = tel }] -> speculateMetas fallback $ do let ps = clausePats cl perm = fromMaybe __IMPOSSIBLE__ $ clausePerm cl -- These are what dot patterns should be instantiated at @@ -350,45 +401,49 @@ compareElims pol fs fTy (Def f []) margs blkArgs' -- Check that we made progress. - r <- runReduceM $ unfoldDefinitionStep False blk f blkArgs + r <- liftReduce $ unfoldDefinitionStep False (Def f []) f blkArgs case r of YesReduction _ blk' -> do reportSDoc "tc.inj.invert.success" 20 $ hsep ["Successful inversion of", prettyTCM f, "at", pretty hd] - KeepGoing <$ success blk' + KeepMetas <$ success blk' NoReduction{} -> do reportSDoc "tc.inj.invert" 30 $ vcat [ "aborting inversion;" <+> prettyTCM blk , "does not reduce" ] - return Abort + return RollBackMetas where - maybeAbort m = do - (a, s) <- localTCStateSaving m - case a of - KeepGoing -> putTC s - Abort -> fallback - + nextMeta :: (MonadState [Term] m, MonadFail m) => m Term nextMeta = do m : ms <- get put ms return m - dotP :: Monad m => Term -> StateT [Term] (ReaderT Substitution m) Term + dotP :: MonadReader Substitution m => Term -> m Term dotP v = do sub <- ask return $ applySubst sub v - metaElim (Arg _ (ProjP o p)) = lift $ lift $ Proj o <$> getOriginalProjection p + metaElim + :: (MonadState [Term] m, MonadReader Substitution m, HasConstInfo m, MonadFail m) + => Arg DeBruijnPattern -> m Elim + metaElim (Arg _ (ProjP o p)) = Proj o <$> getOriginalProjection p metaElim (Arg info p) = Apply . Arg info <$> metaPat p + metaArgs + :: (MonadState [Term] m, MonadReader Substitution m, MonadFail m) + => [NamedArg DeBruijnPattern] -> m Args metaArgs args = mapM (traverse $ metaPat . namedThing) args + metaPat + :: (MonadState [Term] m, MonadReader Substitution m, MonadFail m) + => DeBruijnPattern -> m Term metaPat (DotP _ v) = dotP v metaPat (VarP _ _) = nextMeta metaPat (IApplyP{}) = nextMeta metaPat (ConP c mt args) = Con c (fromConPatternInfo mt) . map Apply <$> metaArgs args metaPat (DefP o q args) = Def q . map Apply <$> metaArgs args - metaPat (LitP l) = return $ Lit l + metaPat (LitP _ l) = return $ Lit l metaPat ProjP{} = __IMPOSSIBLE__ forcePiUsingInjectivity :: Type -> TCM Type diff --git a/src/full/Agda/TypeChecking/Inlining.hs b/src/full/Agda/TypeChecking/Inlining.hs --- a/src/full/Agda/TypeChecking/Inlining.hs +++ b/src/full/Agda/TypeChecking/Inlining.hs @@ -4,7 +4,6 @@ import qualified Data.IntMap as IntMap import Agda.Interaction.Options -import Agda.Syntax.Internal import Agda.TypeChecking.Monad.Base import Agda.TypeChecking.CompiledClause import Agda.TypeChecking.Free diff --git a/src/full/Agda/TypeChecking/InstanceArguments.hs b/src/full/Agda/TypeChecking/InstanceArguments.hs --- a/src/full/Agda/TypeChecking/InstanceArguments.hs +++ b/src/full/Agda/TypeChecking/InstanceArguments.hs @@ -1,20 +1,13 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE NondecreasingIndentation #-} module Agda.TypeChecking.InstanceArguments ( findInstance , isInstanceConstraint - , isConsideringInstance + , shouldPostponeInstanceSearch , postponeInstanceConstraints ) where -#if MIN_VERSION_base(4,11,0) -import Prelude hiding ((<>)) -#endif - -import Control.Applicative hiding (empty) import Control.Monad.Reader -import Control.Monad.State import qualified Data.IntSet as IntSet import qualified Data.Map as Map import qualified Data.Set as Set @@ -27,9 +20,10 @@ import Agda.Syntax.Common import Agda.Syntax.Position import Agda.Syntax.Internal as I +import Agda.Syntax.Internal.MetaVars import Agda.Syntax.Scope.Base (isNameInScope) -import Agda.TypeChecking.Errors () +import Agda.TypeChecking.Errors () --instance only import Agda.TypeChecking.Implicit (implicitArgs) import Agda.TypeChecking.Monad import Agda.TypeChecking.Monad.Builtin @@ -38,10 +32,8 @@ import Agda.TypeChecking.Records import Agda.TypeChecking.Substitute import Agda.TypeChecking.Telescope -import Agda.TypeChecking.Free import {-# SOURCE #-} Agda.TypeChecking.Constraints -import {-# SOURCE #-} Agda.TypeChecking.MetaVars import {-# SOURCE #-} Agda.TypeChecking.Conversion import qualified Agda.Benchmarking as Benchmark @@ -52,11 +44,9 @@ import Agda.Utils.Lens import Agda.Utils.Maybe import Agda.Utils.Monad -import Agda.Utils.Functor import Agda.Utils.Pretty (prettyShow) import Agda.Utils.Null (empty) -#include "undefined.h" import Agda.Utils.Impossible -- | Compute a list of instance candidates. @@ -92,8 +82,7 @@ vars = [ Candidate x t (isOverlappable info) | (x, Dom{domInfo = info, unDom = (_, t)}) <- varsAndRaisedTypes , isInstance info - , usableRelevance info - , usableQuantity info + , usableModality info ] -- {{}}-fields of variables are also candidates @@ -115,12 +104,11 @@ let lets = [ Candidate v t False | (v, Dom{domInfo = info, unDom = t}) <- env , isInstance info - , usableRelevance info - , usableQuantity info + , usableModality info ] return $ vars ++ fields ++ lets - etaExpand :: (MonadTCM m, MonadReduce m, HasConstInfo m) + etaExpand :: (MonadTCM m, MonadReduce m, HasConstInfo m, HasBuiltins m) => Bool -> Type -> m (Maybe (QName, Args)) etaExpand etaOnce t = isEtaRecordType t >>= \case @@ -141,9 +129,9 @@ instanceFields' :: Bool -> (Term,Type) -> ExceptT Blocked_ TCM [Candidate] instanceFields' etaOnce (v, t) = - ifBlockedType t (\m _ -> throwError $ Blocked m ()) $ \ _ t -> do + ifBlocked t (\m _ -> throwError $ Blocked m ()) $ \ _ t -> do caseMaybeM (etaExpand etaOnce t) (return []) $ \ (r, pars) -> do - (tel, args) <- forceEtaExpandRecord r pars v + (tel, args) <- lift $ forceEtaExpandRecord r pars v let types = map unDom $ applySubst (parallelS $ reverse $ map unArg args) (flattenTel tel) fmap concat $ forM (zip args types) $ \ (arg, t) -> ([ Candidate (unArg arg) t (isOverlappable arg) @@ -153,7 +141,7 @@ getScopeDefs :: QName -> TCM [Candidate] getScopeDefs n = do instanceDefs <- getInstanceDefs - rel <- asksTC envRelevance + rel <- asksTC getRelevance let qs = maybe [] Set.toList $ Map.lookup n instanceDefs catMaybes <$> mapM (candidate rel) qs @@ -165,15 +153,16 @@ -- in this case, we just ignore q (issue 674) flip catchError handle $ do def <- getConstInfo q - if not (defRelevance def `moreRelevant` rel) then return Nothing else do + if not (getRelevance def `moreRelevant` rel) then return Nothing else do -- Andreas, 2017-01-14: instantiateDef is a bit of an overkill -- if we anyway get the freeVarsToApply -- WAS: t <- defType <$> instantiateDef def args <- freeVarsToApply q let t = defType def `piApply` args + rel = getRelevance $ defArgInfo def let v = case theDef def of -- drop parameters if it's a projection function... - Function{ funProjection = Just p } -> projDropParsApply p ProjSystem args + Function{ funProjection = Just p } -> projDropParsApply p ProjSystem rel args -- Andreas, 2014-08-19: constructors cannot be declared as -- instances (at least as of now). -- I do not understand why the Constructor case is not impossible. @@ -224,7 +213,7 @@ findInstance' m cands = ifM (isFrozen m) (do reportSLn "tc.instance" 20 "Refusing to solve frozen instance meta." return (Just (cands, Nothing))) $ do - ifM isConsideringInstance (do + ifM shouldPostponeInstanceSearch (do reportSLn "tc.instance" 20 "Postponing possibly recursive instance search." return $ Just (cands, Nothing)) $ billTo [Benchmark.Typing, Benchmark.InstanceSearch] $ do -- Andreas, 2015-02-07: New metas should be created with range of the @@ -300,7 +289,7 @@ Level{} -> __IMPOSSIBLE__ MetaV{} -> __IMPOSSIBLE__ DontCare{} -> __IMPOSSIBLE__ - Dummy s -> __IMPOSSIBLE_VERBOSE__ s + Dummy s _ -> __IMPOSSIBLE_VERBOSE__ s -- | Apply the computation to every argument in turn by reseting the state every -- time. Return the list of the arguments giving the result True. @@ -462,7 +451,7 @@ -- Jesper, 05-12-2014: When we abort, we should add a constraint to -- instantiate the meta at a later time (see issue 1377). ctxElims <- map Apply <$> getContextArgs - guardConstraint (ValueCmp CmpEq t'' (MetaV m ctxElims) v) $ leqType t'' t + guardConstraint (ValueCmp CmpEq (AsTermsOf t'') (MetaV m ctxElims) v) $ leqType t'' t -- make a pass over constraints, to detect cases where some are made -- unsolvable by the assignment, but don't do this for FindInstance's -- to prevent loops. @@ -473,11 +462,11 @@ case sol of MetaV m' _ | m == m' -> reportSDoc "tc.instance" 15 $ - sep [ "instance search: maybe solution for" <+> prettyTCM m <> ":" + sep [ ("instance search: maybe solution for" <+> prettyTCM m) <> ":" , nest 2 $ prettyTCM v ] _ -> reportSDoc "tc.instance" 15 $ - sep [ "instance search: found solution for" <+> prettyTCM m <> ":" + sep [ ("instance search: found solution for" <+> prettyTCM m) <> ":" , nest 2 $ prettyTCM sol ] do solveAwakeConstraints' True @@ -521,17 +510,18 @@ isInstanceConstraint FindInstance{} = True isInstanceConstraint _ = False -isConsideringInstance :: (ReadTCState m, HasOptions m) => m Bool -isConsideringInstance = +shouldPostponeInstanceSearch :: (ReadTCState m, HasOptions m) => m Bool +shouldPostponeInstanceSearch = and2M ((^. stConsideringInstance) <$> getTCState) (not . optOverlappingInstances <$> pragmaOptions) + `or2M` ((^. stPostponeInstanceSearch) <$> getTCState) -nowConsideringInstance :: (MonadTCState m) => m a -> m a +nowConsideringInstance :: (ReadTCState m) => m a -> m a nowConsideringInstance = locallyTCState stConsideringInstance $ const True wakeupInstanceConstraints :: TCM () wakeupInstanceConstraints = - unlessM isConsideringInstance $ do + unlessM shouldPostponeInstanceSearch $ do wakeConstraints (return . isInstance) solveSomeAwakeConstraints isInstance False where @@ -539,7 +529,7 @@ postponeInstanceConstraints :: TCM a -> TCM a postponeInstanceConstraints m = - nowConsideringInstance m <* wakeupInstanceConstraints + locallyTCState stPostponeInstanceSearch (const True) m <* wakeupInstanceConstraints -- | To preserve the invariant that a constructor is not applied to its -- parameter arguments, we explicitly check whether function term diff --git a/src/full/Agda/TypeChecking/Irrelevance.hs b/src/full/Agda/TypeChecking/Irrelevance.hs --- a/src/full/Agda/TypeChecking/Irrelevance.hs +++ b/src/full/Agda/TypeChecking/Irrelevance.hs @@ -1,5 +1,5 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE UndecidableInstances #-} +{-# LANGUAGE NondecreasingIndentation #-} {-| Compile-time irrelevance. @@ -74,8 +74,7 @@ module Agda.TypeChecking.Irrelevance where -import Control.Arrow (first, second) -import Control.Monad.Reader +import Control.Arrow (second) import qualified Data.Map as Map @@ -93,9 +92,6 @@ import Agda.Utils.Lens import Agda.Utils.Monad -#include "undefined.h" -import Agda.Utils.Impossible - -- | data 'Relevance' -- see "Agda.Syntax.Common". @@ -110,17 +106,19 @@ -- | Modify the context whenever going from the l.h.s. (term side) -- of the typing judgement to the r.h.s. (type side). -workOnTypes :: TCM a -> TCM a +workOnTypes :: (MonadTCEnv m, HasOptions m, MonadDebug m) + => m a -> m a workOnTypes cont = do allowed <- optExperimentalIrrelevance <$> pragmaOptions - verboseBracket "tc.irr" 20 "workOnTypes" $ workOnTypes' allowed cont + verboseBracket "tc.irr" 60 "workOnTypes" $ workOnTypes' allowed cont -- | Internal workhorse, expects value of --experimental-irrelevance flag -- as argument. -workOnTypes' :: Bool -> TCM a -> TCM a +workOnTypes' :: (MonadTCEnv m) => Bool -> m a -> m a workOnTypes' experimental - = modifyContext (map $ mapRelevance f) - . applyQuantityToContext Quantity0 + = modifyContextInfo (mapRelevance f) + . applyQuantityToContext zeroQuantity + . typeLevelReductions . localTC (\ e -> e { envWorkingOnTypes = True }) where f | experimental = irrToNonStrict @@ -177,7 +175,7 @@ applyQuantityToContext :: (MonadTCEnv tcm, LensQuantity q) => q -> tcm a -> tcm a applyQuantityToContext thing = case getQuantity thing of - Quantity1 -> id + Quantity1{} -> id q -> applyQuantityToContextOnly q . applyQuantityToJudgementOnly q @@ -199,6 +197,25 @@ applyQuantityToJudgementOnly :: (MonadTCEnv tcm) => Quantity -> tcm a -> tcm a applyQuantityToJudgementOnly = localTC . over eQuantity . composeQuantity +-- | Apply inverse composition with the given cohesion to the typing context. +applyCohesionToContext :: (MonadTCEnv tcm, LensCohesion m) => m -> tcm a -> tcm a +applyCohesionToContext thing = + case getCohesion thing of + m | m == mempty -> id + | otherwise -> applyCohesionToContextOnly m + -- Cohesion does not apply to the judgment. + +applyCohesionToContextOnly :: (MonadTCEnv tcm) => Cohesion -> tcm a -> tcm a +applyCohesionToContextOnly q = localTC + $ over eContext (map $ inverseApplyCohesion q) + . over eLetBindings (Map.map . fmap . second $ inverseApplyCohesion q) + +-- | Can we split on arguments of the given cohesion? +splittableCohesion :: (HasOptions m, LensCohesion a) => a -> m Bool +splittableCohesion a = do + let c = getCohesion a + pure (usableCohesion c) `and2M` (pure (c /= Flat) `or2M` do optFlatSplit <$> pragmaOptions) + -- | (Conditionally) wake up irrelevant variables and make them relevant. -- For instance, -- in an irrelevant function argument otherwise irrelevant variables @@ -230,16 +247,18 @@ applyModalityToJudgementOnly :: (MonadTCEnv tcm) => Modality -> tcm a -> tcm a applyModalityToJudgementOnly = localTC . over eModality . composeModality --- | Like 'applyModalityToContext', but only act on context if +-- | Like 'applyModalityToContext', but only act on context (for Relevance) if -- @--irrelevant-projections@. -- See issue #2170. applyModalityToContextFunBody :: (MonadTCM tcm, LensModality r) => r -> tcm a -> tcm a applyModalityToContextFunBody thing cont = do - let m = getModality thing - if m == mempty then cont else - applyWhenM (optIrrelevantProjections <$> pragmaOptions) - (applyRelevanceToContextOnly (getRelevance m)) $ -- enable local irr. defs only when option - applyModalityToJudgementOnly m cont -- enable global irr. defs alway + ifM (optIrrelevantProjections <$> pragmaOptions) + {-then-} (applyModalityToContext m cont) -- enable global irr. defs always + {-else-} (applyRelevanceToContextFunBody (getRelevance m) + $ applyCohesionToContext (getCohesion m) + $ applyQuantityToContext (getQuantity m) cont) -- enable local irr. defs only when option + where + m = getModality thing -- | Wake up irrelevant variables and make them relevant. This is used -- when type checking terms in a hole, in which case you want to be able to @@ -252,7 +271,7 @@ wakeIrrelevantVars :: (MonadTCEnv tcm) => tcm a -> tcm a wakeIrrelevantVars = applyRelevanceToContextOnly Irrelevant - . applyQuantityToContextOnly Quantity0 + . applyQuantityToContextOnly zeroQuantity -- | Check whether something can be used in a position of the given relevance. -- @@ -274,7 +293,7 @@ instance UsableRelevance Term where usableRel rel u = case u of Var i vs -> do - irel <- getRelevance <$> typeOfBV' i + irel <- getRelevance <$> domOfBV i let ok = irel `moreRelevant` rel reportSDoc "tc.irr" 50 $ "Variable" <+> prettyTCM (var i) <+> @@ -293,7 +312,7 @@ MetaV m vs -> do mrel <- getMetaRelevance <$> lookupMeta m return (mrel `moreRelevant` rel) `and2M` usableRel rel vs - DontCare _ -> return $ isIrrelevant rel + DontCare v -> usableRel rel v -- TODO: allow irrelevant things to be used in DontCare position? Dummy{} -> return True instance UsableRelevance a => UsableRelevance (Type' a) where @@ -305,18 +324,18 @@ Prop l -> usableRel rel l Inf -> return True SizeUniv -> return True - PiSort s1 s2 -> usableRel rel (s1,s2) + PiSort a s -> usableRel rel (a,s) + FunSort s1 s2 -> usableRel rel (s1,s2) UnivSort s -> usableRel rel s MetaS x es -> usableRel rel es DefS d es -> usableRel rel $ Def d es DummyS{} -> return True instance UsableRelevance Level where - usableRel rel (Max ls) = usableRel rel ls + usableRel rel (Max _ ls) = usableRel rel ls instance UsableRelevance PlusLevel where - usableRel rel ClosedLevel{} = return True - usableRel rel (Plus _ l) = usableRel rel l + usableRel rel (Plus _ l) = usableRel rel l instance UsableRelevance LevelAtom where usableRel rel l = case l of @@ -370,7 +389,7 @@ instance UsableModality Term where usableMod mod u = case u of Var i vs -> do - imod <- getModality <$> typeOfBV' i + imod <- getModality <$> domOfBV i let ok = imod `moreUsableModality` mod reportSDoc "tc.irr" 50 $ "Variable" <+> prettyTCM (var i) <+> @@ -399,7 +418,7 @@ text ("has modality " ++ show mmod ++ ", which is a " ++ (if ok then "" else "NOT ") ++ "more usable modality than " ++ show mod) return ok `and2M` usableMod mod vs - DontCare _ -> return $ isIrrelevant mod + DontCare v -> usableMod mod v Dummy{} -> return True instance UsableRelevance a => UsableModality (Type' a) where @@ -412,13 +431,13 @@ -- Prop l -> usableMod mod l -- Inf -> return True -- SizeUniv -> return True - -- PiSort s1 s2 -> usableMod mod (s1,s2) + -- PiSort a s -> usableMod mod (a,s) -- UnivSort s -> usableMod mod s -- MetaS x es -> usableMod mod es -- DummyS{} -> return True instance UsableModality Level where - usableMod mod (Max ls) = usableRel (getRelevance mod) ls + usableMod mod (Max _ ls) = usableRel (getRelevance mod) ls -- instance UsableModality PlusLevel where -- usableMod mod ClosedLevel{} = return True @@ -462,10 +481,12 @@ -- | Is a type a proposition? (Needs reduction.) -isPropM :: (LensSort a, MonadReduce m) => a -> m Bool -isPropM a = reduce (getSort a) <&> \case - Prop{} -> True - _ -> False +isPropM :: (LensSort a, PrettyTCM a, MonadReduce m, MonadDebug m) => a -> m Bool +isPropM a = do + traceSDoc "tc.prop" 80 ("Is " <+> prettyTCM a <+> "of sort" <+> prettyTCM (getSort a) <+> "in Prop?") $ do + reduce (getSort a) <&> \case + Prop{} -> True + _ -> False -isIrrelevantOrPropM :: (LensRelevance a, LensSort a, MonadReduce m) => a -> m Bool +isIrrelevantOrPropM :: (LensRelevance a, LensSort a, PrettyTCM a, MonadReduce m, MonadDebug m) => a -> m Bool isIrrelevantOrPropM x = return (isIrrelevant x) `or2M` isPropM x diff --git a/src/full/Agda/TypeChecking/Irrelevance.hs-boot b/src/full/Agda/TypeChecking/Irrelevance.hs-boot new file mode 100644 --- /dev/null +++ b/src/full/Agda/TypeChecking/Irrelevance.hs-boot @@ -0,0 +1,11 @@ + +module Agda.TypeChecking.Irrelevance where + +import Agda.Syntax.Internal (LensSort) + +import Agda.TypeChecking.Monad.Base (MonadTCEnv, HasOptions, MonadReduce) +import Agda.TypeChecking.Monad.Debug (MonadDebug) +import {-# SOURCE #-} Agda.TypeChecking.Pretty (PrettyTCM) + +workOnTypes :: (MonadTCEnv m, HasOptions m, MonadDebug m) => m a -> m a +isPropM :: (LensSort a, PrettyTCM a, MonadReduce m, MonadDebug m) => a -> m Bool diff --git a/src/full/Agda/TypeChecking/Level.hs b/src/full/Agda/TypeChecking/Level.hs --- a/src/full/Agda/TypeChecking/Level.hs +++ b/src/full/Agda/TypeChecking/Level.hs @@ -1,24 +1,25 @@ -{-# LANGUAGE CPP #-} module Agda.TypeChecking.Level where import Data.Maybe import qualified Data.List as List -import Data.Traversable (Traversable,traverse) +import Data.List.NonEmpty (NonEmpty(..)) +import qualified Data.List.NonEmpty as NonEmpty +import Data.Traversable (traverse) import Agda.Syntax.Common import Agda.Syntax.Internal + +import Agda.TypeChecking.Free.Lazy import Agda.TypeChecking.Monad import Agda.TypeChecking.Substitute import Agda.TypeChecking.Reduce -import Agda.TypeChecking.Reduce.Monad () import Agda.TypeChecking.Monad.Builtin -import Agda.Utils.Except ( MonadError(catchError) ) import Agda.Utils.Maybe ( caseMaybeM, allJustM ) import Agda.Utils.Monad ( tryMaybe ) +import Agda.Utils.Singleton -#include "undefined.h" import Agda.Utils.Impossible data LevelKit = LevelKit @@ -33,9 +34,16 @@ } -- | Get the 'primLevel' as a 'Type'. -levelType :: TCM Type -levelType = El (mkType 0) <$> primLevel +levelType :: (HasBuiltins m) => m Type +levelType = El (mkType 0) . fromMaybe __IMPOSSIBLE__ <$> getBuiltin' builtinLevel +isLevelType :: (HasBuiltins m, MonadReduce m) => Type -> m Bool +isLevelType a = reduce (unEl a) >>= \case + Def f [] -> do + Def lvl [] <- fromMaybe __IMPOSSIBLE__ <$> getBuiltin' builtinLevel + return $ f == lvl + _ -> return False + levelSucFunction :: TCM (Term -> Term) levelSucFunction = apply1 <$> primLevelSuc @@ -59,11 +67,11 @@ } -- | Raises an error if no level kit is available. -requireLevels :: TCM LevelKit +requireLevels :: HasBuiltins m => m LevelKit requireLevels = builtinLevelKit -- | Checks whether level kit is fully available. -haveLevels :: TCM Bool +haveLevels :: HasBuiltins m => m Bool haveLevels = caseMaybeM (allJustM $ map getBuiltin' levelBuiltins) (return False) (\ _bs -> return True) @@ -88,23 +96,22 @@ suc <- fromMaybe __IMPOSSIBLE__ <$> getBuiltin' builtinLevelSuc zer <- fromMaybe __IMPOSSIBLE__ <$> getBuiltin' builtinLevelZero case nv of - Max [] -> return zer - Max [Plus 0 a] -> return $ unLevelAtom a - Max [a] -> do - return $ unPlusV zer (apply1 suc) a - _ -> (`unlevelWithKit` nv) <$> builtinLevelKit + Max n [] -> return $ unConstV zer (apply1 suc) n + Max 0 [a] -> return $ unPlusV (apply1 suc) a + _ -> (`unlevelWithKit` nv) <$> builtinLevelKit unlevelWithKit :: LevelKit -> Level -> Term -unlevelWithKit LevelKit{ lvlZero = zer, lvlSuc = suc, lvlMax = max } (Max as) = - case map (unPlusV zer suc) as of - [a] -> a - [] -> zer - as -> foldl1 max as +unlevelWithKit LevelKit{ lvlZero = zer, lvlSuc = suc, lvlMax = max } = \case + Max m [] -> unConstV zer suc m + Max 0 [a] -> unPlusV suc a + Max m as -> foldl1 max $ [ unConstV zer suc m | m > 0 ] ++ map (unPlusV suc) as -unPlusV :: Term -> (Term -> Term) -> PlusLevel -> Term -unPlusV zer suc (ClosedLevel n) = foldr (.) id (List.genericReplicate n suc) zer -unPlusV _ suc (Plus n a) = foldr (.) id (List.genericReplicate n suc) (unLevelAtom a) +unConstV :: Term -> (Term -> Term) -> Integer -> Term +unConstV zer suc n = foldr (.) id (List.genericReplicate n suc) zer +unPlusV :: (Term -> Term) -> PlusLevel -> Term +unPlusV suc (Plus n a) = foldr (.) id (List.genericReplicate n suc) (unLevelAtom a) + maybePrimCon :: TCM Term -> TCM (Maybe ConHead) maybePrimCon prim = tryMaybe $ do Con c ci [] <- prim @@ -130,43 +137,116 @@ Def lsuc [] <- fromMaybe __IMPOSSIBLE__ <$> getBuiltin' builtinLevelSuc Def lmax [] <- fromMaybe __IMPOSSIBLE__ <$> getBuiltin' builtinLevelMax let view a = do - a <- reduce a - case a of + ba <- reduceB a + case ignoreBlocking ba of Level l -> return l Def s [Apply arg] - | s == lsuc -> inc <$> view (unArg arg) + | s == lsuc -> levelSuc <$> view (unArg arg) Def z [] - | z == lzero -> return $ closed 0 + | z == lzero -> return $ ClosedLevel 0 Def m [Apply arg1, Apply arg2] | m == lmax -> levelLub <$> view (unArg arg1) <*> view (unArg arg2) - _ -> mkAtom a - v <- view a - return v + _ -> return $ mkAtom ba + view a where - mkAtom a = do - b <- reduceB a - return $ case b of - NotBlocked _ (MetaV m as) -> atom $ MetaLevel m as - NotBlocked r _ -> atom $ NeutralLevel r $ ignoreBlocking b - Blocked m _ -> atom $ BlockedLevel m $ ignoreBlocking b + mkAtom ba = atomicLevel $ case ba of + NotBlocked _ (MetaV m as) -> MetaLevel m as + NotBlocked r _ -> case r of + StuckOn{} -> NeutralLevel r $ ignoreBlocking ba + Underapplied{} -> NeutralLevel r $ ignoreBlocking ba + AbsurdMatch{} -> NeutralLevel r $ ignoreBlocking ba + MissingClauses{} -> UnreducedLevel $ ignoreBlocking ba + ReallyNotBlocked{} -> NeutralLevel r $ ignoreBlocking ba + Blocked m _ -> BlockedLevel m $ ignoreBlocking ba - atom a = Max [Plus 0 a] +-- | Given a level @l@, find the maximum constant @n@ such that @l = n + l'@ +levelPlusView :: Level -> (Integer, Level) +levelPlusView (Max 0 []) = (0 , Max 0 []) +levelPlusView (Max 0 as@(_:_)) = (minN , Max 0 (map sub as)) + where + minN = minimum [ n | Plus n _ <- as ] + sub (Plus n a) = Plus (n - minN) a +levelPlusView (Max n as) = (minN , Max (n - minN) (map sub as)) + where + minN = minimum $ n : [ n' | Plus n' _ <- as ] + sub (Plus n' a) = Plus (n' - minN) a - closed n = Max [ClosedLevel n | n > 0] +-- | Given a level @l@, find the biggest constant @n@ such that @n <= l@ +levelLowerBound :: Level -> Integer +levelLowerBound (Max m as) = maximum $ m : [n | Plus n _ <- as] - inc (Max as) = Max $ map inc' as - where - inc' (ClosedLevel n) = ClosedLevel $ n + 1 - inc' (Plus n a) = Plus (n + 1) a +-- | Given a constant @n@ and a level @l@, find the level @l'@ such +-- that @l = n + l'@ (or Nothing if there is no such level). +-- Operates on levels in canonical form. +subLevel :: Integer -> Level -> Maybe Level +subLevel n (Max m ls) = Max <$> m' <*> traverse subPlus ls + where + m' :: Maybe Integer + m' | m == 0, not (null ls) = Just 0 + | otherwise = sub m -levelLub :: Level -> Level -> Level -levelLub (Max as) (Max bs) = levelMax $ as ++ bs + -- General purpose function. + nonNeg :: Integer -> Maybe Integer + nonNeg j | j >= 0 = Just j + | otherwise = Nothing -subLevel :: Integer -> Level -> Maybe Level -subLevel n (Max ls) = Max <$> traverse sub ls + sub :: Integer -> Maybe Integer + sub = nonNeg . subtract n + + subPlus :: PlusLevel -> Maybe PlusLevel + subPlus (Plus j l) = Plus <$> sub j <*> Just l + +-- | Given two levels @a@ and @b@, try to decompose the first one as +-- @a = a' ⊔ b@ (for the minimal value of @a'@). +levelMaxDiff :: Level -> Level -> Maybe Level +levelMaxDiff (Max m as) (Max n bs) = Max <$> diffC m n <*> diffP as bs where - sub :: PlusLevel -> Maybe PlusLevel - sub (ClosedLevel j) | j >= n = Just $ ClosedLevel $ j - n - | otherwise = Nothing - sub (Plus j l) | j >= n = Just $ Plus (j - n) l - | otherwise = Nothing + diffC :: Integer -> Integer -> Maybe Integer + diffC m n + | m == n = Just 0 + | m > n = Just m + | otherwise = Nothing + + diffP :: [PlusLevel] -> [PlusLevel] -> Maybe [PlusLevel] + diffP as [] = Just as + diffP [] bs = Nothing + diffP (a@(Plus m x) : as) (b@(Plus n y) : bs) + | x == y = if + | m == n -> diffP as bs + | m > n -> (Plus m x:) <$> diffP as bs + | otherwise -> Nothing + | otherwise = (a:) <$> diffP as (b:bs) + +-- | A @SingleLevel@ is a @Level@ that cannot be further decomposed as +-- a maximum @a ⊔ b@. +data SingleLevel = SingleClosed Integer | SinglePlus PlusLevel + deriving (Eq, Show) + +unSingleLevel :: SingleLevel -> Level +unSingleLevel (SingleClosed m) = Max m [] +unSingleLevel (SinglePlus a) = Max 0 [a] + +-- | Return the maximum of the given @SingleLevel@s +unSingleLevels :: [SingleLevel] -> Level +unSingleLevels ls = levelMax n as + where + n = maximum $ 0 : [m | SingleClosed m <- ls] + as = [a | SinglePlus a <- ls] + +levelMaxView :: Level -> NonEmpty SingleLevel +levelMaxView (Max n []) = singleton $ SingleClosed n +levelMaxView (Max 0 (a:as)) = SinglePlus a :| map SinglePlus as +levelMaxView (Max n as) = SingleClosed n :| map SinglePlus as + +singleLevelView :: Level -> Maybe SingleLevel +singleLevelView l = case levelMaxView l of + s :| [] -> Just s + _ -> Nothing + +instance Subst Term SingleLevel where + applySubst sub (SingleClosed m) = SingleClosed m + applySubst sub (SinglePlus a) = SinglePlus $ applySubst sub a + +instance Free SingleLevel where + freeVars' (SingleClosed m) = mempty + freeVars' (SinglePlus a) = freeVars' a diff --git a/src/full/Agda/TypeChecking/Level.hs-boot b/src/full/Agda/TypeChecking/Level.hs-boot --- a/src/full/Agda/TypeChecking/Level.hs-boot +++ b/src/full/Agda/TypeChecking/Level.hs-boot @@ -1,7 +1,7 @@ module Agda.TypeChecking.Level where -import Agda.TypeChecking.Monad +import Agda.TypeChecking.Monad.Builtin (HasBuiltins) import Agda.Syntax.Internal -levelView :: Term -> TCM Level +reallyUnLevelView :: (HasBuiltins m) => Level -> m Term diff --git a/src/full/Agda/TypeChecking/Level/Solve.hs b/src/full/Agda/TypeChecking/Level/Solve.hs new file mode 100644 --- /dev/null +++ b/src/full/Agda/TypeChecking/Level/Solve.hs @@ -0,0 +1,71 @@ +{-# LANGUAGE ScopedTypeVariables #-} + +module Agda.TypeChecking.Level.Solve where + +import Control.Monad + +import qualified Data.IntSet as IntSet +import Data.IntSet (IntSet) +import Data.Maybe + +import Agda.Interaction.Options + +import Agda.Syntax.Common +import Agda.Syntax.Internal +import Agda.Syntax.Internal.MetaVars + +import Agda.TypeChecking.Level +import Agda.TypeChecking.MetaVars.Mention +import Agda.TypeChecking.Monad +import Agda.TypeChecking.Substitute +import Agda.TypeChecking.Telescope + +import Agda.Utils.Except +import Agda.Utils.Monad + +-- | Run the given action. At the end take all new metavariables of +-- type level for which the only constraints are upper bounds on the +-- level, and instantiate them to the lowest level. +defaultOpenLevelsToZero :: MonadMetaSolver m => m a -> m a +defaultOpenLevelsToZero f = ifNotM (optCumulativity <$> pragmaOptions) f $ do + (result , newMetas) <- metasCreatedBy f + defaultLevelsToZero newMetas + return result + +defaultLevelsToZero :: forall m. (MonadMetaSolver m) => IntSet -> m () +defaultLevelsToZero xs = loop =<< openLevelMetas (map MetaId $ IntSet.elems xs) + where + loop :: [MetaId] -> m () + loop xs = do + let isOpen x = isOpenMeta . mvInstantiation <$> lookupMeta x + xs <- filterM isOpen xs + allMetaTypes <- getOpenMetas >>= traverse metaType + let notInTypeOfMeta x = not $ mentionsMeta x allMetaTypes + progress <- forM xs $ \x -> do + cs <- filter (mentionsMeta x) <$> getAllConstraints + if | notInTypeOfMeta x , all (`isUpperBoundFor` x) cs -> do + m <- lookupMeta x + TelV tel t <- telView =<< metaType x + addContext tel $ assignV DirEq x (teleArgs tel) (Level $ ClosedLevel 0) (AsTermsOf t) + return True + `catchError` \_ -> return False + | otherwise -> return False + + if | or progress -> loop xs + | otherwise -> return () + + openLevelMetas :: [MetaId] -> m [MetaId] + openLevelMetas xs = return xs + >>= filterM (\m -> isNothing <$> isInteractionMeta m) + >>= filterM (\m -> (== NoGeneralize) <$> isGeneralizableMeta m) + >>= filterM isLevelMeta + + isLevelMeta :: MetaId -> m Bool + isLevelMeta x = do + TelV tel t <- telView =<< metaType x + addContext tel $ isLevelType t + + isUpperBoundFor :: ProblemConstraint -> MetaId -> Bool + isUpperBoundFor c x = case clValue (theConstraint c) of + LevelCmp CmpLeq l u -> not $ mentionsMeta x u + _ -> False diff --git a/src/full/Agda/TypeChecking/LevelConstraints.hs b/src/full/Agda/TypeChecking/LevelConstraints.hs --- a/src/full/Agda/TypeChecking/LevelConstraints.hs +++ b/src/full/Agda/TypeChecking/LevelConstraints.hs @@ -1,35 +1,46 @@ -{-# LANGUAGE CPP #-} module Agda.TypeChecking.LevelConstraints ( simplifyLevelConstraint ) where import qualified Data.List as List +import Data.List.NonEmpty (NonEmpty(..)) +import qualified Data.List.NonEmpty as NonEmpty import Data.Maybe import Agda.Syntax.Internal import Agda.TypeChecking.Monad.Base import Agda.TypeChecking.Substitute import Agda.TypeChecking.Free -import Agda.Utils.Impossible +import Agda.TypeChecking.Level -#include "undefined.h" +import Agda.Utils.Impossible +import Agda.Utils.List (nubOn) +import Agda.Utils.Update -- | @simplifyLevelConstraint c cs@ turns an @c@ into an equality -- constraint if it is an inequality constraint and the reverse -- inequality is contained in @cs@. -- --- The constraints doesn't necessarily have to live in the same context, but +-- The constraints don't necessarily have to live in the same context, but -- they do need to be universally quanitfied over the context. This function -- takes care of renaming variables when checking for matches. -simplifyLevelConstraint :: Constraint -> [Constraint] -> [Constraint] -simplifyLevelConstraint new old = - case inequalities new of - Just eqs -> map simpl eqs - Nothing -> [new] +simplifyLevelConstraint + :: Constraint -- ^ Constraint @c@ to simplify. + -> [Constraint] -- ^ Other constraints, enable simplification. + -> Maybe [Constraint] -- ^ @Just@: list of constraints equal to the original @c@. + -- @Nothing@: no simplification possible. +simplifyLevelConstraint c others = do + cs <- inequalities c + case runChange $ mapM simpl cs of + (cs', True) -> Just cs' + (_, False) -> Nothing + where - simpl (a :=< b) | any (matchLeq (b :=< a)) leqs = LevelCmp CmpEq (Max [a]) (Max [b]) - | otherwise = LevelCmp CmpLeq (Max [a]) (Max [b]) - leqs = concat $ mapMaybe inequalities old + simpl :: Leq -> Change (Constraint) + simpl (a :=< b) + | any (matchLeq (b :=< a)) leqs = dirty $ LevelCmp CmpEq (unSingleLevel a) (unSingleLevel b) + | otherwise = return $ LevelCmp CmpLeq (unSingleLevel a) (unSingleLevel b) + leqs = concat $ mapMaybe inequalities others -data Leq = PlusLevel :=< PlusLevel +data Leq = SingleLevel :=< SingleLevel deriving (Show, Eq) -- | Check if two inequality constraints are the same up to variable renaming. @@ -39,7 +50,7 @@ | otherwise = False where free :: Free a => a -> [Int] - free = List.nub . runFree (:[]) IgnoreNot -- Note: use a list to preserve order of variables + free = nubOn id . runFree (:[]) IgnoreNot -- Note: use a list to preserve order of variables xs = free (a, b) ys = free (c, d) rho = mkSub $ List.sort $ zip ys xs @@ -50,21 +61,29 @@ | y == y' = Var x [] :# go (y + 1) ren | otherwise = Strengthen __IMPOSSIBLE__ $ go (y + 1) ren0 --- | Turn a level constraint into a list of level inequalities, if possible. +-- | Turn a level constraint into a list of inequalities between +-- single levels, if possible. inequalities :: Constraint -> Maybe [Leq] -inequalities (LevelCmp CmpLeq (Max as) (Max [b])) = Just $ map (:=< b) as -- Andreas, 2016-09-28 +inequalities (LevelCmp CmpLeq a b) + | Just b' <- singleLevelView b = Just $ map (:=< b') $ NonEmpty.toList $ levelMaxView a + -- Andreas, 2016-09-28 -- Why was this most natural case missing? -- See test/Succeed/LevelLeqGeq.agda for where it is useful! -- These are very special cases only, in no way complete: -inequalities (LevelCmp CmpEq (Max as) (Max [b])) = - case break (== b) as of - (as0, _ : as1) -> Just [ a :=< b | a <- as0 ++ as1 ] +-- E.g.: a = a ⊔ b ⊔ c --> b ≤ a & c ≤ a + +inequalities (LevelCmp CmpEq a b) + | Just a' <- singleLevelView a = + case break (== a') (NonEmpty.toList $ levelMaxView b) of + (bs0, _ : bs1) -> Just [ b' :=< a' | b' <- bs0 ++ bs1 ] _ -> Nothing -inequalities (LevelCmp CmpEq (Max [b]) (Max as)) = - case break (== b) as of - (as0, _ : as1) -> Just [ a :=< b | a <- as0 ++ as1 ] + +inequalities (LevelCmp CmpEq a b) + | Just b' <- singleLevelView b = + case break (== b') (NonEmpty.toList $ levelMaxView a) of + (as0, _ : as1) -> Just [ a' :=< b' | a' <- as0 ++ as1 ] _ -> Nothing inequalities _ = Nothing diff --git a/src/full/Agda/TypeChecking/MetaVars.hs b/src/full/Agda/TypeChecking/MetaVars.hs --- a/src/full/Agda/TypeChecking/MetaVars.hs +++ b/src/full/Agda/TypeChecking/MetaVars.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE NondecreasingIndentation #-} {-# LANGUAGE GADTs #-} @@ -11,7 +10,7 @@ import Data.Function import qualified Data.IntMap as IntMap import qualified Data.List as List -import qualified Data.Map as Map +import qualified Data.Set as Set import qualified Data.Foldable as Fold import qualified Data.Traversable as Trav @@ -21,17 +20,20 @@ import Agda.Syntax.Common import Agda.Syntax.Internal import Agda.Syntax.Internal.Generic -import Agda.Syntax.Position (killRange) +import Agda.Syntax.Internal.MetaVars +import Agda.Syntax.Position (getRange, killRange) import Agda.TypeChecking.Monad import Agda.TypeChecking.Monad.Builtin import Agda.TypeChecking.Reduce import Agda.TypeChecking.Sort import Agda.TypeChecking.Substitute +import qualified Agda.TypeChecking.SyntacticEquality as SynEq import Agda.TypeChecking.Telescope import Agda.TypeChecking.Constraints import Agda.TypeChecking.Free -import Agda.TypeChecking.Level +import Agda.TypeChecking.Free.Lazy +import Agda.TypeChecking.Level (levelType) import Agda.TypeChecking.Records import Agda.TypeChecking.Pretty import Agda.TypeChecking.Irrelevance @@ -46,25 +48,41 @@ import Agda.Utils.Except ( ExceptT - , MonadError(throwError) + , MonadError(throwError, catchError) , runExceptT ) - import Agda.Utils.Function import Agda.Utils.Lens import Agda.Utils.List import Agda.Utils.Maybe import Agda.Utils.Monad -import Agda.Utils.Null import Agda.Utils.Size import Agda.Utils.Tuple import Agda.Utils.Permutation -import Agda.Utils.Pretty ( prettyShow, render ) -import qualified Agda.Utils.VarSet as Set +import Agda.Utils.Pretty ( prettyShow ) +import Agda.Utils.Singleton +import qualified Agda.Utils.Graph.TopSort as Graph +import Agda.Utils.VarSet (VarSet) +import qualified Agda.Utils.VarSet as VarSet +import Agda.Utils.WithDefault -#include "undefined.h" import Agda.Utils.Impossible +instance MonadMetaSolver TCM where + newMeta' = newMetaTCM' + assignV dir x args v t = assignWrapper dir x (map Apply args) v $ assign dir x args v t + assignTerm' = assignTermTCM' + etaExpandMeta = etaExpandMetaTCM + updateMetaVar = updateMetaVarTCM + + -- Right now we roll back the full state when aborting. + -- TODO: only roll back the metavariables + speculateMetas fallback m = do + (a, s) <- localTCStateSaving m + case a of + KeepMetas -> putTC s + RollBackMetas -> fallback + -- | Find position of a value in a list. -- Used to change metavar argument indices during assignment. -- @@ -105,20 +123,23 @@ -- The instantiation should not be an 'InstV' and the 'MetaId' -- should point to something 'Open' or a 'BlockedConst'. -- Further, the meta variable may not be 'Frozen'. -assignTerm :: MetaId -> [Arg ArgName] -> Term -> TCM () +assignTerm :: MonadMetaSolver m => MetaId -> [Arg ArgName] -> Term -> m () assignTerm x tel v = do -- verify (new) invariants whenM (isFrozen x) __IMPOSSIBLE__ assignTerm' x tel v -- | Skip frozen check. Used for eta expanding frozen metas. -assignTerm' :: MetaId -> [Arg ArgName] -> Term -> TCM () -assignTerm' x tel v = do - reportSLn "tc.meta.assign" 70 $ prettyShow x ++ " := " ++ show v ++ "\n in " ++ show tel +assignTermTCM' :: MetaId -> [Arg ArgName] -> Term -> TCM () +assignTermTCM' x tel v = do + reportSDoc "tc.meta.assign" 70 $ vcat + [ "assignTerm" <+> prettyTCM x <+> " := " <+> prettyTCM v + , nest 2 $ "tel =" <+> prettyList_ (map (text . unArg) tel) + ] -- verify (new) invariants whenM (not <$> asksTC envAssignMetas) __IMPOSSIBLE__ - verboseS "profile.metas" 10 $ liftTCM $ tickMax "max-open-metas" . (fromIntegral . size) =<< getOpenMetas + verboseS "profile.metas" 10 $ liftTCM $ return () {-tickMax "max-open-metas" . (fromIntegral . size) =<< getOpenMetas-} modifyMetaStore $ ins x $ InstV tel $ killRange v etaExpandListeners x wakeupConstraints x @@ -136,16 +157,19 @@ return x -- | Create a sort meta that may be instantiated with 'Inf' (Setω). -newSortMeta :: TCM Sort +newSortMeta :: MonadMetaSolver m => m Sort newSortMeta = ifM hasUniversePolymorphism (newSortMetaCtx =<< getContextArgs) -- else (no universe polymorphism) $ do i <- createMetaInfo - x <- newMeta Instantiable i normalMetaPriority (idP 0) $ IsSort () __DUMMY_TYPE__ + let j = IsSort () __DUMMY_TYPE__ + x <- newMeta Instantiable i normalMetaPriority (idP 0) j + reportSDoc "tc.meta.new" 50 $ + "new sort meta" <+> prettyTCM x return $ MetaS x [] -- | Create a sort meta that may be instantiated with 'Inf' (Setω). -newSortMetaCtx :: Args -> TCM Sort +newSortMetaCtx :: MonadMetaSolver m => Args -> m Sort newSortMetaCtx vs = do i <- createMetaInfo tel <- getContextTelescope @@ -155,25 +179,40 @@ "new sort meta" <+> prettyTCM x <+> ":" <+> prettyTCM t return $ MetaS x $ map Apply vs +newTypeMeta' :: Comparison -> Sort -> TCM Type +newTypeMeta' cmp s = El s . snd <$> newValueMeta RunMetaOccursCheck cmp (sort s) + newTypeMeta :: Sort -> TCM Type -newTypeMeta s = El s . snd <$> newValueMeta RunMetaOccursCheck (sort s) +newTypeMeta = newTypeMeta' CmpLeq newTypeMeta_ :: TCM Type -newTypeMeta_ = newTypeMeta =<< (workOnTypes $ newSortMeta) +newTypeMeta_ = newTypeMeta' CmpEq =<< (workOnTypes $ newSortMeta) -- TODO: (this could be made work with new uni-poly) -- Andreas, 2011-04-27: If a type meta gets solved, than we do not have to check -- that it has a sort. The sort comes from the solution. -- newTypeMeta_ = newTypeMeta Inf +newLevelMeta :: MonadMetaSolver m => m Level +newLevelMeta = do + (x, v) <- newValueMeta RunMetaOccursCheck CmpEq =<< levelType + return $ case v of + Level l -> l + MetaV x vs -> Max 0 [Plus 0 (MetaLevel x vs)] + _ -> Max 0 [Plus 0 (UnreducedLevel v)] + -- | @newInstanceMeta s t cands@ creates a new instance metavariable -- of type the output type of @t@ with name suggestion @s@. -newInstanceMeta :: MetaNameSuggestion -> Type -> TCM (MetaId, Term) +newInstanceMeta + :: MonadMetaSolver m + => MetaNameSuggestion -> Type -> m (MetaId, Term) newInstanceMeta s t = do vs <- getContextArgs ctx <- getContextTelescope newInstanceMetaCtx s (telePi_ ctx t) vs -newInstanceMetaCtx :: MetaNameSuggestion -> Type -> Args -> TCM (MetaId, Term) +newInstanceMetaCtx + :: MonadMetaSolver m + => MetaNameSuggestion -> Type -> Args -> m (MetaId, Term) newInstanceMetaCtx s t vs = do reportSDoc "tc.meta.new" 50 $ fsep [ "new instance meta:" @@ -184,7 +223,7 @@ let i = i0 { miNameSuggestion = s } TelV tel _ <- telView t let perm = idP (size tel) - x <- newMeta' OpenInstance Instantiable i normalMetaPriority perm (HasType () t) + x <- newMeta' OpenInstance Instantiable i normalMetaPriority perm (HasType () CmpLeq t) reportSDoc "tc.meta.new" 50 $ fsep [ nest 2 $ pretty x <+> ":" <+> prettyTCM t ] @@ -192,50 +231,55 @@ -- If we're not already solving instance constraints we should add this -- to the awake constraints to make sure we don't forget about it. If we -- are solving constraints it will get woken up later (see #2690) - ifM isSolvingConstraints (addConstraint c) (addAwakeConstraint' c) + ifM isSolvingConstraints (addConstraint c) (addAwakeConstraint c) etaExpandMetaSafe x return (x, MetaV x $ map Apply vs) -- | Create a new value meta with specific dependencies, possibly η-expanding in the process. -newNamedValueMeta :: RunMetaOccursCheck -> MetaNameSuggestion -> Type -> TCM (MetaId, Term) -newNamedValueMeta b s t = do - (x, v) <- newValueMeta b t +newNamedValueMeta :: MonadMetaSolver m => RunMetaOccursCheck -> MetaNameSuggestion -> Comparison -> Type -> m (MetaId, Term) +newNamedValueMeta b s cmp t = do + (x, v) <- newValueMeta b cmp t setMetaNameSuggestion x s return (x, v) -- | Create a new value meta with specific dependencies without η-expanding. -newNamedValueMeta' :: RunMetaOccursCheck -> MetaNameSuggestion -> Type -> TCM (MetaId, Term) -newNamedValueMeta' b s t = do - (x, v) <- newValueMeta' b t +newNamedValueMeta' :: MonadMetaSolver m => RunMetaOccursCheck -> MetaNameSuggestion -> Comparison -> Type -> m (MetaId, Term) +newNamedValueMeta' b s cmp t = do + (x, v) <- newValueMeta' b cmp t setMetaNameSuggestion x s return (x, v) -- | Create a new metavariable, possibly η-expanding in the process. -newValueMeta :: RunMetaOccursCheck -> Type -> TCM (MetaId, Term) -newValueMeta b t = do +newValueMeta :: MonadMetaSolver m => RunMetaOccursCheck -> Comparison -> Type -> m (MetaId, Term) +newValueMeta b cmp t = do vs <- getContextArgs tel <- getContextTelescope - newValueMetaCtx Instantiable b t tel (idP $ size tel) vs + newValueMetaCtx Instantiable b cmp t tel (idP $ size tel) vs -newValueMetaCtx :: Frozen -> RunMetaOccursCheck -> Type -> Telescope -> Permutation -> Args -> TCM (MetaId, Term) -newValueMetaCtx frozen b t tel perm ctx = - mapSndM instantiateFull =<< newValueMetaCtx' frozen b t tel perm ctx +newValueMetaCtx + :: MonadMetaSolver m + => Frozen -> RunMetaOccursCheck -> Comparison -> Type -> Telescope -> Permutation -> Args -> m (MetaId, Term) +newValueMetaCtx frozen b cmp t tel perm ctx = + mapSndM instantiateFull =<< newValueMetaCtx' frozen b cmp t tel perm ctx -- | Create a new value meta without η-expanding. -newValueMeta' :: RunMetaOccursCheck -> Type -> TCM (MetaId, Term) -newValueMeta' b t = do +newValueMeta' + :: MonadMetaSolver m + => RunMetaOccursCheck -> Comparison -> Type -> m (MetaId, Term) +newValueMeta' b cmp t = do vs <- getContextArgs tel <- getContextTelescope - newValueMetaCtx' Instantiable b t tel (idP $ size tel) vs + newValueMetaCtx' Instantiable b cmp t tel (idP $ size tel) vs --- | Create a new value meta with specific dependencies. -newValueMetaCtx' :: Frozen -> RunMetaOccursCheck -> Type -> Telescope -> Permutation -> Args -> TCM (MetaId, Term) -newValueMetaCtx' frozen b a tel perm vs = do +newValueMetaCtx' + :: MonadMetaSolver m + => Frozen -> RunMetaOccursCheck -> Comparison -> Type -> Telescope -> Permutation -> Args -> m (MetaId, Term) +newValueMetaCtx' frozen b cmp a tel perm vs = do i <- createMetaInfo' b let t = telePi_ tel a - x <- newMeta frozen i normalMetaPriority perm (HasType () t) + x <- newMeta frozen i normalMetaPriority perm (HasType () cmp t) reportSDoc "tc.meta.new" 50 $ fsep - [ "new meta:" + [ text $ "new meta (" ++ show (i ^. lensIsAbstract) ++ "):" , nest 2 $ prettyTCM vs <+> "|-" , nest 2 $ pretty x <+> ":" <+> prettyTCM t ] @@ -245,7 +289,7 @@ boundedSizeMetaHook u tel a return (x, u) -newTelMeta :: Telescope -> TCM Args +newTelMeta :: MonadMetaSolver m => Telescope -> m Args newTelMeta tel = newArgsMeta (abstract tel $ __DUMMY_TYPE__) type Condition = Dom Type -> Abs Type -> Bool @@ -253,10 +297,10 @@ trueCondition :: Condition trueCondition _ _ = True -newArgsMeta :: Type -> TCM Args +newArgsMeta :: MonadMetaSolver m => Type -> m Args newArgsMeta = newArgsMeta' trueCondition -newArgsMeta' :: Condition -> Type -> TCM Args +newArgsMeta' :: MonadMetaSolver m => Condition -> Type -> m Args newArgsMeta' condition t = do args <- getContextArgs tel <- getContextTelescope @@ -265,7 +309,9 @@ newArgsMetaCtx :: Type -> Telescope -> Permutation -> Args -> TCM Args newArgsMetaCtx = newArgsMetaCtx' Instantiable trueCondition -newArgsMetaCtx' :: Frozen -> Condition -> Type -> Telescope -> Permutation -> Args -> TCM Args +newArgsMetaCtx' + :: MonadMetaSolver m + => Frozen -> Condition -> Type -> Telescope -> Permutation -> Args -> m Args newArgsMetaCtx' frozen condition (El s tm) tel perm ctx = do tm <- reduce tm case tm of @@ -276,8 +322,9 @@ tel' = telFromList . map (mod `inverseApplyModality`) . telToList $ tel ctx' = (map . mapModality) (mod `inverseComposeModality`) ctx (m, u) <- applyModalityToContext info $ - newValueMetaCtx frozen RunMetaOccursCheck a tel' perm ctx' + newValueMetaCtx frozen RunMetaOccursCheck CmpLeq a tel' perm ctx' setMetaArgInfo m (getArgInfo dom) + setMetaNameSuggestion m (absName codom) args <- newArgsMetaCtx' frozen condition (codom `absApp` u) tel perm ctx return $ Arg info u : args _ -> return [] @@ -302,11 +349,13 @@ con <- getRecordConstructor r return $ Con con ConOSystem (map Apply fields) -newQuestionMark :: InteractionId -> Type -> TCM (MetaId, Term) -newQuestionMark = newQuestionMark' $ newValueMeta' RunMetaOccursCheck +newQuestionMark :: InteractionId -> Comparison -> Type -> TCM (MetaId, Term) +newQuestionMark ii cmp = newQuestionMark' (newValueMeta' RunMetaOccursCheck) ii cmp -newQuestionMark' :: (Type -> TCM (MetaId, Term)) -> InteractionId -> Type -> TCM (MetaId, Term) -newQuestionMark' new ii t = do +newQuestionMark' + :: (Comparison -> Type -> TCM (MetaId, Term)) + -> InteractionId -> Comparison -> Type -> TCM (MetaId, Term) +newQuestionMark' new ii cmp t = do -- Andreas, 2016-07-29, issue 1720-2 -- This is slightly risky, as the same interaction id -- maybe be shared between different contexts. @@ -317,17 +366,21 @@ -- Do not run check for recursive occurrence of meta in definitions, -- because we want to give the recursive solution interactively (Issue 589) - (x, m) <- new t + (x, m) <- new cmp t connectInteractionPoint ii x return (x, m) -- | Construct a blocked constant if there are constraints. -blockTerm :: Type -> TCM Term -> TCM Term +blockTerm + :: (MonadMetaSolver m, MonadConstraint m, MonadFresh Nat m, MonadFresh ProblemId m) + => Type -> m Term -> m Term blockTerm t blocker = do (pid, v) <- newProblem blocker blockTermOnProblem t v pid -blockTermOnProblem :: Type -> Term -> ProblemId -> TCM Term +blockTermOnProblem + :: (MonadMetaSolver m, MonadFresh Nat m) + => Type -> Term -> ProblemId -> m Term blockTermOnProblem t v pid = -- Andreas, 2012-09-27 do not block on unsolved size constraints ifM (isProblemSolved pid `or2M` isSizeProblem pid) (return v) $ do @@ -336,7 +389,7 @@ tel <- getContextTelescope x <- newMeta' (BlockedConst $ abstract tel v) Instantiable i lowMetaPriority (idP $ size tel) - (HasType () $ telePi_ tel t) + (HasType () CmpLeq $ telePi_ tel t) -- we don't instantiate blocked terms inTopContext $ addConstraint (Guarded (UnBlock x) pid) reportSDoc "tc.meta.blocked" 20 $ vcat @@ -351,21 +404,26 @@ -- blocked terms can be instantiated before they are unblocked, thus making -- constraint solving a bit more robust against instantiation order. -- Andreas, 2015-05-22: DontRunMetaOccursCheck to avoid Issue585-17. - (_, v) <- newValueMeta DontRunMetaOccursCheck t - i <- liftTCM fresh + (m', v) <- newValueMeta DontRunMetaOccursCheck CmpLeq t + reportSDoc "tc.meta.blocked" 30 $ "setting twin of" <+> prettyTCM m' <+> "to be" <+> prettyTCM x + updateMetaVar m' (\ mv -> mv { mvTwin = Just x }) + i <- fresh -- This constraint is woken up when unblocking, so it doesn't need a problem id. - cmp <- buildProblemConstraint_ (ValueCmp CmpEq t v (MetaV x es)) + cmp <- buildProblemConstraint_ (ValueCmp CmpEq (AsTermsOf t) v (MetaV x es)) + reportSDoc "tc.constr.add" 20 $ "adding constraint" <+> prettyTCM cmp listenToMeta (CheckConstraint i cmp) x return v -blockTypeOnProblem :: Type -> ProblemId -> TCM Type +blockTypeOnProblem + :: (MonadMetaSolver m, MonadFresh Nat m) + => Type -> ProblemId -> m Type blockTypeOnProblem (El s a) pid = El s <$> blockTermOnProblem (El Inf $ Sort s) a pid -- | @unblockedTester t@ returns @False@ if @t@ is a meta or a blocked term. -- -- Auxiliary function to create a postponed type checking problem. unblockedTester :: Type -> TCM Bool -unblockedTester t = ifBlockedType t (\ m t -> return False) (\ _ t -> return True) +unblockedTester t = ifBlocked t (\ m t -> return False) (\ _ t -> return True) -- | Create a postponed type checking problem @e : t@ that waits for type @t@ -- to unblock (become instantiated or its constraints resolved). @@ -391,7 +449,11 @@ let t = problemType p m <- newMeta' (PostponedTypeCheckingProblem cl unblock) Instantiable i normalMetaPriority (idP (size tel)) - $ HasType () $ telePi_ tel t + $ HasType () CmpLeq $ telePi_ tel t + inTopContext $ reportSDoc "tc.meta.postponed" 20 $ vcat + [ "new meta" <+> prettyTCM m <+> ":" <+> prettyTCM (telePi_ tel t) + , "for postponed typechecking problem" <+> prettyTCM p + ] -- Create the meta that we actually return -- Andreas, 2012-03-15 @@ -401,8 +463,9 @@ -- to run the extended occurs check (metaOccurs) to exclude -- non-terminating solutions. es <- map Apply <$> getContextArgs - (_, v) <- newValueMeta DontRunMetaOccursCheck t - cmp <- buildProblemConstraint_ (ValueCmp CmpEq t v (MetaV m es)) + (_, v) <- newValueMeta DontRunMetaOccursCheck CmpLeq t + cmp <- buildProblemConstraint_ (ValueCmp CmpEq (AsTermsOf t) v (MetaV m es)) + reportSDoc "tc.constr.add" 20 $ "adding constraint" <+> prettyTCM cmp i <- liftTCM fresh listenToMeta (CheckConstraint i cmp) m addConstraint (UnBlock m) @@ -429,33 +492,17 @@ wakeupListener (EtaExpand x) = etaExpandMetaSafe x wakeupListener (CheckConstraint _ c) = do reportSDoc "tc.meta.blocked" 20 $ "waking boxed constraint" <+> prettyTCM c - addAwakeConstraints [c] + modifyAwakeConstraints (c:) solveAwakeConstraints -- | Do safe eta-expansions for meta (@SingletonRecords,Levels@). -etaExpandMetaSafe :: MetaId -> TCM () +etaExpandMetaSafe :: (MonadMetaSolver m) => MetaId -> m () etaExpandMetaSafe = etaExpandMeta [SingletonRecords,Levels] --- | Various kinds of metavariables. - -data MetaKind = - Records - -- ^ Meta variables of record type. - | SingletonRecords - -- ^ Meta variables of \"hereditarily singleton\" record type. - | Levels - -- ^ Meta variables of level type, if type-in-type is activated. - deriving (Eq, Enum, Bounded, Show) - --- | All possible metavariable kinds. - -allMetaKinds :: [MetaKind] -allMetaKinds = [minBound .. maxBound] - -- | Eta expand a metavariable, if it is of the specified kind. -- Don't do anything if the metavariable is a blocked term. -etaExpandMeta :: [MetaKind] -> MetaId -> TCM () -etaExpandMeta kinds m = whenM (asksTC envAssignMetas `and2M` isEtaExpandable kinds m) $ do +etaExpandMetaTCM :: [MetaKind] -> MetaId -> TCM () +etaExpandMetaTCM kinds m = whenM ((not <$> isFrozen m) `and2M` asksTC envAssignMetas `and2M` isEtaExpandable kinds m) $ do verboseBracket "tc.meta.eta" 20 ("etaExpandMeta " ++ prettyShow m) $ do let waitFor x = do reportSDoc "tc.meta.eta" 20 $ do @@ -470,7 +517,7 @@ meta <- lookupMeta m case mvJudgement meta of IsSort{} -> dontExpand - HasType _ a -> do + HasType _ cmp a -> do reportSDoc "tc.meta.eta" 40 $ sep [ text "considering eta-expansion at type " @@ -493,6 +540,9 @@ -- solution for the whole meta. if any domFinite (flattenTel tel) then dontExpand else do + -- Issue #3774: continue with the right context for b + addContext tel $ do + -- if the target type @b@ of @m@ is a meta variable @x@ itself -- (@NonBlocked (MetaV{})@), -- or it is blocked by a meta-variable @x@ (@Blocked@), we cannot @@ -509,9 +559,7 @@ -- Andreas, 2019-03-18, AIM XXIX, issue #3597 -- When meta is frozen instantiate it with in-turn frozen metas. inTopContext $ do - verboseS "tc.meta.eta" 15 $ do - du <- prettyTCM u - reportSDoc "tc.meta.eta" 15 $ sep + reportSDoc "tc.meta.eta" 15 $ sep [ "eta expanding: " <+> pretty m <+> " --> " , nest 2 $ prettyTCM u ] @@ -535,14 +583,15 @@ reportSLn "tc.meta.eta" 20 $ "Expanding level meta to 0 (type-in-type)" -- Andreas, 2012-03-30: No need for occurrence check etc. -- we directly assign the solution for the meta - noConstraints $ assignTerm m (telToArgs tel) (Level $ Max []) + noConstraints $ assignTerm m (telToArgs tel) $ Level $ ClosedLevel 0 ) $ {- else -} dontExpand _ -> dontExpand -- | Eta expand blocking metavariables of record type, and reduce the -- blocked thing. -etaExpandBlocked :: Reduce t => Blocked t -> TCM (Blocked t) +etaExpandBlocked :: (MonadReduce m, MonadMetaSolver m, Reduce t) + => Blocked t -> m (Blocked t) etaExpandBlocked t@NotBlocked{} = return t etaExpandBlocked (Blocked m t) = do etaExpandMeta [Records] m @@ -551,31 +600,21 @@ Blocked m' _ | m /= m' -> etaExpandBlocked t _ -> return t --- * Solve constraint @x vs = v@. - --- | Assign to an open metavar which may not be frozen. --- First check that metavar args are in pattern fragment. --- Then do extended occurs check on given thing. --- --- Assignment is aborted by throwing a @PatternErr@ via a call to --- @patternViolation@. This error is caught by @catchConstraint@ --- during equality checking (@compareAtom@) and leads to --- restoration of the original constraints. - -assignV :: CompareDirection -> MetaId -> Args -> Term -> TCM () -assignV dir x args v = assignWrapper dir x (map Apply args) v $ assign dir x args v - -assignWrapper :: CompareDirection -> MetaId -> Elims -> Term -> TCM () -> TCM () +assignWrapper :: (MonadMetaSolver m, MonadConstraint m, MonadError TCErr m, MonadDebug m, HasOptions m) + => CompareDirection -> MetaId -> Elims -> Term -> m () -> m () assignWrapper dir x es v doAssign = do - ifNotM (asksTC envAssignMetas) patternViolation $ {- else -} do + ifNotM (asksTC envAssignMetas) dontAssign $ {- else -} do reportSDoc "tc.meta.assign" 10 $ do "term" <+> prettyTCM (MetaV x es) <+> text (":" ++ show dir) <+> prettyTCM v - liftTCM $ nowSolvingConstraints doAssign `finally` solveAwakeConstraints + nowSolvingConstraints doAssign `finally` solveAwakeConstraints + where dontAssign = do + reportSLn "tc.meta.assign" 10 "don't assign metas" + patternViolation -- | Miller pattern unification: -- --- @assign x vs v@ solves problem @x vs = v@ for meta @x@ +-- @assign dir x vs v a@ solves problem @x vs <=(dir) v : a@ for meta @x@ -- if @vs@ are distinct variables (linearity check) -- and @v@ depends only on these variables -- and does not contain @x@ itself (occurs check). @@ -589,8 +628,8 @@ -- For a reference to some of these extensions, read -- Andreas Abel and Brigitte Pientka's TLCA 2011 paper. -assign :: CompareDirection -> MetaId -> Args -> Term -> TCM () -assign dir x args v = do +assign :: CompareDirection -> MetaId -> Args -> Term -> CompareAs -> TCM () +assign dir x args v target = do mvar <- lookupMeta x -- information associated with meta x let t = jMetaType $ mvJudgement mvar @@ -654,7 +693,7 @@ , nest 2 $ inTopContext $ prettyTCM cxt ] - expandProjectedVars args v $ \ args v -> do + expandProjectedVars args (v, target) $ \ args (v, target) -> do reportSDoc "tc.meta.assign.proj" 45 $ do cxt <- getContextTelescope @@ -663,37 +702,62 @@ , nest 2 $ inTopContext $ prettyTCM cxt ] - -- If we had the type here we could save the work we put - -- into expanding projected variables. - -- catchConstraint (ValueCmp CmpEq ? (MetaV m $ map Apply args) v) $ do + -- Andreas, 2019-11-16, issue #4159: + -- We would like to save the work we put into expanding projected variables. + -- However, the Conversion checker speculatively tries some assignment + -- in some places (e.g. shortcut) and relies on an exception to be thrown + -- to try other alternatives next. + -- If we catch the exception here, this (brittle) mechanism will be broken. + -- Maybe one possibility would be to rethrow the exception with the + -- new constraint. Then, further up, it could be decided whether + -- to discard the new constraint and do something different, + -- or add the new constraint when postponing. + -- BEGIN attempt #4159 + -- let constraint = case v of + -- -- Sort s -> dirToCmp SortCmp dir (MetaS x $ map Apply args) s + -- _ -> dirToCmp (\ cmp -> ValueCmp cmp target) dir (MetaV x $ map Apply args) v + -- reportSDoc "tc.meta.assign.catch" 40 $ sep + -- [ "assign: catching constraint:" + -- , prettyTCM constraint + -- ] + -- -- reportSDoc "tc.meta.assign.catch" 60 $ sep + -- -- [ "assign: catching constraint:" + -- -- , pretty constraint + -- -- ] + -- reportSDoc "tc.meta.assign.catch" 80 $ sep + -- [ "assign: catching constraint (raw):" + -- , (text . show) constraint + -- ] + -- catchConstraint constraint $ do + -- END attempt #4159 + + -- Andreas, 2011-04-21 do the occurs check first -- e.g. _1 x (suc x) = suc (_2 x y) -- even though the lhs is not a pattern, we can prune the y from _2 - (relVL, nonstrictVL, irrVL) <- do - -- Andreas, 2016-11-03 #2211 attempt to do s.th. for unused - if False -- irrelevant $ getMetaRelevance mvar - then do - reportSDoc "tc.meta.assign" 25 $ "meta is irrelevant or unused" - return (Set.toList $ allFreeVars args, empty, empty) - else do - let vars = allFreeVarsWithOcc args - relVL = IntMap.keys $ IntMap.filter isRelevant vars - nonstrictVL = IntMap.keys $ IntMap.filter isNonStrict vars + let + vars = freeVars args + relVL = filterVarMapToList isRelevant vars + nonstrictVL = filterVarMapToList isNonStrict vars + irrVL = filterVarMapToList (liftM2 (&&) isIrrelevant isUnguarded) vars -- Andreas, 2011-10-06 only irrelevant vars that are direct -- arguments to the meta, hence, can be abstracted over, may -- appear on the rhs. (test/fail/Issue483b) -- Update 2011-03-27: Also irr. vars under record constructors. - let fromIrrVar (Var i []) = return [i] - fromIrrVar (Con c _ vs) = - ifM (isNothing <$> isRecordConstructor (conName c)) (return []) $ - concat <$> mapM (fromIrrVar . {- stripDontCare .-} unArg) (fromMaybe __IMPOSSIBLE__ (allApplyElims vs)) - fromIrrVar _ = return [] - irrVL <- concat <$> mapM fromIrrVar - [ v | Arg info v <- args, isIrrelevant info ] - -- irrelevant (getRelevance info) ] - return (relVL, nonstrictVL, irrVL) + -- Andreas, 2019-06-25: The reason is that when solving + -- @X args = v@ we drop all irrelevant arguments that + -- are not variables (after flattening of record constructors). + -- (See isVarOrIrrelevant in inverseSubst.) + -- Thus, the occurs-check needs to ensure only these variables + -- are mentioned on the rhs. + -- In the terminology of free variable analysis, the retained + -- irrelevant variables are exactly the Unguarded ones. + -- Jesper, 2019-10-15: This is actually wrong since it + -- will lead to pruning of metas that should not be + -- pruned, see #4136. + reportSDoc "tc.meta.assign" 20 $ let pr (Var n []) = text (show n) pr (Def c []) = prettyTCM c @@ -710,7 +774,8 @@ -- Herein, distinguish relevant and irrelevant vars, -- since when abstracting irrelevant lhs vars, they may only occur -- irrelevantly on rhs. - v <- liftTCM $ occursCheck x (relVL, nonstrictVL, irrVL) v + -- v <- liftTCM $ occursCheck x (relVL, nonstrictVL, irrVL) v + v <- liftTCM $ occursCheck x vars v reportSLn "tc.meta.assign" 15 "passed occursCheck" verboseS "tc.meta.assign" 30 $ do @@ -728,7 +793,7 @@ -- we'll build solutions where the irrelevant terms are not valid let fvs = allFreeVars v reportSDoc "tc.meta.assign" 20 $ - "fvars rhs:" <+> sep (map (text . show) $ Set.toList fvs) + "fvars rhs:" <+> sep (map (text . show) $ VarSet.toList fvs) -- Check that the arguments are variables mids <- do @@ -738,7 +803,9 @@ Right ids -> do reportSDoc "tc.meta.assign" 50 $ "inverseSubst returns:" <+> sep (map prettyTCM ids) - return $ Just ids + let boundVars = VarSet.fromList $ map fst ids + if | fvs `VarSet.isSubsetOf` boundVars -> return $ Just ids + | otherwise -> return Nothing -- we have proper values as arguments which could be cased on -- here, we cannot prune, since offending vars could be eliminated Left CantInvert -> return Nothing @@ -753,16 +820,41 @@ Just ids -> do -- Check linearity ids <- do - res <- runExceptT $ checkLinearity {- (`Set.member` fvs) -} ids + res <- runExceptT $ checkLinearity {- (`VarSet.member` fvs) -} ids case res of -- case: linear Right ids -> return ids -- case: non-linear variables that could possibly be pruned Left () -> attemptPruning x args fvs + let n = length args + TelV tel' _ <- telViewUpToPath n t + + -- Check subtyping constraints on the context variables. + + -- Intuition: suppose @_X : (x : A) → B@, then to turn + -- @ + -- Γ(x : A') ⊢ _X x =?= v : B'@ + -- @ + -- into + -- @ + -- Γ ⊢ _X =?= λ x → v + -- @ + -- we need to check that @A <: A'@ (due to contravariance). + let sigma = parallelS $ reverse $ map unArg args + hasSubtyping <- collapseDefault . optSubtyping <$> pragmaOptions + when hasSubtyping $ forM_ ids $ \(i , u) -> do + -- @u@ is a (projected) variable, so we can infer its type + a <- applySubst sigma <$> addContext tel' (infer u) + a' <- typeOfBV i + checkSubtypeIsEqual a' a + `catchError` \case + TypeError{} -> patternViolation + err -> throwError err + -- Solve. m <- getContextSize - assignMeta' m x t (length args) ids v + assignMeta' m x t n ids v where -- | Try to remove meta arguments from lhs that mention variables not occurring on rhs. attemptPruning @@ -772,7 +864,7 @@ -> TCM a attemptPruning x args fvs = do -- non-linear lhs: we cannot solve, but prune - killResult <- prune x args $ Set.toList fvs + killResult <- prune x args $ (`VarSet.member` fvs) reportSDoc "tc.meta.assign" 10 $ "pruning" <+> prettyTCM x <+> do text $ @@ -900,27 +992,26 @@ "preparing to instantiate: " <+> prettyTCM v -- Rename the variables in v to make it suitable for abstraction over ids. - v' <- do - -- Basically, if - -- Γ = a b c d e - -- ids = d b e - -- then - -- v' = (λ a b c d e. v) _ 1 _ 2 0 - -- - -- Andreas, 2013-10-25 Solve using substitutions: - -- Convert assocList @ids@ (which is sorted) into substitution, - -- filling in __IMPOSSIBLE__ for the missing terms, e.g. - -- [(0,0),(1,2),(3,1)] --> [0, 2, __IMP__, 1, __IMP__] - -- ALT 1: O(m * size ids), serves as specification - -- let ivs = [fromMaybe __IMPOSSIBLE__ $ lookup i ids | i <- [0..m-1]] - -- ALT 2: O(m) - let assocToList i l = case l of - _ | i >= m -> [] - ((j,u) : l) | i == j -> Just u : assocToList (i+1) l - _ -> Nothing : assocToList (i+1) l - ivs = assocToList 0 ids - rho = prependS __IMPOSSIBLE__ ivs $ raiseS n - return $ applySubst rho v + -- Basically, if + -- Γ = a b c d e + -- ids = d b e + -- then + -- v' = (λ a b c d e. v) _ 1 _ 2 0 + -- + -- Andreas, 2013-10-25 Solve using substitutions: + -- Convert assocList @ids@ (which is sorted) into substitution, + -- filling in __IMPOSSIBLE__ for the missing terms, e.g. + -- [(0,0),(1,2),(3,1)] --> [0, 2, __IMP__, 1, __IMP__] + -- ALT 1: O(m * size ids), serves as specification + -- let ivs = [fromMaybe __IMPOSSIBLE__ $ lookup i ids | i <- [0..m-1]] + -- ALT 2: O(m) + let assocToList i l = case l of + _ | i >= m -> [] + ((j,u) : l) | i == j -> Just u : assocToList (i+1) l + _ -> Nothing : assocToList (i+1) l + ivs = assocToList 0 ids + rho = prependS __IMPOSSIBLE__ ivs $ raiseS n + v' = applySubst rho v -- Metas are top-level so we do the assignment at top-level. inTopContext $ do @@ -929,7 +1020,6 @@ -- (no longer from ids which may not be the complete variable list -- any more) reportSDoc "tc.meta.assign" 15 $ "type of meta =" <+> prettyTCM t - reportSDoc "tc.meta.assign" 70 $ "type of meta =" <+> text (show t) (telv@(TelV tel' a),bs) <- telViewUpToPathBoundary n t reportSDoc "tc.meta.assign" 30 $ "tel' =" <+> prettyTCM tel' @@ -940,23 +1030,35 @@ when (size tel' < n) patternViolation -- WAS: __IMPOSSIBLE__ + -- Jesper, 2019-09-13: When --no-sort-comparison is enabled, + -- we equate the sort of the solution with the sort of the + -- metavariable, in order to solve metavariables in sorts. + whenM ((not . optCompareSorts <$> pragmaOptions) `or2M` + (optCumulativity <$> pragmaOptions)) $ case unEl a of + Sort s -> addContext tel' $ do + m <- lookupMeta x + cmp <- ifM (not . optCumulativity <$> pragmaOptions) (return CmpEq) $ + case mvJudgement m of + HasType{ jComparison = cmp } -> return cmp + IsSort{} -> __IMPOSSIBLE__ + s' <- sortOf v' + reportSDoc "tc.meta.assign" 40 $ + "Instantiating sort" <+> prettyTCM s <+> + "to sort" <+> prettyTCM s' <+> "of solution" <+> prettyTCM v' + traceCall (CheckMetaSolution (getRange m) x a v') $ + compareSort cmp s' s + _ -> return () + -- Perform the assignment (and wake constraints). let vsol = abstract tel' v' -- Andreas, 2013-10-25 double check solution before assigning - whenM (optDoubleCheck <$> pragmaOptions) $ noConstraints $ dontAssignMetas $ do + whenM (optDoubleCheck <$> pragmaOptions) $ do m <- lookupMeta x reportSDoc "tc.meta.check" 30 $ "double checking solution" - addContext tel' $ case mvJudgement m of - HasType{} -> do - reportSDoc "tc.meta.check" 30 $ nest 2 $ - prettyTCM v' <+> " : " <+> prettyTCM a - checkInternal v' a - IsSort{} -> void $ do - reportSDoc "tc.meta.check" 30 $ nest 2 $ - prettyTCM v' <+> " is a sort" - checkSort defaultAction =<< shouldBeSort (El __DUMMY_SORT__ v') + catchConstraint (CheckMetaInst x) $ + addContext tel' $ checkSolutionForMeta x m v' a reportSDoc "tc.meta.assign" 10 $ "solving" <+> prettyTCM x <+> ":=" <+> prettyTCM vsol @@ -975,6 +1077,81 @@ equalTermOnFace r t y v return v +-- | Check that the instantiation of the given metavariable fits the +-- type of the metavariable. If the metavariable is not yet +-- instantiated, add a constraint to check the instantiation later. +checkMetaInst :: MetaId -> TCM () +checkMetaInst x = do + m <- lookupMeta x + let postpone = addConstraint $ CheckMetaInst x + case mvInstantiation m of + BlockedConst{} -> postpone + PostponedTypeCheckingProblem{} -> postpone + Open{} -> postpone + OpenInstance{} -> postpone + InstV xs v -> do + let n = size xs + t = jMetaType $ mvJudgement m + (telv@(TelV tel a),bs) <- telViewUpToPathBoundary n t + catchConstraint (CheckMetaInst x) $ addContext tel $ checkSolutionForMeta x m v a + +-- | Check that the instantiation of the metavariable with the given +-- term is well-typed. +checkSolutionForMeta :: MetaId -> MetaVariable -> Term -> Type -> TCM () +checkSolutionForMeta x m v a = do + reportSDoc "tc.meta.check" 30 $ "checking solution for meta" <+> prettyTCM x + case mvJudgement m of + HasType{ jComparison = cmp } -> do + reportSDoc "tc.meta.check" 30 $ nest 2 $ + prettyTCM x <+> " : " <+> prettyTCM a <+> ":=" <+> prettyTCM v + reportSDoc "tc.meta.check" 50 $ nest 2 $ do + ctx <- getContext + inTopContext $ "in context: " <+> prettyTCM (PrettyContext ctx) + traceCall (CheckMetaSolution (getRange m) x a v) $ + checkInternal v cmp a + IsSort{} -> void $ do + reportSDoc "tc.meta.check" 30 $ nest 2 $ + prettyTCM x <+> ":=" <+> prettyTCM v <+> " is a sort" + s <- shouldBeSort (El __DUMMY_SORT__ v) + traceCall (CheckMetaSolution (getRange m) x (sort (univSort Nothing s)) (Sort s)) $ + checkSort defaultAction s + +-- | Given two types @a@ and @b@ with @a <: b@, check that @a == b@. +checkSubtypeIsEqual :: Type -> Type -> TCM () +checkSubtypeIsEqual a b = do + reportSDoc "tc.meta.subtype" 30 $ + "checking that subtype" <+> prettyTCM a <+> + "of" <+> prettyTCM b <+> "is actually equal." + ((a, b), equal) <- SynEq.checkSyntacticEquality a b + unless equal $ do + cumulativity <- optCumulativity <$> pragmaOptions + reduce (unEl b) >>= \case + Sort sb -> reduce (unEl a) >>= \case + Sort sa | cumulativity -> equalSort sa sb + | otherwise -> return () + MetaV{} -> patternViolation + Dummy{} -> return () -- TODO: this shouldn't happen but + -- currently does because of generalized + -- metas being created in a dummy context + _ -> patternViolation + Pi b1 b2 -> reduce (unEl a) >>= \case + Pi a1 a2 + | getRelevance a1 /= getRelevance b1 -> patternViolation + | getQuantity a1 /= getQuantity b1 -> patternViolation + | getCohesion a1 /= getCohesion b1 -> patternViolation + | otherwise -> do + checkSubtypeIsEqual (unDom b1) (unDom a1) + underAbstractionAbs a1 a2 $ \a2' -> checkSubtypeIsEqual a2' (absBody b2) + MetaV{} -> patternViolation + Dummy{} -> return () -- TODO: this shouldn't happen but + -- currently does because of generalized + -- metas being created in a dummy context + _ -> patternViolation + MetaV{} -> patternViolation + -- TODO: check subtyping for Size< types + _ -> return () + + -- | Turn the assignment problem @_X args <= SizeLt u@ into -- @_X args = SizeLt (_Y args)@ and constraint -- @_Y args <= u@. @@ -1004,17 +1181,17 @@ let size = sizeType_ qSize t' = telePi tel size y <- newMeta Instantiable (mvInfo mvar) (mvPriority mvar) (mvPermutation mvar) - (HasType __IMPOSSIBLE__ t') + (HasType __IMPOSSIBLE__ CmpLeq t') -- Note: no eta-expansion of new meta possible/necessary. -- Add the size constraint @y args `dir` u@. let yArgs = MetaV y $ map Apply args - addConstraint $ dirToCmp (`ValueCmp` size) dir yArgs u + addConstraint $ dirToCmp (`ValueCmp` AsSizes) dir yArgs u -- We continue with the new assignment problem, and install -- an exception handler, since we created a meta and a constraint, -- so we cannot fall back to the original handler. let xArgs = MetaV x $ map Apply args v' = Def qSizeLt [Apply $ Arg ai yArgs] - c = dirToCmp (`ValueCmp` sizeUniv) dir xArgs v' + c = dirToCmp (`ValueCmp` (AsTermsOf sizeUniv)) dir xArgs v' catchConstraint c $ cont v' _ -> fallback @@ -1053,7 +1230,7 @@ reportSDoc "tc.meta.assign.proj" 25 $ "eta-expanding var " <+> prettyTCM (var i) <+> " in terms " <+> prettyTCM v - inTopContext $ addContext delta $ + unsafeInTopContext $ addContext delta $ succeed $ applySubst tau v -- | Check whether one of the meta args is a projected var. @@ -1154,7 +1331,7 @@ _ -> __IMPOSSIBLE__ -} -type FVs = Set.VarSet +type FVs = VarSet type SubstCand = [(Int,Term)] -- ^ a possibly non-deterministic substitution -- | Turn non-det substitution into proper substitution, if possible. @@ -1171,7 +1348,7 @@ makeLinear [] = __IMPOSSIBLE__ makeLinear grp@[_] = return grp makeLinear (p@(i,t) : _) = - ifM ((Right True ==) <$> do isSingletonTypeModuloRelevance =<< typeOfBV i) + ifM ((Right True ==) <$> do lift . isSingletonTypeModuloRelevance =<< typeOfBV i) (return [p]) (throwError ()) @@ -1208,31 +1385,38 @@ neutralArg = throwError NeutralArg isVarOrIrrelevant :: Res -> (Arg Term, Term) -> ExceptT InvertExcept TCM Res - isVarOrIrrelevant vars (arg, t) = - case arg of + isVarOrIrrelevant vars (Arg info v, t) = do + let irr | isIrrelevant info = True + | DontCare{} <- v = True + | otherwise = False + case stripDontCare v of -- i := x - Arg info (Var i []) -> return $ (Arg info i, t) `cons` vars + Var i [] -> return $ (Arg info i, t) `cons` vars -- π i := x try to eta-expand projection π away! - Arg _ (Var i es) | Just qs <- mapM isProjElim es -> + Var i es | Just qs <- mapM isProjElim es -> throwError $ ProjectedVar i qs -- (i, j) := x becomes [i := fst x, j := snd x] -- Andreas, 2013-09-17 but only if constructor is fully applied - Arg info (Con c ci es) -> do + Con c ci es -> do let fallback | isIrrelevant info = return vars | otherwise = failure - isRC <- lift $ isRecordConstructor $ conName c - case isRC of - Just (_, Record{ recFields = fs }) - | length fs == length es -> do - let aux (Arg _ v) (Arg info' f) = (Arg ai v,) $ t `applyE` [Proj ProjSystem f] where + irrProj <- optIrrelevantProjections <$> pragmaOptions + (lift $ isRecordConstructor $ conName c) >>= \case + Just (_, r@Record{ recFields = fs }) + | YesEta <- recEtaEquality r -- Andreas, 2019-11-10, issue #4185: only for eta-records + , length fs == length es + , hasQuantity0 info || all usableQuantity fs -- Andreas, 2019-11-12/17, issue #4168b + , irrProj || all isRelevant fs -> do + let aux (Arg _ v) Dom{domInfo = info', unDom = f} = (Arg ai v,) $ t `applyE` [Proj ProjSystem f] where ai = ArgInfo { argInfoHiding = min (getHiding info) (getHiding info') , argInfoModality = Modality { modRelevance = max (getRelevance info) (getRelevance info') , modQuantity = max (getQuantity info) (getQuantity info') + , modCohesion = max (getCohesion info) (getCohesion info') } , argInfoOrigin = min (getOrigin info) (getOrigin info') , argInfoFreeVariables = unknownFreeVariables @@ -1241,27 +1425,23 @@ res <- loop $ zipWith aux vs fs return $ res `append` vars | otherwise -> fallback - Just _ -> __IMPOSSIBLE__ - Nothing -> fallback + _ -> fallback -- An irrelevant argument which is not an irrefutable pattern is dropped - Arg info _ | isIrrelevant info -> return vars - -- Andreas, 2013-10-29 - -- An irrelevant part can also be marked by a DontCare - -- (coming from an irrelevant projection), see Issue 927: - Arg _ DontCare{} -> return vars + _ | irr -> return vars -- Distinguish args that can be eliminated (Con,Lit,Lam,unsure) ==> failure -- from those that can only put somewhere as a whole ==> neutralArg - Arg _ Var{} -> neutralArg - Arg _ Def{} -> neutralArg -- Note that this Def{} is in normal form and might be prunable. - Arg _ Lam{} -> failure - Arg _ Lit{} -> failure - Arg _ MetaV{} -> failure - Arg _ Pi{} -> neutralArg - Arg _ Sort{} -> neutralArg - Arg _ Level{} -> neutralArg - Arg _ (Dummy s) -> __IMPOSSIBLE_VERBOSE__ s + Var{} -> neutralArg + Def{} -> neutralArg -- Note that this Def{} is in normal form and might be prunable. + Lam{} -> failure + Lit{} -> failure + MetaV{} -> failure + Pi{} -> neutralArg + Sort{} -> neutralArg + Level{} -> neutralArg + DontCare{} -> __IMPOSSIBLE__ -- Ruled out by stripDontCare + Dummy s _ -> __IMPOSSIBLE_VERBOSE__ s -- managing an assoc list where duplicate indizes cannot be irrelevant vars append :: Res -> Res -> Res @@ -1275,14 +1455,6 @@ -- filter out duplicate irrelevants filter (not . (\ a@(Arg info j, t) -> isIrrelevant info && i == j)) vars --- UNUSED --- -- | Used in 'Agda.Interaction.BasicOps.giveExpr'. --- updateMeta :: MetaId -> Term -> TCM () --- updateMeta mI v = do --- mv <- lookupMeta mI --- withMetaInfo' mv $ do --- args <- getContextArgs --- noConstraints $ assignV DirEq mI args v -- | Turn open metas into postulates. -- @@ -1300,7 +1472,7 @@ ms <- IntMap.assocs <$> useTC stMetaStore forM_ ms $ \ (x, mv) -> do when (isOpenMeta $ mvInstantiation mv) $ do - let t = jMetaType $ mvJudgement mv + let t = dummyTypeToOmega $ jMetaType $ mvJudgement mv -- Create a name for the new postulate. let r = clValue $ miClosRange $ mvInfo mv @@ -1326,3 +1498,29 @@ let inst = InstV [] $ Def q [] updateMetaVar (MetaId x) $ \ mv0 -> mv0 { mvInstantiation = inst } return () + where + -- Unsolved sort metas can have a type ending in a Dummy if they are allowed to be instantiated + -- to Setω. This will crash the serializer (issue #3730). To avoid this we replace dummy type + -- codomains by Setω. + dummyTypeToOmega t = + case telView' t of + TelV tel (El _ Dummy{}) -> abstract tel topSort + _ -> t + +-- | Sort metas in dependency order. +dependencySortMetas :: [MetaId] -> TCM (Maybe [MetaId]) +dependencySortMetas metas = do + metaGraph <- concat <$> do + forM metas $ \ m -> do + deps <- allMetas (\ m' -> if m' `elem` metas then singleton m' else mempty) <$> getType m + return [ (m, m') | m' <- Set.toList deps ] + + return $ Graph.topSort metas metaGraph + + where + -- Sort metas don't have types, but we still want to sort them. + getType m = do + mv <- lookupMeta m + case mvJudgement mv of + IsSort{} -> return Nothing + HasType{ jMetaType = t } -> Just <$> instantiateFull t diff --git a/src/full/Agda/TypeChecking/MetaVars.hs-boot b/src/full/Agda/TypeChecking/MetaVars.hs-boot --- a/src/full/Agda/TypeChecking/MetaVars.hs-boot +++ b/src/full/Agda/TypeChecking/MetaVars.hs-boot @@ -1,19 +1,22 @@ module Agda.TypeChecking.MetaVars where -import Agda.Syntax.Common ( Arg, Dom ) -import Agda.Syntax.Internal ( MetaId, Term, Type, Args, Abs, Telescope, Sort ) -import Agda.TypeChecking.Monad.Base ( TCM, RunMetaOccursCheck, CompareDirection ) +import Agda.Syntax.Common ( Arg ) +import Agda.Syntax.Internal ( MetaId, Term, Type, Args, Dom, Abs, Telescope, Sort ) +import Agda.TypeChecking.Monad.Base ( TCM, RunMetaOccursCheck, Comparison, CompareAs, CompareDirection ) +import Agda.TypeChecking.Monad.MetaVars (MonadMetaSolver) +instance MonadMetaSolver TCM + type Condition = Dom Type -> Abs Type -> Bool -newArgsMeta' :: Condition -> Type -> TCM Args -newArgsMeta :: Type -> TCM Args -assignTerm :: MetaId -> [Arg String] -> Term -> TCM () -etaExpandMetaSafe :: MetaId -> TCM () -assignV :: CompareDirection -> MetaId -> Args -> Term -> TCM () -assign :: CompareDirection -> MetaId -> Args -> Term -> TCM () -newInstanceMeta :: String -> Type -> TCM (MetaId, Term) -newValueMeta :: RunMetaOccursCheck -> Type -> TCM (MetaId, Term) -newNamedValueMeta :: RunMetaOccursCheck -> String -> Type -> TCM (MetaId, Term) -newNamedValueMeta':: RunMetaOccursCheck -> String -> Type -> TCM (MetaId, Term) -newTelMeta :: Telescope -> TCM Args -newSortMeta :: TCM Sort +newArgsMeta' :: MonadMetaSolver m => Condition -> Type -> m Args +newArgsMeta :: MonadMetaSolver m => Type -> m Args +assignTerm :: MonadMetaSolver m => MetaId -> [Arg String] -> Term -> m () +etaExpandMetaSafe :: MonadMetaSolver m => MetaId -> m () +assign :: CompareDirection -> MetaId -> Args -> Term -> CompareAs -> TCM () +newInstanceMeta :: MonadMetaSolver m => String -> Type -> m (MetaId, Term) +newValueMeta :: MonadMetaSolver m => RunMetaOccursCheck -> Comparison -> Type -> m (MetaId, Term) +newNamedValueMeta :: MonadMetaSolver m => RunMetaOccursCheck -> String -> Comparison -> Type -> m (MetaId, Term) +newNamedValueMeta':: MonadMetaSolver m => RunMetaOccursCheck -> String -> Comparison -> Type -> m (MetaId, Term) +newTelMeta :: MonadMetaSolver m => Telescope -> m Args +newSortMeta :: MonadMetaSolver m => m Sort +checkMetaInst :: MetaId -> TCM () diff --git a/src/full/Agda/TypeChecking/MetaVars/Mention.hs b/src/full/Agda/TypeChecking/MetaVars/Mention.hs --- a/src/full/Agda/TypeChecking/MetaVars/Mention.hs +++ b/src/full/Agda/TypeChecking/MetaVars/Mention.hs @@ -1,15 +1,21 @@ module Agda.TypeChecking.MetaVars.Mention where +import Data.HashSet (HashSet) +import qualified Data.HashSet as HashSet + import Agda.Syntax.Common import Agda.Syntax.Internal import Agda.TypeChecking.Monad class MentionsMeta t where - mentionsMeta :: MetaId -> t -> Bool + mentionsMetas :: HashSet MetaId -> t -> Bool +mentionsMeta :: MentionsMeta t => MetaId -> t -> Bool +mentionsMeta = mentionsMetas . HashSet.singleton + instance MentionsMeta Term where - mentionsMeta x v = case v of + mentionsMetas xs v = case v of Var _ args -> mm args Lam _ b -> mm b Lit{} -> False @@ -20,84 +26,83 @@ Level l -> mm l Dummy{} -> False DontCare v -> False -- we don't have to look inside don't cares when deciding to wake constraints - MetaV y args -> x == y || mm args -- TODO: we really only have to look one level deep at meta args + MetaV y args -> HashSet.member y xs || mm args -- TODO: we really only have to look one level deep at meta args where - mm v = mentionsMeta x v + mm v = mentionsMetas xs v instance MentionsMeta Level where - mentionsMeta x (Max as) = mentionsMeta x as + mentionsMetas xs (Max _ as) = mentionsMetas xs as instance MentionsMeta PlusLevel where - mentionsMeta x ClosedLevel{} = False - mentionsMeta x (Plus _ a) = mentionsMeta x a + mentionsMetas xs (Plus _ a) = mentionsMetas xs a instance MentionsMeta LevelAtom where - mentionsMeta x l = case l of - MetaLevel m vs -> x == m || mentionsMeta x vs - BlockedLevel m _ -> x == m -- if it's blocked on a different meta it doesn't matter if it mentions the meta somewhere else - UnreducedLevel l -> mentionsMeta x l - NeutralLevel _ l -> mentionsMeta x l + mentionsMetas xs l = case l of + MetaLevel m vs -> HashSet.member m xs || mentionsMetas xs vs + BlockedLevel m _ -> HashSet.member m xs -- if it's blocked on a different meta it doesn't matter if it mentions the meta somewhere else + UnreducedLevel l -> mentionsMetas xs l + NeutralLevel _ l -> mentionsMetas xs l instance MentionsMeta Type where - mentionsMeta x (El s t) = mentionsMeta x (s, t) + mentionsMetas xs (El s t) = mentionsMetas xs (s, t) instance MentionsMeta Sort where - mentionsMeta x s = case s of - Type l -> mentionsMeta x l - Prop l -> mentionsMeta x l + mentionsMetas xs s = case s of + Type l -> mentionsMetas xs l + Prop l -> mentionsMetas xs l Inf -> False SizeUniv -> False - PiSort s1 s2 -> mentionsMeta x (s1, s2) - UnivSort s -> mentionsMeta x s - MetaS m es -> x == m || mentionsMeta x es - DefS d es -> mentionsMeta x es + PiSort a s -> mentionsMetas xs (a, s) + FunSort s1 s2 -> mentionsMetas xs (s1, s2) + UnivSort s -> mentionsMetas xs s + MetaS m es -> HashSet.member m xs || mentionsMetas xs es + DefS d es -> mentionsMetas xs es DummyS{} -> False instance MentionsMeta t => MentionsMeta (Abs t) where - mentionsMeta x = mentionsMeta x . unAbs + mentionsMetas xs = mentionsMetas xs . unAbs instance MentionsMeta t => MentionsMeta (Arg t) where - mentionsMeta x a | isIrrelevant a = False + mentionsMetas xs a | isIrrelevant a = False -- ^ we don't have to look inside irrelevant arguments when deciding to wake constraints - mentionsMeta x a = mentionsMeta x (unArg a) + mentionsMetas xs a = mentionsMetas xs (unArg a) instance MentionsMeta t => MentionsMeta (Dom t) where - mentionsMeta x = mentionsMeta x . unDom + mentionsMetas xs = mentionsMetas xs . unDom instance MentionsMeta t => MentionsMeta [t] where - mentionsMeta x = any (mentionsMeta x) + mentionsMetas xs = any (mentionsMetas xs) instance MentionsMeta t => MentionsMeta (Maybe t) where - mentionsMeta x = maybe False (mentionsMeta x) + mentionsMetas xs = maybe False (mentionsMetas xs) instance (MentionsMeta a, MentionsMeta b) => MentionsMeta (a, b) where - mentionsMeta x (a, b) = mentionsMeta x a || mentionsMeta x b + mentionsMetas xs (a, b) = mentionsMetas xs a || mentionsMetas xs b instance (MentionsMeta a, MentionsMeta b, MentionsMeta c) => MentionsMeta (a, b, c) where - mentionsMeta x (a, b, c) = mentionsMeta x a || mentionsMeta x b || mentionsMeta x c + mentionsMetas xs (a, b, c) = mentionsMetas xs a || mentionsMetas xs b || mentionsMetas xs c instance MentionsMeta a => MentionsMeta (Closure a) where - mentionsMeta x cl = mentionsMeta x (clValue cl) + mentionsMetas xs cl = mentionsMetas xs (clValue cl) instance MentionsMeta Elim where - mentionsMeta x Proj{} = False - mentionsMeta x (Apply v) = mentionsMeta x v - mentionsMeta x (IApply y0 y1 v) = mentionsMeta x (y0,y1,v) + mentionsMetas xs Proj{} = False + mentionsMetas xs (Apply v) = mentionsMetas xs v + mentionsMetas xs (IApply y0 y1 v) = mentionsMetas xs (y0,y1,v) instance MentionsMeta a => MentionsMeta (Tele a) where - mentionsMeta x EmptyTel = False - mentionsMeta x (ExtendTel a b) = mentionsMeta x (a, b) + mentionsMetas xs EmptyTel = False + mentionsMetas xs (ExtendTel a b) = mentionsMetas xs (a, b) instance MentionsMeta ProblemConstraint where - mentionsMeta x = mentionsMeta x . theConstraint + mentionsMetas xs = mentionsMetas xs . theConstraint instance MentionsMeta Constraint where - mentionsMeta x c = case c of + mentionsMetas xs c = case c of ValueCmp _ t u v -> mm (t, u, v) ValueCmpOnFace _ p t u v -> mm ((p,t), u, v) ElimCmp _ _ t v as bs -> mm ((t, v), (as, bs)) LevelCmp _ u v -> mm (u, v) - TypeCmp _ a b -> mm (a, b) TelCmp a b _ u v -> mm ((a, b), (u, v)) SortCmp _ a b -> mm (a, b) Guarded{} -> False -- This gets woken up when the problem it's guarded by is solved @@ -110,9 +115,18 @@ CheckFunDef{} -> True -- not sure what metas this depends on HasBiggerSort a -> mm a HasPTSRule a b -> mm (a, b) - UnquoteTactic bl tac hole goal -> Just x == bl + UnquoteTactic bl tac hole goal -> case bl of + Nothing -> False + Just m -> HashSet.member m xs + CheckMetaInst m -> True -- TODO where - mm v = mentionsMeta x v + mm v = mentionsMetas xs v + +instance MentionsMeta CompareAs where + mentionsMetas xs = \case + AsTermsOf a -> mentionsMetas xs a + AsSizes -> False + AsTypes -> False -- instance (Ord k, MentionsMeta e) => MentionsMeta (Map k e) where -- mentionsMeta = traverse mentionsMeta diff --git a/src/full/Agda/TypeChecking/MetaVars/Occurs.hs b/src/full/Agda/TypeChecking/MetaVars/Occurs.hs --- a/src/full/Agda/TypeChecking/MetaVars/Occurs.hs +++ b/src/full/Agda/TypeChecking/MetaVars/Occurs.hs @@ -1,6 +1,6 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE NoMonomorphismRestriction #-} {-# LANGUAGE NondecreasingIndentation #-} +{-# LANGUAGE TypeFamilies #-} {-# LANGUAGE UndecidableInstances #-} {- | The occurs check for unification. Does pruning on the fly. @@ -19,12 +19,12 @@ import Control.Monad import Control.Monad.Reader -import Data.Foldable (foldMap) +import Data.Foldable (traverse_) +import Data.Functor import Data.Monoid import Data.Set (Set) import qualified Data.Set as Set import qualified Data.IntMap as IntMap -import Data.IntMap (IntMap) import qualified Data.IntSet as IntSet import Data.IntSet (IntSet) import Data.Traversable (traverse) @@ -34,12 +34,13 @@ import Agda.Syntax.Common import Agda.Syntax.Internal +import Agda.TypeChecking.Constraints () -- instances import Agda.TypeChecking.Monad -import Agda.TypeChecking.Monad.Builtin import qualified Agda.TypeChecking.Monad.Benchmark as Bench import Agda.TypeChecking.Reduce import Agda.TypeChecking.Pretty -import Agda.TypeChecking.Free hiding (Occurrence(..)) +import Agda.TypeChecking.Free +import Agda.TypeChecking.Free.Lazy import Agda.TypeChecking.Free.Reduce import Agda.TypeChecking.Substitute import Agda.TypeChecking.Datatypes @@ -62,9 +63,11 @@ import Agda.Utils.Pretty (prettyShow) import Agda.Utils.Size -#include "undefined.h" import Agda.Utils.Impossible +--------------------------------------------------------------------------- +-- * MetaOccursCheck: going into definitions to exclude cyclic solutions + {- To address issue 585 (meta var occurrences in mutual defs) data B : Set where @@ -132,138 +135,254 @@ -- | Remove a def from the list of defs to be looked at. tallyDef :: QName -> TCM () -tallyDef d = modifyOccursCheckDefs $ \ s -> Set.delete d s +tallyDef d = modifyOccursCheckDefs $ Set.delete d -data OccursCtx - = Flex -- ^ We are in arguments of a meta. - | Rigid -- ^ We are not in arguments of a meta but a bound var. - | StronglyRigid -- ^ We are at the start or in the arguments of a constructor. - | Irrel -- ^ We are in an irrelevant argument. - deriving (Eq, Show) +--------------------------------------------------------------------------- +-- * OccursM monad and its services -data UnfoldStrategy = YesUnfold | NoUnfold - deriving (Eq, Show) +-- | Extra environment for the occurs check. (Complements 'FreeEnv'.) +data OccursExtra = OccursExtra + { occUnfold :: UnfoldStrategy + , occVars :: VarMap -- ^ The allowed variables with their variance. + , occMeta :: MetaId -- ^ The meta we want to solve. + , occCxtSize :: Nat -- ^ The size of the typing context upon invocation. + } -defArgs :: UnfoldStrategy -> OccursCtx -> OccursCtx -defArgs NoUnfold _ = Flex -defArgs YesUnfold ctx = weakly ctx +type OccursCtx = FreeEnv' () OccursExtra AllowedVar +type OccursM = ReaderT OccursCtx TCM -unfold :: UnfoldStrategy -> Term -> TCM (Blocked Term) -unfold NoUnfold v = notBlocked <$> instantiate v -unfold YesUnfold v = reduceB v +-- ** Modality handling. --- | Leave the strongly rigid position. -weakly :: OccursCtx -> OccursCtx -weakly StronglyRigid = Rigid -weakly ctx = ctx +-- | The passed modality is the one of the current context. +type AllowedVar = Modality -> All -strongly :: OccursCtx -> OccursCtx -strongly Rigid = StronglyRigid -strongly ctx = ctx +instance IsVarSet () AllowedVar where + withVarOcc o f = f . composeModality (getModality o) -patternViolation' :: Int -> String -> TCM a -patternViolation' n err = do - reportSLn "tc.meta.occurs" n err - patternViolation +-- | Check whether a free variable is allowed in the context as +-- specified by the modality. +variableCheck :: VarMap -> Maybe Variable -> AllowedVar +variableCheck xs mi q = All $ + -- Bound variables are always allowed to occur: + caseMaybe mi True $ \ i -> + -- Free variables not listed in @xs@ are forbidden: + caseMaybe (lookupVarMap i xs) False $ \ o -> + -- For listed variables it holds: + -- The ascribed modality @o@ must be submodality of the + -- modality @q@ of the current context. + -- E.g. irrelevant variables (ascribed, lhs) can only + -- be used in irrelevant position (rhs). + getModality o `moreUsableModality` q -abort :: OccursCtx -> TypeError -> TCM a -abort StronglyRigid err = typeError err -- here, throw an uncatchable error (unsolvable constraint) -abort Flex err = patternViolation' 70 (show err) -- throws a PatternErr, which leads to delayed constraint -abort Rigid err = patternViolation' 70 (show err) -abort Irrel err = patternViolation' 70 (show err) +-- | Occurs check fails if a defined name is not available +-- since it was declared in irrelevant or erased context. +definitionCheck :: QName -> OccursM () +definitionCheck d = do + cxt <- ask + let irr = isIrrelevant cxt + er = hasQuantity0 cxt + m = occMeta $ feExtra cxt + -- Anything goes if we are both irrelevant and erased. + -- Otherwise, have to check the modality of the defined name. + unless (irr && er) $ do + dmod <- modalityOfConst d + unless (irr || usableRelevance dmod) $ do + reportSDoc "tc.meta.occurs" 35 $ hsep + [ "occursCheck: definition" + , prettyTCM d + , "has relevance" + , prettyTCM (getRelevance dmod) + ] + abort $ MetaIrrelevantSolution m $ Def d [] + unless (er || usableQuantity dmod) $ do + reportSDoc "tc.meta.occurs" 35 $ hsep + [ "occursCheck: definition" + , prettyTCM d + , "has quantity" + , prettyTCM (getQuantity dmod) + ] + abort $ MetaErasedSolution m $ Def d [] --- | Distinguish relevant, irrelevant and nonstrict variables in occurs check. -type Vars = ([Nat],[Nat],[Nat]) --- TODO: refactor this into an actual datatype +-- | Construct a test whether a de Bruijn index is allowed +-- or needs to be pruned. +allowedVars :: OccursM (Nat -> Bool) +allowedVars = do + -- @n@ is the number of binders we have stepped under. + n <- liftM2 (-) getContextSize (asks (occCxtSize . feExtra)) + xs <- IntMap.keysSet . theVarMap <$> asks (occVars . feExtra) + -- Bound variables are allowed, and those mentioned in occVars. + return $ \ i -> i < n || (i - n) `IntSet.member` xs -goIrrelevant :: Vars -> Vars -goIrrelevant (relVs, nonstrictVs, irrVs) = (irrVs ++ nonstrictVs ++ relVs, [], []) +-- ** Unfolding during occurs check. -goNonStrict :: Vars -> Vars -goNonStrict (relVs, nonstrictVs, irrVs) = (nonstrictVs ++ relVs, [], irrVs) +-- | Unfold definitions during occurs check? +-- This effectively runs the occurs check on the normal form. +data UnfoldStrategy = YesUnfold | NoUnfold + deriving (Eq, Show) -allowedVar :: Nat -> Vars -> Bool -allowedVar i (relVs, nonstrictVs, irrVs) = i `elem` relVs +defArgs :: OccursM a -> OccursM a +defArgs m = asks (occUnfold . feExtra) >>= \case + NoUnfold -> flexibly m + YesUnfold -> weakly m -takeRelevant :: Vars -> [Nat] -takeRelevant (relVs, nonstrictVs, irrVs) = relVs +unfoldB :: (Instantiate t, Reduce t) => t -> OccursM (Blocked t) +unfoldB v = do + unfold <- asks $ occUnfold . feExtra + rel <- asks feModality + case unfold of + YesUnfold | not (isIrrelevant rel) -> reduceB v + _ -> notBlocked <$> instantiate v -takeAll :: Vars -> [Nat] -takeAll (rel, nst, irr) = rel ++ nst ++ irr +unfold :: (Instantiate t, Reduce t) => t -> OccursM t +unfold v = asks (occUnfold . feExtra) >>= \case + NoUnfold -> instantiate v + YesUnfold -> reduce v -liftUnderAbs :: Vars -> Vars -liftUnderAbs (relVs, nonstrictVs, irrVs) = (0 : map (1+) relVs, map (+1) nonstrictVs, map (1+) irrVs) +-- ** Managing rigidiy during occurs check. +-- | Leave the strongly rigid position. +weakly :: OccursM a -> OccursM a +weakly = local $ over lensFlexRig $ composeFlexRig WeaklyRigid + +strongly :: OccursM a -> OccursM a +strongly = local $ over lensFlexRig $ \case + WeaklyRigid -> StronglyRigid + Unguarded -> StronglyRigid + ctx -> ctx + +flexibly :: OccursM a -> OccursM a +flexibly = local $ set lensFlexRig $ Flexible () + +-- ** Error throwing during occurs check. + +patternViolation' :: MonadTCM m => Int -> String -> m a +patternViolation' n err = liftTCM $ do + reportSLn "tc.meta.occurs" n err + patternViolation + +abort :: TypeError -> OccursM a +abort err = do + ctx <- ask + lift $ do + if | isIrrelevant ctx -> soft + | StronglyRigid <- ctx ^. lensFlexRig -> hard + | otherwise -> soft + where + hard = typeError err -- here, throw an uncatchable error (unsolvable constraint) + soft = patternViolation' 70 (show err) -- throws a PatternErr, which leads to delayed constraint + +--------------------------------------------------------------------------- +-- * Implementation of the occurs check. + -- | Extended occurs check. class Occurs t where - occurs :: UnfoldStrategy -> OccursCtx -> MetaId -> Vars -> t -> TCM t + occurs :: t -> OccursM t metaOccurs :: MetaId -> t -> TCM () -- raise exception if meta occurs in t + default occurs :: (Traversable f, Occurs a, f a ~ t) => t -> OccursM t + occurs = traverse occurs + + default metaOccurs :: (Foldable f, Occurs a, f a ~ t) => MetaId -> t -> TCM () + metaOccurs = traverse_ . metaOccurs + -- | When assigning @m xs := v@, check that @m@ does not occur in @v@ -- and that the free variables of @v@ are contained in @xs@. occursCheck :: (Occurs a, InstantiateFull a, PrettyTCM a) - => MetaId -> Vars -> a -> TCM a + => MetaId -> VarMap -> a -> TCM a occursCheck m xs v = Bench.billTo [ Bench.Typing, Bench.OccursCheck ] $ do mv <- lookupMeta m - let ctx = if isIrrelevant (getMetaRelevance mv) then Irrel else StronglyRigid + n <- getContextSize + reportSLn "tc.meta.occurs" 35 $ "occursCheck " ++ show m ++ " " ++ show xs + let initEnv unf = FreeEnv + { feExtra = OccursExtra + { occUnfold = unf + , occVars = xs + , occMeta = m + , occCxtSize = n + } + , feFlexRig = StronglyRigid -- ? Unguarded + , feModality = getMetaModality mv + , feSingleton = variableCheck xs + } initOccursCheck mv - -- TODO: Can we do this in a better way? - let redo m = m - -- First try without normalising the term - redo (occurs NoUnfold ctx m xs v) `catchError` \_ -> do - initOccursCheck mv - redo (occurs YesUnfold ctx m xs v) `catchError` \err -> case err of - -- Produce nicer error messages + nicerErrorMessage $ do + -- First try without normalising the term + (occurs v `runReaderT` initEnv NoUnfold) `catchError` \err -> do + -- If first run is inconclusive, try again with normalization + -- (unless metavariable is irrelevant, in which case the + -- constraint will anyway be dropped) + case err of + PatternErr{} | not (isIrrelevant $ getMetaModality mv) -> do + initOccursCheck mv + occurs v `runReaderT` initEnv YesUnfold + _ -> throwError err + + where + -- Produce nicer error messages + nicerErrorMessage :: TCM a -> TCM a + nicerErrorMessage f = f `catchError` \ err -> case err of TypeError _ cl -> case clValue cl of MetaOccursInItself{} -> - typeError . GenericError . show =<< + typeError . GenericDocError =<< fsep [ text ("Refuse to construct infinite term by instantiating " ++ prettyShow m ++ " to") , prettyTCM =<< instantiateFull v ] - MetaCannotDependOn _ _ i -> + MetaCannotDependOn _ i -> ifM (isSortMeta m `and2M` (not <$> hasUniversePolymorphism)) - ( typeError . GenericError . show =<< + ( typeError . GenericDocError =<< fsep [ text ("Cannot instantiate the metavariable " ++ prettyShow m ++ " to") , prettyTCM v , "since universe polymorphism is disabled" ] ) {- else -} - ( typeError . GenericError . show =<< + ( typeError . GenericDocError =<< fsep [ text ("Cannot instantiate the metavariable " ++ prettyShow m ++ " to solution") , prettyTCM v , "since it contains the variable" , enterClosure cl $ \_ -> prettyTCM (Var i []) - , text $ "which is not in scope of the metavariable or irrelevant in the metavariable but relevant in the solution" + , "which is not in scope of the metavariable" ] ) MetaIrrelevantSolution _ _ -> - typeError . GenericError . show =<< + typeError . GenericDocError =<< fsep [ text ("Cannot instantiate the metavariable " ++ prettyShow m ++ " to solution") , prettyTCM v - , "since (part of) the solution was created in an irrelevant context." + , "since (part of) the solution was created in an irrelevant context" ] + MetaErasedSolution _ _ -> + typeError . GenericDocError =<< + fsep [ text ("Cannot instantiate the metavariable " ++ prettyShow m ++ " to solution") + , prettyTCM v + , "since (part of) the solution was created in an erased context" + ] _ -> throwError err _ -> throwError err instance Occurs Term where - occurs red ctx m xs v = do - v <- unfold red v + occurs v = do + vb <- unfoldB v -- occurs' ctx $ ignoreBlocking v -- fails test/succeed/DontPruneBlocked - case v of - -- Don't fail on blocked terms or metas - NotBlocked _ v -> occurs' ctx v - -- Blocked _ v@MetaV{} -> occurs' ctx v -- does not help with issue 856 - Blocked _ v -> occurs' Flex v - where - occurs' ctx v = do + let flexIfBlocked = case vb of + -- Don't fail on blocked terms or metas + -- Blocked _ MetaV{} -> id -- does not help with issue #856 + Blocked{} -> flexibly + -- Re #3594, do not fail hard when Underapplied: + -- the occurrence could be computed away after eta expansion. + NotBlocked{blockingStatus = Underapplied} -> flexibly + NotBlocked{} -> id + v <- return $ ignoreBlocking vb + flexIfBlocked $ do + ctx <- ask + let m = occMeta . feExtra $ ctx reportSDoc "tc.meta.occurs" 45 $ - text ("occursCheck " ++ prettyShow m ++ " (" ++ show ctx ++ ") of ") <+> prettyTCM v + text ("occursCheck " ++ prettyShow m ++ " (" ++ show (feFlexRig ctx) ++ ") of ") <+> prettyTCM v reportSDoc "tc.meta.occurs" 70 $ nest 2 $ text $ show v case v of Var i es -> do - if (i `allowedVar` xs) then Var i <$> occ (weakly ctx) es else do + allowed <- getAll . ($ mempty) <$> variable i + if allowed then Var i <$> weakly (occurs es) else do -- if the offending variable is of singleton type, -- eta-expand it away reportSDoc "tc.meta.occurs" 35 $ "offending variable: " <+> prettyTCM (var i) @@ -275,27 +394,25 @@ -- cannot decide, blocked by meta-var Left mid -> patternViolation' 70 $ "Disallowed var " ++ show i ++ " not obviously singleton" -- not a singleton type - Right Nothing -> -- abort Rigid turns this error into PatternErr - abort (strongly ctx) $ MetaCannotDependOn m (takeRelevant xs) i + Right Nothing -> + -- #4480: Only hard fail if the variable is not in scope. Wrong modality/relevance + -- could potentially be salvaged by eta expansion. + ifM (($ i) <$> allowedVars) + (patternViolation' 70 $ "Disallowed var " ++ show i ++ " due to modality/relevance") + (strongly $ abort $ MetaCannotDependOn m i) -- is a singleton type with unique inhabitant sv Right (Just sv) -> return $ sv `applyE` es - Lam h f -> Lam h <$> occ ctx f - Level l -> Level <$> occ ctx l + Lam h f -> Lam h <$> occurs f + Level l -> Level <$> occurs l Lit l -> return v Dummy{} -> return v - DontCare v -> if ctx == Irrel then - dontCare <$> occurs red ctx m xs v - else - abort (strongly ctx) $ MetaIrrelevantSolution m v + DontCare v -> dontCare <$> do underRelevance Irrelevant $ occurs v Def d es -> do - drel <- relOfConst d - unless (usableRelevance drel || ctx == Irrel) $ do - reportSDoc "tc.meta.occurs" 35 $ text ("relevance of definition: " ++ show drel) - abort ctx $ MetaIrrelevantSolution m $ Def d [] - Def d <$> occDef d ctx es - Con c ci vs -> Con c ci <$> occ ctx vs -- if strongly rigid, remain so - Pi a b -> uncurry Pi <$> occ ctx (a,b) - Sort s -> Sort <$> occurs red ctx m (goNonStrict xs) s + definitionCheck d + Def d <$> occDef d es + Con c ci vs -> Con c ci <$> occurs vs -- if strongly rigid, remain so + Pi a b -> uncurry Pi <$> occurs (a,b) + Sort s -> Sort <$> do underRelevance NonStrict $ occurs s MetaV m' es -> do -- Check for loop -- don't fail hard on this, since we might still be on the top-level @@ -314,35 +431,36 @@ when (m == m') $ patternViolation' 50 $ "occursCheck failed: Found " ++ prettyShow m -- The arguments of a meta are in a flexible position - (MetaV m' <$> occurs red Flex m xs es) `catchError` \err -> do + (MetaV m' <$> do flexibly $ occurs es) `catchError` \ err -> do + ctx <- ask reportSDoc "tc.meta.kill" 25 $ vcat - [ text $ "error during flexible occurs check, we are " ++ show ctx + [ text $ "error during flexible occurs check, we are " ++ show (ctx ^. lensFlexRig) , text $ show err ] case err of -- On pattern violations try to remove offending -- flexible occurrences (if not already in a flexible context) - PatternErr{} | ctx /= Flex -> do + PatternErr{} | not (isFlexible ctx) -> do reportSLn "tc.meta.kill" 20 $ "oops, pattern violation for " ++ prettyShow m' -- Andreas, 2014-03-02, see issue 1070: -- Do not prune when meta is projected! caseMaybe (allApplyElims es) (throwError err) $ \ vs -> do - killResult <- prune m' vs (takeAll xs) + killResult <- lift . prune m' vs =<< allowedVars if (killResult == PrunedEverything) -- after successful pruning, restart occurs check - then occurs red ctx m xs =<< instantiate (MetaV m' es) + then occurs =<< instantiate (MetaV m' es) else throwError err _ -> throwError err where - occ ctx v = occurs red ctx m xs v -- a data or record type constructor propagates strong occurrences -- since e.g. x = List x is unsolvable - occDef d ctx vs = do - metaOccurs m d - ifM (isJust <$> isDataOrRecordType d) - {-then-} (occ ctx vs) - {-else-} (occ (defArgs red ctx) vs) + occDef d vs = do + m <- asks (occMeta . feExtra) + lift $ metaOccurs m d + ifM (liftTCM $ isJust <$> isDataOrRecordType d) + {-then-} (occurs vs) + {-else-} (defArgs $ occurs vs) metaOccurs m v = do v <- instantiate v @@ -361,7 +479,7 @@ | otherwise -> metaOccurs m vs instance Occurs QName where - occurs red ctx m xs d = __IMPOSSIBLE__ + occurs d = __IMPOSSIBLE__ metaOccurs m d = whenM (defNeedsChecking d) $ do tallyDef d @@ -376,7 +494,7 @@ -- constructors are also called up. instance Occurs Defn where - occurs red ctx m xs def = __IMPOSSIBLE__ + occurs def = __IMPOSSIBLE__ metaOccurs m Axiom{} = return () metaOccurs m DataOrRecSig{} = return () @@ -391,33 +509,29 @@ metaOccurs m GeneralizableVar{} = __IMPOSSIBLE__ instance Occurs Clause where - occurs red ctx m xs cl = __IMPOSSIBLE__ + occurs cl = __IMPOSSIBLE__ metaOccurs m = metaOccurs m . clauseBody instance Occurs Level where - occurs red ctx m xs (Max as) = Max <$> occurs red ctx m xs as + occurs (Max n as) = Max n <$> occurs as - metaOccurs m (Max as) = metaOccurs m as + metaOccurs m (Max _ as) = metaOccurs m as instance Occurs PlusLevel where - occurs red ctx m xs l@ClosedLevel{} = return l - occurs red ctx m xs (Plus n l) = Plus n <$> occurs red ctx m xs l - metaOccurs m ClosedLevel{} = return () - metaOccurs m (Plus n l) = metaOccurs m l + occurs (Plus n l) = Plus n <$> occurs l + metaOccurs m (Plus n l) = metaOccurs m l + instance Occurs LevelAtom where - occurs red ctx m xs l = do - l <- case red of - YesUnfold -> reduce l - NoUnfold -> instantiate l - case l of + occurs l = do + unfold l >>= \case MetaLevel m' args -> do - MetaV m' args <- occurs red ctx m xs (MetaV m' args) + MetaV m' args <- occurs (MetaV m' args) return $ MetaLevel m' args - NeutralLevel r v -> NeutralLevel r <$> occurs red ctx m xs v - BlockedLevel m' v -> BlockedLevel m' <$> occurs red Flex m xs v - UnreducedLevel v -> UnreducedLevel <$> occurs red ctx m xs v + NeutralLevel r v -> NeutralLevel r <$> occurs v + BlockedLevel m' v -> BlockedLevel m' <$> do flexibly $ occurs v + UnreducedLevel v -> UnreducedLevel <$> occurs v metaOccurs m l = do l <- instantiate l @@ -429,34 +543,37 @@ instance Occurs Type where - occurs red ctx m xs (El s v) = uncurry El <$> occurs red ctx m xs (s,v) + occurs (El s v) = uncurry El <$> occurs (s,v) metaOccurs m (El s v) = metaOccurs m (s,v) instance Occurs Sort where - occurs red ctx m xs s = do - s' <- case red of - YesUnfold -> reduce s - NoUnfold -> instantiate s - case s' of - PiSort s1 s2 -> uncurry PiSort <$> occurs red (weakly ctx) m xs (s1,s2) - Type a -> Type <$> occurs red ctx m xs a - Prop a -> Prop <$> occurs red ctx m xs a - Inf -> return s' - SizeUniv -> return s' - UnivSort s -> UnivSort <$> occurs red (weakly ctx) m xs s + occurs s = do + unfold s >>= \case + PiSort a s2 -> do + s1' <- flexibly $ occurs $ getSort a + a' <- (a $>) . El s1' <$> do flexibly $ occurs $ unEl $ unDom a + s2' <- mapAbstraction a' (flexibly . underBinder . occurs) s2 + return $ PiSort a' s2' + FunSort s1 s2 -> FunSort <$> flexibly (occurs s1) <*> flexibly (occurs s2) + Type a -> Type <$> occurs a + Prop a -> Prop <$> occurs a + s@Inf -> return s + s@SizeUniv -> return s + UnivSort s -> UnivSort <$> do flexibly $ occurs s MetaS x es -> do - MetaV x es <- occurs red ctx m xs (MetaV x es) + MetaV x es <- occurs (MetaV x es) return $ MetaS x es DefS x es -> do - Def x es <- occurs red ctx m xs (Def x es) + Def x es <- occurs (Def x es) return $ DefS x es DummyS{} -> return s metaOccurs m s = do s <- instantiate s case s of - PiSort s1 s2 -> metaOccurs m (s1,s2) + PiSort a s -> metaOccurs m (a,s) + FunSort s1 s2 -> metaOccurs m (s1,s2) Type a -> metaOccurs m a Prop a -> metaOccurs m a Inf -> return () @@ -467,59 +584,36 @@ DummyS{} -> return () instance Occurs a => Occurs (Elim' a) where - occurs red ctx m xs e@(Proj _ f) = do - frel <- relOfConst f - unless (usableRelevance frel || ctx == Irrel) $ do - reportSDoc "tc.meta.occurs" 35 $ text ("relevance of projection: " ++ show frel) - abort ctx $ MetaIrrelevantSolution m $ Def f [] - return e - occurs red ctx m xs (Apply a) = Apply <$> occurs red ctx m xs a - occurs red ctx m xs (IApply x y a) - = IApply <$> occurs red ctx m xs x - <*> occurs red ctx m xs y - <*> occurs red ctx m xs a + occurs e@(Proj _ f) = e <$ definitionCheck f + occurs (Apply a) = Apply <$> occurs a + occurs (IApply x y a) = IApply <$> occurs x <*> occurs y <*> occurs a metaOccurs m (Proj{} ) = return () metaOccurs m (Apply a) = metaOccurs m a metaOccurs m (IApply x y a) = metaOccurs m (x,(y,a)) instance (Occurs a, Subst t a) => Occurs (Abs a) where - occurs red ctx m xs b@(Abs s x) = Abs s <$> underAbstraction_ b (occurs red ctx m (liftUnderAbs xs)) - occurs red ctx m xs b@(NoAbs s x) = NoAbs s <$> occurs red ctx m xs x + occurs b@(Abs s _) = Abs s <$> do underAbstraction_ b $ underBinder . occurs + occurs (NoAbs s x) = NoAbs s <$> occurs x - metaOccurs m (Abs s x) = metaOccurs m x - metaOccurs m (NoAbs s x) = metaOccurs m x + metaOccurs m (Abs _ x) = metaOccurs m x + metaOccurs m (NoAbs _ x) = metaOccurs m x instance Occurs a => Occurs (Arg a) where - occurs red ctx m xs (Arg info x) | isIrrelevant info = Arg info <$> - occurs red Irrel m (goIrrelevant xs) x - occurs red ctx m xs (Arg info x) | isNonStrict info = Arg info <$> - occurs red ctx m (goNonStrict xs) x - occurs red ctx m xs (Arg info x) = Arg info <$> - occurs red ctx m xs x - - metaOccurs m a = metaOccurs m (unArg a) + occurs (Arg info v) = Arg info <$> do underModality info $ occurs v + metaOccurs m = metaOccurs m . unArg instance Occurs a => Occurs (Dom a) where - occurs red ctx m xs = traverse $ occurs red ctx m xs - metaOccurs m = metaOccurs m . unDom +instance Occurs a => Occurs [a] where +instance Occurs a => Occurs (Maybe a) where instance (Occurs a, Occurs b) => Occurs (a,b) where - occurs red ctx m xs (x,y) = (,) <$> occurs red ctx m xs x <*> occurs red ctx m xs y + occurs (x,y) = (,) <$> occurs x <*> occurs y metaOccurs m (x,y) = metaOccurs m x >> metaOccurs m y -instance Occurs a => Occurs [a] where - occurs red ctx m xs ys = mapM (occurs red ctx m xs) ys - - metaOccurs m ys = mapM_ (metaOccurs m) ys - -instance Occurs a => Occurs (Maybe a) where - occurs red ctx m mx my = traverse (occurs red ctx m mx) my - - metaOccurs m = maybe (return ()) (metaOccurs m) - --- * Getting rid of flexible occurrences +--------------------------------------------------------------------------- +-- * Pruning: getting rid of flexible occurrences. -- | @prune m' vs xs@ attempts to remove all arguments from @vs@ whose -- free variables are not contained in @xs@. @@ -530,7 +624,12 @@ -- If any of the meta args @vs@ is matchable, e.g., is a constructor term, -- we cannot prune, because the offending variables could be removed by -- reduction for a suitable instantiation of the meta variable. -prune :: MetaId -> Args -> [Nat] -> TCM PruneResult +prune + :: MonadMetaSolver m + => MetaId -- ^ Meta to prune. + -> Args -- ^ Arguments to meta variable. + -> (Nat -> Bool) -- ^ Test for allowed variable (de Bruijn index). + -> m PruneResult prune m' vs xs = do caseEitherM (runExceptT $ mapM (hasBadRigid xs) $ map unArg vs) (const $ return PrunedNothing) $ \ kills -> do @@ -538,7 +637,7 @@ [ "attempting kills" , nest 2 $ vcat [ "m' =" <+> pretty m' - , "xs =" <+> prettyList (map (prettyTCM . var) xs) + -- , "xs =" <+> prettyList (map (prettyTCM . var) xs) -- no longer printable , "vs =" <+> prettyList (map prettyTCM vs) , "kills =" <+> text (show kills) ] @@ -552,14 +651,18 @@ -- @hasBadRigid xs v = Nothing@ means that -- we cannot prune at all as one of the meta args is matchable. -- (See issue 1147.) -hasBadRigid :: [Nat] -> Term -> ExceptT () TCM Bool +hasBadRigid + :: (MonadReduce m, HasConstInfo m, MonadAddContext m) + => (Nat -> Bool) -- ^ Test for allowed variable (de Bruijn index). + -> Term -- ^ Argument of meta variable. + -> ExceptT () m Bool -- ^ Exception if argument is matchable. hasBadRigid xs t = do -- We fail if we encounter a matchable argument. let failure = throwError () - tb <- liftTCM $ reduceB t + tb <- reduceB t let t = ignoreBlocking tb case t of - Var x _ -> return $ notElem x xs + Var x _ -> return $ not $ xs x -- Issue 1153: A lambda has to be considered matchable. -- Lam _ v -> hasBadRigid (0 : map (+1) xs) (absBody v) Lam _ v -> failure @@ -568,18 +671,18 @@ -- match: data, record, Pi, levels, sorts -- Thus, their offending rigid variables are bad. v@(Def f es) -> ifNotM (isNeutral tb f es) failure $ {- else -} do - es `rigidVarsNotContainedIn` xs + lift $ es `rigidVarsNotContainedIn` xs -- Andreas, 2012-05-03: There is room for further improvement. -- We could also consider a defined f which is not blocked by a meta. - Pi a b -> (a,b) `rigidVarsNotContainedIn` xs - Level v -> v `rigidVarsNotContainedIn` xs - Sort s -> s `rigidVarsNotContainedIn` xs + Pi a b -> lift $ (a,b) `rigidVarsNotContainedIn` xs + Level v -> lift $ v `rigidVarsNotContainedIn` xs + Sort s -> lift $ s `rigidVarsNotContainedIn` xs -- Since constructors can be eliminated by pattern-matching, -- offending variables under a constructor could be removed by -- the right instantiation of the meta variable. -- Thus, they are not rigid. Con c _ es | Just args <- allApplyElims es -> do - ifM (liftTCM $ isEtaCon (conName c)) + ifM (isEtaCon (conName c)) -- in case of a record con, we can in principle prune -- (but not this argument; the meta could become a projection!) (and <$> mapM (hasBadRigid xs . unArg) args) -- not andM, we need to force the exceptions! @@ -591,12 +694,12 @@ -- | Check whether a term @Def f es@ is finally stuck. -- Currently, we give only a crude approximation. -isNeutral :: MonadTCM tcm => Blocked t -> QName -> Elims -> tcm Bool -isNeutral b f es = liftTCM $ do +isNeutral :: (HasConstInfo m) => Blocked t -> QName -> Elims -> m Bool +isNeutral b f es = do let yes = return True no = return False def <- getConstInfo f - if defMatchable def then no else do + if not (null $ defMatchable def) then no else do case theDef def of AbstractDefn{} -> yes Axiom{} -> yes @@ -613,11 +716,15 @@ -- occurs *definitely* in the term in a rigid position. -- Reduces the term successively to remove variables in dead subterms. -- This fixes issue 1386. -rigidVarsNotContainedIn :: (MonadTCM tcm, FoldRigid a) => a -> [Nat] -> tcm Bool -rigidVarsNotContainedIn v is = liftTCM $ do +rigidVarsNotContainedIn + :: (MonadReduce m, MonadAddContext m, MonadTCEnv m, MonadDebug m, AnyRigid a) + => a + -> (Nat -> Bool) -- ^ Test for allowed variable (de Bruijn index). + -> m Bool +rigidVarsNotContainedIn v is = do n0 <- getContextSize let -- allowed variables as de Bruijn levels - levels = Set.fromList $ map (n0-1 -) is + levels = is . (n0-1 -) -- test if index is forbidden by converting it to level test i = do n <- getContextSize @@ -625,107 +732,104 @@ let l = n-1 - i -- If l >= n0 then it is a bound variable and can be -- ignored. Otherwise, it has to be in the allowed levels. - forbidden = l < n0 && not (l `Set.member` levels) + forbidden = l < n0 && not (levels l) when forbidden $ reportSLn "tc.meta.kill" 20 $ "found forbidden de Bruijn level " ++ show l - return $ Any forbidden - getAny <$> foldRigid test v + return forbidden + anyRigid test v -- | Collect the *definitely* rigid variables in a monoid. -- We need to successively reduce the expression to do this. -class FoldRigid a where --- foldRigid :: (MonadTCM tcm, Monoid (tcm m)) => (Nat -> tcm m) -> a -> tcm m - foldRigid :: (Monoid (TCM m)) => (Nat -> TCM m) -> a -> TCM m +class AnyRigid a where + anyRigid :: (MonadReduce tcm, MonadAddContext tcm) + => (Nat -> tcm Bool) -> a -> tcm Bool -instance FoldRigid Term where - foldRigid f t = do - b <- liftTCM $ reduceB t +instance AnyRigid Term where + anyRigid f t = do + b <- reduceB t case ignoreBlocking b of -- Upon entry, we are in rigid position, thus, -- bound variables are rigid ones. - Var i es -> f i `mappend` fold es - Lam _ t -> fold t - Lit{} -> mempty + Var i es -> f i `or2M` anyRigid f es + Lam _ t -> anyRigid f t + Lit{} -> return False Def _ es -> case b of -- If the definition is blocked by a meta, its arguments -- may be in flexible positions. - Blocked{} -> mempty + Blocked{} -> return False -- If the definition is incomplete, arguments might disappear -- by reductions that come with more clauses, thus, these -- arguments are not rigid. - NotBlocked MissingClauses _ -> mempty + NotBlocked MissingClauses _ -> return False -- _ -> mempty -- breaks: ImproveInertRHS, Issue442, PruneRecord, PruningNonMillerPattern - _ -> fold es - Con _ _ ts -> fold ts - Pi a b -> fold (a,b) - Sort s -> fold s - Level l -> fold l - MetaV{} -> mempty - DontCare{} -> mempty - Dummy{} -> mempty - where fold = foldRigid f + _ -> anyRigid f es + Con _ _ ts -> anyRigid f ts + Pi a b -> anyRigid f (a,b) + Sort s -> anyRigid f s + Level l -> anyRigid f l + MetaV{} -> return False + DontCare{} -> return False + Dummy{} -> return False -instance FoldRigid Type where - foldRigid f (El s t) = foldRigid f (s,t) +instance AnyRigid Type where + anyRigid f (El s t) = anyRigid f (s,t) -instance FoldRigid Sort where - foldRigid f s = +instance AnyRigid Sort where + anyRigid f s = case s of - Type l -> fold l - Prop l -> fold l - Inf -> mempty - SizeUniv -> mempty - PiSort s1 s2 -> mempty - UnivSort s -> fold s - MetaS{} -> mempty - DefS{} -> mempty - DummyS{} -> mempty - where fold = foldRigid f + Type l -> anyRigid f l + Prop l -> anyRigid f l + Inf -> return False + SizeUniv -> return False + PiSort a s -> return False + FunSort s1 s2 -> return False + UnivSort s -> anyRigid f s + MetaS{} -> return False + DefS{} -> return False + DummyS{} -> return False -instance FoldRigid Level where - foldRigid f (Max ls) = foldRigid f ls +instance AnyRigid Level where + anyRigid f (Max _ ls) = anyRigid f ls -instance FoldRigid PlusLevel where - foldRigid f ClosedLevel{} = mempty - foldRigid f (Plus _ l) = foldRigid f l +instance AnyRigid PlusLevel where + anyRigid f (Plus _ l) = anyRigid f l -instance FoldRigid LevelAtom where - foldRigid f l = +instance AnyRigid LevelAtom where + anyRigid f l = case l of - MetaLevel{} -> mempty - NeutralLevel MissingClauses _ -> mempty - NeutralLevel _ l -> fold l - BlockedLevel _ l -> fold l - UnreducedLevel l -> fold l - where fold = foldRigid f + MetaLevel{} -> return False + NeutralLevel MissingClauses _ -> return False + NeutralLevel _ l -> anyRigid f l + BlockedLevel _ l -> anyRigid f l + UnreducedLevel l -> anyRigid f l -instance (Subst t a, FoldRigid a) => FoldRigid (Abs a) where - foldRigid f b = underAbstraction_ b $ foldRigid f +instance (Subst t a, AnyRigid a) => AnyRigid (Abs a) where + anyRigid f b = underAbstraction_ b $ anyRigid f -instance FoldRigid a => FoldRigid (Arg a) where - foldRigid f a = +instance AnyRigid a => AnyRigid (Arg a) where + anyRigid f a = case getRelevance a of -- Irrelevant arguments are definitionally equal to -- values, so the variables there are not considered -- "definitely rigid". - Irrelevant -> mempty - _ -> foldRigid f $ unArg a + Irrelevant -> return False + _ -> anyRigid f $ unArg a -instance FoldRigid a => FoldRigid (Dom a) where - foldRigid f dom = foldRigid f $ unDom dom +instance AnyRigid a => AnyRigid (Dom a) where + anyRigid f dom = anyRigid f $ unDom dom -instance FoldRigid a => FoldRigid (Elim' a) where - foldRigid f (Apply a) = foldRigid f a - foldRigid f (IApply x y a) = foldRigid f (x,(y,a)) - foldRigid f Proj{} = mempty +instance AnyRigid a => AnyRigid (Elim' a) where + anyRigid f (Apply a) = anyRigid f a + anyRigid f (IApply x y a) = anyRigid f (x,(y,a)) + anyRigid f Proj{} = return False -instance FoldRigid a => FoldRigid [a] where - foldRigid f = foldMap $ foldRigid f +instance AnyRigid a => AnyRigid [a] where + anyRigid f xs = anyM xs $ anyRigid f -instance (FoldRigid a, FoldRigid b) => FoldRigid (a,b) where - foldRigid f (a,b) = foldRigid f a `mappend` foldRigid f b +instance (AnyRigid a, AnyRigid b) => AnyRigid (a,b) where + anyRigid f (a,b) = anyRigid f a `or2M` anyRigid f b data PruneResult @@ -737,7 +841,7 @@ -- | @killArgs [k1,...,kn] X@ prunes argument @i@ from metavar @X@ if @ki==True@. -- Pruning is carried out whenever > 0 arguments can be pruned. -killArgs :: [Bool] -> MetaId -> TCM PruneResult +killArgs :: (MonadMetaSolver m) => [Bool] -> MetaId -> m PruneResult killArgs kills _ | not (or kills) = return NothingToPrune -- nothing to kill killArgs kills m = do @@ -752,7 +856,7 @@ dbg kills' a a' -- If there is any prunable argument, perform the pruning if not (any unArg kills') then return PrunedNothing else do - performKill kills' m a' + addContext tel $ performKill kills' m a' -- Only successful if all occurrences were killed -- Andreas, 2011-05-09 more precisely, check that at least -- the in 'kills' prescribed kills were carried out @@ -769,7 +873,7 @@ , nest 2 $ vcat [ "metavar =" <+> prettyTCM m , "kills =" <+> text (show kills) - , "kills' =" <+> text (show kills') + , "kills' =" <+> prettyList (map prettyTCM kills') , "oldType =" <+> prettyTCM a , "newType =" <+> prettyTCM a' ] @@ -780,7 +884,7 @@ -- Invariant: @k'i == True@ iff @ki == True@ and pruning the @i@th argument from -- type @b@ is possible without creating unbound variables. -- @t'@ is type @t@ after pruning all @k'i==True@. -killedType :: [(Dom (ArgName, Type), Bool)] -> Type -> TCM ([Arg Bool], Type) +killedType :: (MonadReduce m) => [(Dom (ArgName, Type), Bool)] -> Type -> m ([Arg Bool], Type) killedType args b = do -- Turn list of bools into an IntSet containing the variables we want to kill @@ -811,7 +915,7 @@ -- where Δ' ⊆ Δ (possibly reduced to remove dependencies, see #3177) -- ys ⊆ xs are the variables that were dropped from Δ -- B' = strengthen ys B - go :: [Dom (ArgName, Type)] -> IntSet -> Type -> TCM (IntSet, Type) + go :: (MonadReduce m) => [Dom (ArgName, Type)] -> IntSet -> Type -> m (IntSet, Type) go [] xs b | IntSet.null xs = return (xs, b) | otherwise = __IMPOSSIBLE__ go (arg : args) xs b -- go (Δ (x : A)) xs B, (x = deBruijn index 0) @@ -837,7 +941,7 @@ -- Shift back up to make it relative to Δ (x : A) again. return (up zs, b) -reallyNotFreeIn :: IntSet -> Type -> TCM (IntSet, Type) +reallyNotFreeIn :: (MonadReduce m) => IntSet -> Type -> m (IntSet, Type) reallyNotFreeIn xs a | IntSet.null xs = return (xs, a) -- Shortcut reallyNotFreeIn xs a = do let fvs = freeVars a @@ -859,11 +963,12 @@ -- | Instantiate a meta variable with a new one that only takes -- the arguments which are not pruneable. performKill - :: [Arg Bool] -- ^ Arguments to old meta var in left to right order + :: MonadMetaSolver m + => [Arg Bool] -- ^ Arguments to old meta var in left to right order -- with @Bool@ indicating whether they can be pruned. -> MetaId -- ^ The old meta var to receive pruning. -> Type -- ^ The pruned type of the new meta var. - -> TCM () + -> m () performKill kills m a = do mv <- lookupMeta m when (mvFrozen mv == Frozen) __IMPOSSIBLE__ @@ -874,10 +979,14 @@ -- (de Bruijn level order). let perm = Perm n [ i | (i, Arg _ False) <- zip [0..] kills ] + -- The permutation for the old meta might range over a prefix of the arguments + oldPerm = liftP (max 0 $ n - m) p + where p = mvPermutation mv + m = size p judg = case mvJudgement mv of - HasType{} -> HasType __IMPOSSIBLE__ a + HasType{ jComparison = cmp } -> HasType __IMPOSSIBLE__ cmp a IsSort{} -> IsSort __IMPOSSIBLE__ a - m' <- newMeta Instantiable (mvInfo mv) (mvPriority mv) perm judg + m' <- newMeta Instantiable (mvInfo mv) (mvPriority mv) (composeP perm oldPerm) judg -- Andreas, 2010-10-15 eta expand new meta variable if necessary etaExpandMetaSafe m' let -- Arguments to new meta (de Bruijn indices) @@ -895,7 +1004,7 @@ [ "actual killing" , nest 2 $ vcat [ "new meta:" <+> pretty m' - , "kills :" <+> text (show kills) + , "kills :" <+> prettyList_ (map (text . show . unArg) kills) , "inst :" <+> pretty m <+> ":=" <+> prettyTCM u ] ] diff --git a/src/full/Agda/TypeChecking/Monad.hs b/src/full/Agda/TypeChecking/Monad.hs --- a/src/full/Agda/TypeChecking/Monad.hs +++ b/src/full/Agda/TypeChecking/Monad.hs @@ -1,5 +1,6 @@ module Agda.TypeChecking.Monad ( module Agda.TypeChecking.Monad.Base + , module Agda.TypeChecking.Monad.Builtin , module Agda.TypeChecking.Monad.Closure , module Agda.TypeChecking.Monad.Constraints , module Agda.TypeChecking.Monad.Context @@ -19,6 +20,7 @@ ) where import Agda.TypeChecking.Monad.Base +import Agda.TypeChecking.Monad.Builtin import Agda.TypeChecking.Monad.Closure import Agda.TypeChecking.Monad.Constraints import Agda.TypeChecking.Monad.Context diff --git a/src/full/Agda/TypeChecking/Monad/Base.hs b/src/full/Agda/TypeChecking/Monad/Base.hs --- a/src/full/Agda/TypeChecking/Monad/Base.hs +++ b/src/full/Agda/TypeChecking/Monad/Base.hs @@ -1,3867 +1,4269 @@ -{-# LANGUAGE BangPatterns #-} -{-# LANGUAGE CPP #-} -{-# LANGUAGE DeriveDataTypeable #-} -{-# LANGUAGE GeneralizedNewtypeDeriving #-} - -module Agda.TypeChecking.Monad.Base where - -import Prelude hiding (null) - -import qualified Control.Concurrent as C -import qualified Control.Exception as E - -#if __GLASGOW_HASKELL__ >= 800 -import qualified Control.Monad.Fail as Fail -#endif - -import Control.Monad.State -import Control.Monad.Reader -import Control.Monad.Writer hiding ((<>)) -import Control.Monad.Trans.Maybe -import Control.Applicative hiding (empty) - -import Data.Function -import Data.Int -import Data.IntMap (IntMap) -import qualified Data.IntMap as IntMap -import qualified Data.List as List -import Data.Maybe -import Data.Map (Map) -import qualified Data.Map as Map -- hiding (singleton, null, empty) -import Data.Monoid ( Monoid, mempty, mappend ) -import Data.Sequence (Seq) -import Data.Set (Set) -import qualified Data.Set as Set -- hiding (singleton, null, empty) -import Data.Semigroup ( Semigroup, (<>), Any(..) ) -import Data.Data (Data, toConstr) -import Data.Foldable (Foldable) -import Data.String -import Data.Text.Lazy (Text) -import qualified Data.Text.Lazy as T -import Data.Traversable -import Data.IORef - -import qualified System.Console.Haskeline as Haskeline - -import Agda.Benchmarking (Benchmark, Phase) - -import Agda.Syntax.Concrete (TopLevelModuleName) -import Agda.Syntax.Common -import qualified Agda.Syntax.Concrete as C -import Agda.Syntax.Concrete.Definitions - (NiceDeclaration, DeclarationWarning, declarationWarningName) -import qualified Agda.Syntax.Abstract as A -import Agda.Syntax.Abstract (AllNames) -import Agda.Syntax.Internal as I -import Agda.Syntax.Internal.Pattern () -import Agda.Syntax.Internal.Generic (TermLike(..)) -import Agda.Syntax.Literal -import Agda.Syntax.Parser (PM(..), ParseWarning, runPMIO) -import Agda.Syntax.Parser.Monad (parseWarningName) -import Agda.Syntax.Treeless (Compiled) -import Agda.Syntax.Fixity -import Agda.Syntax.Position -import Agda.Syntax.Scope.Base -import qualified Agda.Syntax.Info as Info - -import Agda.TypeChecking.CompiledClause -import Agda.TypeChecking.Coverage.SplitTree -import Agda.TypeChecking.Positivity.Occurrence -import Agda.TypeChecking.Free.Lazy (Free(freeVars'), bind', bind) - -import Agda.Termination.CutOff - -import {-# SOURCE #-} Agda.Compiler.Backend - --- import {-# SOURCE #-} Agda.Interaction.FindFile -import Agda.Interaction.Options -import Agda.Interaction.Options.Warnings -import Agda.Interaction.Response - (InteractionOutputCallback, defaultInteractionOutputCallback, Response(..)) -import Agda.Interaction.Highlighting.Precise - (CompressedFile, HighlightingInfo) -import Agda.Interaction.Library - -import Agda.Utils.Except - ( Error(strMsg) - , ExceptT - , MonadError(catchError, throwError) - , runExceptT - , mapExceptT - ) - -import Agda.Utils.Benchmark (MonadBench(..)) -import Agda.Utils.FileName -import Agda.Utils.HashMap (HashMap) -import qualified Agda.Utils.HashMap as HMap -import Agda.Utils.Hash -import Agda.Utils.Lens -import Agda.Utils.List -import Agda.Utils.ListT -import Agda.Utils.Monad -import Agda.Utils.NonemptyList -import Agda.Utils.Null -import Agda.Utils.Permutation -import Agda.Utils.Pretty hiding ((<>)) -import qualified Agda.Utils.Pretty as P -import Agda.Utils.Singleton -import Agda.Utils.Functor -import Agda.Utils.Function -import Agda.Utils.WithDefault ( collapseDefault ) - -#include "undefined.h" -import Agda.Utils.Impossible - ---------------------------------------------------------------------------- --- * Type checking state ---------------------------------------------------------------------------- - -data TCState = TCSt - { stPreScopeState :: !PreScopeState - -- ^ The state which is frozen after scope checking. - , stPostScopeState :: !PostScopeState - -- ^ The state which is modified after scope checking. - , stPersistentState :: !PersistentTCState - -- ^ State which is forever, like a diamond. - } - -class Monad m => ReadTCState m where - getTCState :: m TCState - withTCState :: (TCState -> TCState) -> m a -> m a - -instance ReadTCState m => ReadTCState (MaybeT m) where - getTCState = lift getTCState - withTCState = mapMaybeT . withTCState - -instance ReadTCState m => ReadTCState (ListT m) where - getTCState = lift getTCState - withTCState f = ListT . withTCState f . runListT - -instance ReadTCState m => ReadTCState (ExceptT err m) where - getTCState = lift getTCState - withTCState = mapExceptT . withTCState - -instance ReadTCState m => ReadTCState (ReaderT r m) where - getTCState = lift getTCState - withTCState = mapReaderT . withTCState - -instance (Monoid w, ReadTCState m) => ReadTCState (WriterT w m) where - getTCState = lift getTCState - withTCState = mapWriterT . withTCState - -instance ReadTCState m => ReadTCState (StateT s m) where - getTCState = lift getTCState - withTCState = mapStateT . withTCState - -instance Show TCState where - show _ = "TCSt{}" - -data PreScopeState = PreScopeState - { stPreTokens :: !CompressedFile -- from lexer - -- ^ Highlighting info for tokens (but not those tokens for - -- which highlighting exists in 'stSyntaxInfo'). - , stPreImports :: !Signature -- XX populated by scopec hecker - -- ^ Imported declared identifiers. - -- Those most not be serialized! - , stPreImportedModules :: !(Set ModuleName) -- imports logic - , stPreModuleToSource :: !ModuleToSource -- imports - , stPreVisitedModules :: !VisitedModules -- imports - , stPreScope :: !ScopeInfo - -- generated by scope checker, current file: which modules you have, public definitions, current file, maps concrete names to abstract names. - , stPrePatternSyns :: !A.PatternSynDefns - -- ^ Pattern synonyms of the current file. Serialized. - , stPrePatternSynImports :: !A.PatternSynDefns - -- ^ Imported pattern synonyms. Must not be serialized! - , stPreGeneralizedVars :: !(Maybe (Set QName)) - -- ^ Collected generalizable variables; used during scope checking of terms - , stPrePragmaOptions :: !PragmaOptions - -- ^ Options applying to the current file. @OPTIONS@ - -- pragmas only affect this field. - , stPreImportedBuiltins :: !(BuiltinThings PrimFun) - , stPreImportedDisplayForms :: !DisplayForms - -- ^ Display forms added by someone else to imported identifiers - , stPreImportedInstanceDefs :: !InstanceTable - , stPreForeignCode :: !(Map BackendName [ForeignCode]) - -- ^ @{-\# FOREIGN \#-}@ code that should be included in the compiled output. - -- Does not include code for imported modules. - , stPreFreshInteractionId :: !InteractionId - , stPreImportedUserWarnings :: !(Map A.QName String) - -- ^ Imported @UserWarning@s, not to be stored in the @Interface@ - , stPreLocalUserWarnings :: !(Map A.QName String) - -- ^ Locally defined @UserWarning@s, to be stored in the @Interface@ - } - -type DisambiguatedNames = IntMap A.QName - -data PostScopeState = PostScopeState - { stPostSyntaxInfo :: !CompressedFile - -- ^ Highlighting info. - , stPostDisambiguatedNames :: !DisambiguatedNames - -- ^ Disambiguation carried out by the type checker. - -- Maps position of first name character to disambiguated @'A.QName'@ - -- for each @'A.AmbiguousQName'@ already passed by the type checker. - , stPostMetaStore :: !MetaStore - , stPostInteractionPoints :: !InteractionPoints -- scope checker first - , stPostAwakeConstraints :: !Constraints - , stPostSleepingConstraints :: !Constraints - , stPostDirty :: !Bool -- local - -- ^ Dirty when a constraint is added, used to prevent pointer update. - -- Currently unused. - , stPostOccursCheckDefs :: !(Set QName) -- local - -- ^ Definitions to be considered during occurs check. - -- Initialized to the current mutual block before the check. - -- During occurs check, we remove definitions from this set - -- as soon we have checked them. - , stPostSignature :: !Signature - -- ^ Declared identifiers of the current file. - -- These will be serialized after successful type checking. - , stPostModuleCheckpoints :: !(Map ModuleName CheckpointId) - -- ^ For each module remember the checkpoint corresponding to the orignal - -- context of the module parameters. - , stPostImportsDisplayForms :: !DisplayForms - -- ^ Display forms we add for imported identifiers - , stPostCurrentModule :: !(Maybe ModuleName) - -- ^ The current module is available after it has been type - -- checked. - , stPostInstanceDefs :: !TempInstanceTable - , stPostConcreteNames :: !(Map Name [C.Name]) - -- ^ Map keeping track of concrete names assigned to each abstract name - -- (can be more than one name in case the first one is shadowed) - , stPostShadowingNames :: !(Map Name [Name]) - -- ^ Map keeping track of which names could maybe be shadowed by - -- another name - , stPostStatistics :: !Statistics - -- ^ Counters to collect various statistics about meta variables etc. - -- Only for current file. - , stPostTCWarnings :: ![TCWarning] - , stPostMutualBlocks :: !(Map MutualId MutualBlock) - , stPostLocalBuiltins :: !(BuiltinThings PrimFun) - , stPostFreshMetaId :: !MetaId - , stPostFreshMutualId :: !MutualId - , stPostFreshProblemId :: !ProblemId - , stPostFreshCheckpointId :: !CheckpointId - , stPostFreshInt :: !Int - , stPostFreshNameId :: !NameId - , stPostAreWeCaching :: !Bool - , stPostConsideringInstance :: !Bool - } - --- | A mutual block of names in the signature. -data MutualBlock = MutualBlock - { mutualInfo :: Info.MutualInfo - -- ^ The original info of the mutual block. - , mutualNames :: Set QName - } deriving (Show, Eq) - -instance Null MutualBlock where - empty = MutualBlock empty empty - --- | A part of the state which is not reverted when an error is thrown --- or the state is reset. -data PersistentTCState = PersistentTCSt - { stDecodedModules :: DecodedModules - , stPersistentOptions :: CommandLineOptions - , stInteractionOutputCallback :: InteractionOutputCallback - -- ^ Callback function to call when there is a response - -- to give to the interactive frontend. - -- See the documentation of 'InteractionOutputCallback'. - , stBenchmark :: !Benchmark - -- ^ Structure to track how much CPU time was spent on which Agda phase. - -- Needs to be a strict field to avoid space leaks! - , stAccumStatistics :: !Statistics - -- ^ Should be strict field. - , stLoadedFileCache :: !(Maybe LoadedFileCache) - -- ^ Cached typechecking state from the last loaded file. - -- Should be Nothing when checking imports. - , stPersistBackends :: [Backend] - -- ^ Current backends with their options - } - -data LoadedFileCache = LoadedFileCache - { lfcCached :: !CachedTypeCheckLog - , lfcCurrent :: !CurrentTypeCheckLog - } - --- | A log of what the type checker does and states after the action is --- completed. The cached version is stored first executed action first. -type CachedTypeCheckLog = [(TypeCheckAction, PostScopeState)] - --- | Like 'CachedTypeCheckLog', but storing the log for an ongoing type --- checking of a module. Stored in reverse order (last performed action --- first). -type CurrentTypeCheckLog = [(TypeCheckAction, PostScopeState)] - --- | A complete log for a module will look like this: --- --- * 'Pragmas' --- --- * 'EnterSection', entering the main module. --- --- * 'Decl'/'EnterSection'/'LeaveSection', for declarations and nested --- modules --- --- * 'LeaveSection', leaving the main module. -data TypeCheckAction - = EnterSection !Info.ModuleInfo !ModuleName !A.Telescope - | LeaveSection !ModuleName - | Decl !A.Declaration - -- ^ Never a Section or ScopeDecl - | Pragmas !PragmaOptions - --- | Empty persistent state. - -initPersistentState :: PersistentTCState -initPersistentState = PersistentTCSt - { stPersistentOptions = defaultOptions - , stDecodedModules = Map.empty - , stInteractionOutputCallback = defaultInteractionOutputCallback - , stBenchmark = empty - , stAccumStatistics = Map.empty - , stLoadedFileCache = Nothing - , stPersistBackends = [] - } - --- | Empty state of type checker. - -initPreScopeState :: PreScopeState -initPreScopeState = PreScopeState - { stPreTokens = mempty - , stPreImports = emptySignature - , stPreImportedModules = Set.empty - , stPreModuleToSource = Map.empty - , stPreVisitedModules = Map.empty - , stPreScope = emptyScopeInfo - , stPrePatternSyns = Map.empty - , stPrePatternSynImports = Map.empty - , stPreGeneralizedVars = mempty - , stPrePragmaOptions = defaultInteractionOptions - , stPreImportedBuiltins = Map.empty - , stPreImportedDisplayForms = HMap.empty - , stPreImportedInstanceDefs = Map.empty - , stPreForeignCode = Map.empty - , stPreFreshInteractionId = 0 - , stPreImportedUserWarnings = Map.empty - , stPreLocalUserWarnings = Map.empty - } - -initPostScopeState :: PostScopeState -initPostScopeState = PostScopeState - { stPostSyntaxInfo = mempty - , stPostDisambiguatedNames = IntMap.empty - , stPostMetaStore = IntMap.empty - , stPostInteractionPoints = Map.empty - , stPostAwakeConstraints = [] - , stPostSleepingConstraints = [] - , stPostDirty = False - , stPostOccursCheckDefs = Set.empty - , stPostSignature = emptySignature - , stPostModuleCheckpoints = Map.empty - , stPostImportsDisplayForms = HMap.empty - , stPostCurrentModule = Nothing - , stPostInstanceDefs = (Map.empty , Set.empty) - , stPostConcreteNames = Map.empty - , stPostShadowingNames = Map.empty - , stPostStatistics = Map.empty - , stPostTCWarnings = [] - , stPostMutualBlocks = Map.empty - , stPostLocalBuiltins = Map.empty - , stPostFreshMetaId = 0 - , stPostFreshMutualId = 0 - , stPostFreshProblemId = 1 - , stPostFreshCheckpointId = 1 - , stPostFreshInt = 0 - , stPostFreshNameId = NameId 0 0 - , stPostAreWeCaching = False - , stPostConsideringInstance = False - } - -initState :: TCState -initState = TCSt - { stPreScopeState = initPreScopeState - , stPostScopeState = initPostScopeState - , stPersistentState = initPersistentState - } - --- * st-prefixed lenses ------------------------------------------------------------------------- - -stTokens :: Lens' CompressedFile TCState -stTokens f s = - f (stPreTokens (stPreScopeState s)) <&> - \x -> s {stPreScopeState = (stPreScopeState s) {stPreTokens = x}} - -stImports :: Lens' Signature TCState -stImports f s = - f (stPreImports (stPreScopeState s)) <&> - \x -> s {stPreScopeState = (stPreScopeState s) {stPreImports = x}} - -stImportedModules :: Lens' (Set ModuleName) TCState -stImportedModules f s = - f (stPreImportedModules (stPreScopeState s)) <&> - \x -> s {stPreScopeState = (stPreScopeState s) {stPreImportedModules = x}} - -stModuleToSource :: Lens' ModuleToSource TCState -stModuleToSource f s = - f (stPreModuleToSource (stPreScopeState s)) <&> - \x -> s {stPreScopeState = (stPreScopeState s) {stPreModuleToSource = x}} - -stVisitedModules :: Lens' VisitedModules TCState -stVisitedModules f s = - f (stPreVisitedModules (stPreScopeState s)) <&> - \x -> s {stPreScopeState = (stPreScopeState s) {stPreVisitedModules = x}} - -stScope :: Lens' ScopeInfo TCState -stScope f s = - f (stPreScope (stPreScopeState s)) <&> - \x -> s {stPreScopeState = (stPreScopeState s) {stPreScope = x}} - -stPatternSyns :: Lens' A.PatternSynDefns TCState -stPatternSyns f s = - f (stPrePatternSyns (stPreScopeState s)) <&> - \x -> s {stPreScopeState = (stPreScopeState s) {stPrePatternSyns = x}} - -stPatternSynImports :: Lens' A.PatternSynDefns TCState -stPatternSynImports f s = - f (stPrePatternSynImports (stPreScopeState s)) <&> - \x -> s {stPreScopeState = (stPreScopeState s) {stPrePatternSynImports = x}} - -stGeneralizedVars :: Lens' (Maybe (Set QName)) TCState -stGeneralizedVars f s = - f (stPreGeneralizedVars (stPreScopeState s)) <&> - \x -> s {stPreScopeState = (stPreScopeState s) {stPreGeneralizedVars = x}} - -stPragmaOptions :: Lens' PragmaOptions TCState -stPragmaOptions f s = - f (stPrePragmaOptions (stPreScopeState s)) <&> - \x -> s {stPreScopeState = (stPreScopeState s) {stPrePragmaOptions = x}} - -stImportedBuiltins :: Lens' (BuiltinThings PrimFun) TCState -stImportedBuiltins f s = - f (stPreImportedBuiltins (stPreScopeState s)) <&> - \x -> s {stPreScopeState = (stPreScopeState s) {stPreImportedBuiltins = x}} - -stForeignCode :: Lens' (Map BackendName [ForeignCode]) TCState -stForeignCode f s = - f (stPreForeignCode (stPreScopeState s)) <&> - \x -> s {stPreScopeState = (stPreScopeState s) {stPreForeignCode = x}} - -stFreshInteractionId :: Lens' InteractionId TCState -stFreshInteractionId f s = - f (stPreFreshInteractionId (stPreScopeState s)) <&> - \x -> s {stPreScopeState = (stPreScopeState s) {stPreFreshInteractionId = x}} - -stImportedUserWarnings :: Lens' (Map A.QName String) TCState -stImportedUserWarnings f s = - f (stPreImportedUserWarnings (stPreScopeState s)) <&> - \ x -> s {stPreScopeState = (stPreScopeState s) {stPreImportedUserWarnings = x}} - -stLocalUserWarnings :: Lens' (Map A.QName String) TCState -stLocalUserWarnings f s = - f (stPreLocalUserWarnings (stPreScopeState s)) <&> - \ x -> s {stPreScopeState = (stPreScopeState s) {stPreLocalUserWarnings = x}} - -getUserWarnings :: MonadTCState m => m (Map A.QName String) -getUserWarnings = do - iuw <- useTC stImportedUserWarnings - luw <- useTC stLocalUserWarnings - return $ iuw `Map.union` luw - -stBackends :: Lens' [Backend] TCState -stBackends f s = - f (stPersistBackends (stPersistentState s)) <&> - \x -> s {stPersistentState = (stPersistentState s) {stPersistBackends = x}} - -stFreshNameId :: Lens' NameId TCState -stFreshNameId f s = - f (stPostFreshNameId (stPostScopeState s)) <&> - \x -> s {stPostScopeState = (stPostScopeState s) {stPostFreshNameId = x}} - -stSyntaxInfo :: Lens' CompressedFile TCState -stSyntaxInfo f s = - f (stPostSyntaxInfo (stPostScopeState s)) <&> - \x -> s {stPostScopeState = (stPostScopeState s) {stPostSyntaxInfo = x}} - -stDisambiguatedNames :: Lens' DisambiguatedNames TCState -stDisambiguatedNames f s = - f (stPostDisambiguatedNames (stPostScopeState s)) <&> - \x -> s {stPostScopeState = (stPostScopeState s) {stPostDisambiguatedNames = x}} - -stMetaStore :: Lens' MetaStore TCState -stMetaStore f s = - f (stPostMetaStore (stPostScopeState s)) <&> - \x -> s {stPostScopeState = (stPostScopeState s) {stPostMetaStore = x}} - -stInteractionPoints :: Lens' InteractionPoints TCState -stInteractionPoints f s = - f (stPostInteractionPoints (stPostScopeState s)) <&> - \x -> s {stPostScopeState = (stPostScopeState s) {stPostInteractionPoints = x}} - -stAwakeConstraints :: Lens' Constraints TCState -stAwakeConstraints f s = - f (stPostAwakeConstraints (stPostScopeState s)) <&> - \x -> s {stPostScopeState = (stPostScopeState s) {stPostAwakeConstraints = x}} - -stSleepingConstraints :: Lens' Constraints TCState -stSleepingConstraints f s = - f (stPostSleepingConstraints (stPostScopeState s)) <&> - \x -> s {stPostScopeState = (stPostScopeState s) {stPostSleepingConstraints = x}} - -stDirty :: Lens' Bool TCState -stDirty f s = - f (stPostDirty (stPostScopeState s)) <&> - \x -> s {stPostScopeState = (stPostScopeState s) {stPostDirty = x}} - -stOccursCheckDefs :: Lens' (Set QName) TCState -stOccursCheckDefs f s = - f (stPostOccursCheckDefs (stPostScopeState s)) <&> - \x -> s {stPostScopeState = (stPostScopeState s) {stPostOccursCheckDefs = x}} - -stSignature :: Lens' Signature TCState -stSignature f s = - f (stPostSignature (stPostScopeState s)) <&> - \x -> s {stPostScopeState = (stPostScopeState s) {stPostSignature = x}} - -stModuleCheckpoints :: Lens' (Map ModuleName CheckpointId) TCState -stModuleCheckpoints f s = - f (stPostModuleCheckpoints (stPostScopeState s)) <&> - \x -> s {stPostScopeState = (stPostScopeState s) {stPostModuleCheckpoints = x}} - -stImportsDisplayForms :: Lens' DisplayForms TCState -stImportsDisplayForms f s = - f (stPostImportsDisplayForms (stPostScopeState s)) <&> - \x -> s {stPostScopeState = (stPostScopeState s) {stPostImportsDisplayForms = x}} - -stImportedDisplayForms :: Lens' DisplayForms TCState -stImportedDisplayForms f s = - f (stPreImportedDisplayForms (stPreScopeState s)) <&> - \x -> s {stPreScopeState = (stPreScopeState s) {stPreImportedDisplayForms = x}} - -stCurrentModule :: Lens' (Maybe ModuleName) TCState -stCurrentModule f s = - f (stPostCurrentModule (stPostScopeState s)) <&> - \x -> s {stPostScopeState = (stPostScopeState s) {stPostCurrentModule = x}} - -stImportedInstanceDefs :: Lens' InstanceTable TCState -stImportedInstanceDefs f s = - f (stPreImportedInstanceDefs (stPreScopeState s)) <&> - \x -> s {stPreScopeState = (stPreScopeState s) {stPreImportedInstanceDefs = x}} - -stInstanceDefs :: Lens' TempInstanceTable TCState -stInstanceDefs f s = - f (stPostInstanceDefs (stPostScopeState s)) <&> - \x -> s {stPostScopeState = (stPostScopeState s) {stPostInstanceDefs = x}} - -stConcreteNames :: Lens' (Map Name [C.Name]) TCState -stConcreteNames f s = - f (stPostConcreteNames (stPostScopeState s)) <&> - \x -> s {stPostScopeState = (stPostScopeState s) {stPostConcreteNames = x}} - -stShadowingNames :: Lens' (Map Name [Name]) TCState -stShadowingNames f s = - f (stPostShadowingNames (stPostScopeState s)) <&> - \x -> s {stPostScopeState = (stPostScopeState s) {stPostShadowingNames = x}} - -stStatistics :: Lens' Statistics TCState -stStatistics f s = - f (stPostStatistics (stPostScopeState s)) <&> - \x -> s {stPostScopeState = (stPostScopeState s) {stPostStatistics = x}} - -stTCWarnings :: Lens' [TCWarning] TCState -stTCWarnings f s = - f (stPostTCWarnings (stPostScopeState s)) <&> - \x -> s {stPostScopeState = (stPostScopeState s) {stPostTCWarnings = x}} - -stMutualBlocks :: Lens' (Map MutualId MutualBlock) TCState -stMutualBlocks f s = - f (stPostMutualBlocks (stPostScopeState s)) <&> - \x -> s {stPostScopeState = (stPostScopeState s) {stPostMutualBlocks = x}} - -stLocalBuiltins :: Lens' (BuiltinThings PrimFun) TCState -stLocalBuiltins f s = - f (stPostLocalBuiltins (stPostScopeState s)) <&> - \x -> s {stPostScopeState = (stPostScopeState s) {stPostLocalBuiltins = x}} - -stFreshMetaId :: Lens' MetaId TCState -stFreshMetaId f s = - f (stPostFreshMetaId (stPostScopeState s)) <&> - \x -> s {stPostScopeState = (stPostScopeState s) {stPostFreshMetaId = x}} - -stFreshMutualId :: Lens' MutualId TCState -stFreshMutualId f s = - f (stPostFreshMutualId (stPostScopeState s)) <&> - \x -> s {stPostScopeState = (stPostScopeState s) {stPostFreshMutualId = x}} - -stFreshProblemId :: Lens' ProblemId TCState -stFreshProblemId f s = - f (stPostFreshProblemId (stPostScopeState s)) <&> - \x -> s {stPostScopeState = (stPostScopeState s) {stPostFreshProblemId = x}} - -stFreshCheckpointId :: Lens' CheckpointId TCState -stFreshCheckpointId f s = - f (stPostFreshCheckpointId (stPostScopeState s)) <&> - \x -> s {stPostScopeState = (stPostScopeState s) {stPostFreshCheckpointId = x}} - -stFreshInt :: Lens' Int TCState -stFreshInt f s = - f (stPostFreshInt (stPostScopeState s)) <&> - \x -> s {stPostScopeState = (stPostScopeState s) {stPostFreshInt = x}} - --- use @areWeCaching@ from the Caching module instead. -stAreWeCaching :: Lens' Bool TCState -stAreWeCaching f s = - f (stPostAreWeCaching (stPostScopeState s)) <&> - \x -> s {stPostScopeState = (stPostScopeState s) {stPostAreWeCaching = x}} - -stConsideringInstance :: Lens' Bool TCState -stConsideringInstance f s = - f (stPostConsideringInstance (stPostScopeState s)) <&> - \x -> s {stPostScopeState = (stPostScopeState s) {stPostConsideringInstance = x}} - -stBuiltinThings :: TCState -> BuiltinThings PrimFun -stBuiltinThings s = (s^.stLocalBuiltins) `Map.union` (s^.stImportedBuiltins) - - --- * Fresh things ------------------------------------------------------------------------- - -class Enum i => HasFresh i where - freshLens :: Lens' i TCState - nextFresh' :: i -> i - nextFresh' = succ - -nextFresh :: HasFresh i => TCState -> (i, TCState) -nextFresh s = - let !c = s^.freshLens - in (c, set freshLens (nextFresh' c) s) - -fresh :: (HasFresh i, MonadTCState m) => m i -fresh = - do !s <- getTC - let (!c , !s') = nextFresh s - putTC s' - return c - -instance HasFresh MetaId where - freshLens = stFreshMetaId - -instance HasFresh MutualId where - freshLens = stFreshMutualId - -instance HasFresh InteractionId where - freshLens = stFreshInteractionId - -instance HasFresh NameId where - freshLens = stFreshNameId - -- nextFresh increments the current fresh name by 2 so @NameId@s used - -- before caching starts do not overlap with the ones used after. - nextFresh' = succ . succ - -instance HasFresh Int where - freshLens = stFreshInt - -newtype ProblemId = ProblemId Nat - deriving (Data, Eq, Ord, Enum, Real, Integral, Num) - --- TODO: 'Show' should output Haskell-parseable representations. --- The following instance is deprecated, and Pretty[TCM] should be used --- instead. Later, simply derive Show for this type. - --- ASR (28 December 2014). This instance is not used anymore (module --- the test suite) when reporting errors. See Issue 1293. - --- This particular Show instance is ok because of the Num instance. -instance Show ProblemId where - show (ProblemId n) = show n - -instance Pretty ProblemId where - pretty (ProblemId n) = pretty n - -instance HasFresh ProblemId where - freshLens = stFreshProblemId - -newtype CheckpointId = CheckpointId Int - deriving (Data, Eq, Ord, Enum, Real, Integral, Num) - -instance Show CheckpointId where - show (CheckpointId n) = show n - -instance Pretty CheckpointId where - pretty (CheckpointId n) = pretty n - -instance HasFresh CheckpointId where - freshLens = stFreshCheckpointId - -freshName :: MonadTCState m => Range -> String -> m Name -freshName r s = do - i <- fresh - return $ mkName r i s - -freshNoName :: MonadTCState m => Range -> m Name -freshNoName r = - do i <- fresh - return $ Name i (C.NoName noRange i) r noFixity' False - -freshNoName_ :: MonadTCState m => m Name -freshNoName_ = freshNoName noRange - -freshRecordName :: MonadTCState m => m Name -freshRecordName = do - i <- fresh - return $ Name i (C.Name noRange C.NotInScope [C.Id "r"]) noRange noFixity' True - --- | Create a fresh name from @a@. -class FreshName a where - freshName_ :: MonadTCState m => a -> m Name - -instance FreshName (Range, String) where - freshName_ = uncurry freshName - -instance FreshName String where - freshName_ = freshName noRange - -instance FreshName Range where - freshName_ = freshNoName - -instance FreshName () where - freshName_ () = freshNoName_ - ---------------------------------------------------------------------------- --- ** Managing file names ---------------------------------------------------------------------------- - --- | Maps top-level module names to the corresponding source file --- names. - -type ModuleToSource = Map TopLevelModuleName AbsolutePath - --- | Maps source file names to the corresponding top-level module --- names. - -type SourceToModule = Map AbsolutePath TopLevelModuleName - --- | Creates a 'SourceToModule' map based on 'stModuleToSource'. --- --- O(n log n). --- --- For a single reverse lookup in 'stModuleToSource', --- rather use 'lookupModuleFromSourse'. - -sourceToModule :: TCM SourceToModule -sourceToModule = - Map.fromList - . List.map (\(m, f) -> (f, m)) - . Map.toList - <$> useTC stModuleToSource - --- | Lookup an 'AbsolutePath' in 'sourceToModule'. --- --- O(n). - -lookupModuleFromSource :: AbsolutePath -> TCM (Maybe TopLevelModuleName) -lookupModuleFromSource f = - fmap fst . List.find ((f ==) . snd) . Map.toList <$> useTC stModuleToSource - ---------------------------------------------------------------------------- --- ** Interface ---------------------------------------------------------------------------- - -data ModuleInfo = ModuleInfo - { miInterface :: Interface - , miWarnings :: Bool - -- ^ 'True' if warnings were encountered when the module was type - -- checked. - , miPrimitive :: Bool - -- ^ 'True' if the module is a primitive module, which should always - -- be importable. - } - --- Note that the use of 'C.TopLevelModuleName' here is a potential --- performance problem, because these names do not contain unique --- identifiers. - -type VisitedModules = Map C.TopLevelModuleName ModuleInfo -type DecodedModules = Map C.TopLevelModuleName Interface - -data ForeignCode = ForeignCode Range String - deriving Show - -data Interface = Interface - { iSourceHash :: Hash - -- ^ Hash of the source code. - , iSource :: Text - -- ^ The source code. The source code is stored so that the HTML - -- and LaTeX backends can generate their output without having to - -- re-read the (possibly out of date) source code. - , iFileType :: FileType - -- ^ Source file type, determined from the file extension - , iImportedModules :: [(ModuleName, Hash)] - -- ^ Imported modules and their hashes. - , iModuleName :: ModuleName - -- ^ Module name of this interface. - , iScope :: Map ModuleName Scope - -- ^ Scope defined by this module. - -- - -- Andreas, AIM XX: Too avoid duplicate serialization, this field is - -- not serialized, so if you deserialize an interface, @iScope@ - -- will be empty. - -- But 'constructIScope' constructs 'iScope' from 'iInsideScope'. - , iInsideScope :: ScopeInfo - -- ^ Scope after we loaded this interface. - -- Used in 'Agda.Interaction.BasicOps.AtTopLevel' - -- and 'Agda.Interaction.CommandLine.interactionLoop'. - , iSignature :: Signature - , iDisplayForms :: DisplayForms - -- ^ Display forms added for imported identifiers. - , iUserWarnings :: Map A.QName String - -- ^ User warnings for imported identifiers - , iBuiltin :: BuiltinThings (String, QName) - , iForeignCode :: Map BackendName [ForeignCode] - , iHighlighting :: HighlightingInfo - , iPragmaOptions :: [OptionsPragma] - -- ^ Pragma options set in the file. - , iOptionsUsed :: PragmaOptions - -- ^ Options/features used when checking the file (can be different - -- from options set directly in the file). - , iPatternSyns :: A.PatternSynDefns - , iWarnings :: [TCWarning] - } - deriving Show - -instance Pretty Interface where - pretty (Interface - sourceH source fileT importedM moduleN scope insideS signature - display userwarn builtin foreignCode highlighting pragmaO - oUsed patternS warnings) = - hang "Interface" 2 $ vcat - [ "source hash:" <+> (pretty . show) sourceH - , "source:" $$ nest 2 (text $ T.unpack source) - , "file type:" <+> (pretty . show) fileT - , "imported modules:" <+> (pretty . show) importedM - , "module name:" <+> pretty moduleN - , "scope:" <+> (pretty . show) scope - , "inside scope:" <+> (pretty . show) insideS - , "signature:" <+> (pretty . show) signature - , "display:" <+> (pretty . show) display - , "user warnings:" <+> (pretty . show) userwarn - , "builtin:" <+> (pretty . show) builtin - , "Foreign code:" <+> (pretty . show) foreignCode - , "highlighting:" <+> (pretty . show) highlighting - , "pragma options:" <+> (pretty . show) pragmaO - , "options used:" <+> (pretty . show) oUsed - , "pattern syns:" <+> (pretty . show) patternS - , "warnings:" <+> (pretty . show) warnings - ] - --- | Combines the source hash and the (full) hashes of the imported modules. -iFullHash :: Interface -> Hash -iFullHash i = combineHashes $ iSourceHash i : List.map snd (iImportedModules i) - ---------------------------------------------------------------------------- --- ** Closure ---------------------------------------------------------------------------- - -data Closure a = Closure - { clSignature :: Signature - , clEnv :: TCEnv - , clScope :: ScopeInfo - , clModuleCheckpoints :: Map ModuleName CheckpointId - , clValue :: a - } - deriving (Data, Functor, Foldable) - -instance Show a => Show (Closure a) where - show cl = "Closure { clValue = " ++ show (clValue cl) ++ " }" - -instance HasRange a => HasRange (Closure a) where - getRange = getRange . clValue - -buildClosure :: a -> TCM (Closure a) -buildClosure x = do - env <- askTC - sig <- useTC stSignature - scope <- useTC stScope - cps <- useTC stModuleCheckpoints - return $ Closure sig env scope cps x - ---------------------------------------------------------------------------- --- ** Constraints ---------------------------------------------------------------------------- - -type Constraints = [ProblemConstraint] - -data ProblemConstraint = PConstr - { constraintProblems :: Set ProblemId - , theConstraint :: Closure Constraint - } - deriving (Data, Show) - -instance HasRange ProblemConstraint where - getRange = getRange . theConstraint - -data Constraint - = ValueCmp Comparison Type Term Term - | ValueCmpOnFace Comparison Term Type Term Term - | ElimCmp [Polarity] [IsForced] Type Term [Elim] [Elim] - | TypeCmp Comparison Type Type - | TelCmp Type Type Comparison Telescope Telescope -- ^ the two types are for the error message only - | SortCmp Comparison Sort Sort - | LevelCmp Comparison Level Level --- | ShortCut MetaId Term Type --- -- ^ A delayed instantiation. Replaces @ValueCmp@ in 'postponeTypeCheckingProblem'. - | HasBiggerSort Sort - | HasPTSRule Sort (Abs Sort) - | UnBlock MetaId - | Guarded Constraint ProblemId - | IsEmpty Range Type - -- ^ The range is the one of the absurd pattern. - | CheckSizeLtSat Term - -- ^ Check that the 'Term' is either not a SIZELT or a non-empty SIZELT. - | FindInstance MetaId (Maybe MetaId) (Maybe [Candidate]) - -- ^ the first argument is the instance argument, the second one is the meta - -- on which the constraint may be blocked on and the third one is the list - -- of candidates (or Nothing if we haven’t determined the list of - -- candidates yet) - | CheckFunDef Delayed Info.DefInfo QName [A.Clause] - | UnquoteTactic (Maybe MetaId) Term Term Type -- ^ First argument is computation and the others are hole and goal type - deriving (Data, Show) - -instance HasRange Constraint where - getRange (IsEmpty r t) = r - getRange _ = noRange -{- no Range instances for Term, Type, Elm, Tele, Sort, Level, MetaId - getRange (ValueCmp cmp a u v) = getRange (a,u,v) - getRange (ElimCmp pol a v es es') = getRange (a,v,es,es') - getRange (TypeCmp cmp a b) = getRange (a,b) - getRange (TelCmp a b cmp tel tel') = getRange (a,b,tel,tel') - getRange (SortCmp cmp s s') = getRange (s,s') - getRange (LevelCmp cmp l l') = getRange (l,l') - getRange (UnBlock x) = getRange x - getRange (Guarded c pid) = getRange c - getRange (FindInstance x cands) = getRange x --} - -instance Free Constraint where - freeVars' c = - case c of - ValueCmp _ t u v -> freeVars' (t, (u, v)) - ValueCmpOnFace _ p t u v -> freeVars' (p, (t, (u, v))) - ElimCmp _ _ t u es es' -> freeVars' ((t, u), (es, es')) - TypeCmp _ t t' -> freeVars' (t, t') - TelCmp _ _ _ tel tel' -> freeVars' (tel, tel') - SortCmp _ s s' -> freeVars' (s, s') - LevelCmp _ l l' -> freeVars' (l, l') - UnBlock _ -> mempty - Guarded c _ -> freeVars' c - IsEmpty _ t -> freeVars' t - CheckSizeLtSat u -> freeVars' u - FindInstance _ _ cs -> freeVars' cs - CheckFunDef _ _ _ _ -> mempty - HasBiggerSort s -> freeVars' s - HasPTSRule s1 s2 -> freeVars' (s1 , s2) - UnquoteTactic _ t h g -> freeVars' (t, (h, g)) - -instance TermLike Constraint where - foldTerm f = \case - ValueCmp _ t u v -> foldTerm f (t, u, v) - ValueCmpOnFace _ p t u v -> foldTerm f (p, t, u, v) - ElimCmp _ _ t u es es' -> foldTerm f (t, u, es, es') - TypeCmp _ t t' -> foldTerm f (t, t') - LevelCmp _ l l' -> foldTerm f (l, l') - IsEmpty _ t -> foldTerm f t - CheckSizeLtSat u -> foldTerm f u - UnquoteTactic _ t h g -> foldTerm f (t, h, g) - Guarded c _ -> foldTerm f c - TelCmp _ _ _ tel1 tel2 -> foldTerm f (tel1, tel2) - SortCmp _ s1 s2 -> foldTerm f (s1, s2) - UnBlock _ -> mempty - FindInstance _ _ _ -> mempty - CheckFunDef _ _ _ _ -> mempty - HasBiggerSort s -> foldTerm f s - HasPTSRule s1 s2 -> foldTerm f (s1, s2) - traverseTermM f c = __IMPOSSIBLE__ -- Not yet implemented - - -data Comparison = CmpEq | CmpLeq - deriving (Eq, Data, Show) - -instance Pretty Comparison where - pretty CmpEq = "=" - pretty CmpLeq = "=<" - --- | An extension of 'Comparison' to @>=@. -data CompareDirection = DirEq | DirLeq | DirGeq - deriving (Eq, Show) - -instance Pretty CompareDirection where - pretty = text . \case - DirEq -> "=" - DirLeq -> "=<" - DirGeq -> ">=" - --- | Embed 'Comparison' into 'CompareDirection'. -fromCmp :: Comparison -> CompareDirection -fromCmp CmpEq = DirEq -fromCmp CmpLeq = DirLeq - --- | Flip the direction of comparison. -flipCmp :: CompareDirection -> CompareDirection -flipCmp DirEq = DirEq -flipCmp DirLeq = DirGeq -flipCmp DirGeq = DirLeq - --- | Turn a 'Comparison' function into a 'CompareDirection' function. --- --- Property: @dirToCmp f (fromCmp cmp) = f cmp@ -dirToCmp :: (Comparison -> a -> a -> c) -> CompareDirection -> a -> a -> c -dirToCmp cont DirEq = cont CmpEq -dirToCmp cont DirLeq = cont CmpLeq -dirToCmp cont DirGeq = flip $ cont CmpLeq - ---------------------------------------------------------------------------- --- * Open things ---------------------------------------------------------------------------- - --- | A thing tagged with the context it came from. -data Open a = OpenThing { openThingCheckpoint :: CheckpointId, openThing :: a } - deriving (Data, Show, Functor, Foldable, Traversable) - -instance Decoration Open where - traverseF f (OpenThing cp x) = OpenThing cp <$> f x - ---------------------------------------------------------------------------- --- * Judgements --- --- Used exclusively for typing of meta variables. ---------------------------------------------------------------------------- - --- | Parametrized since it is used without MetaId when creating a new meta. -data Judgement a - = HasType { jMetaId :: a, jMetaType :: Type } - | IsSort { jMetaId :: a, jMetaType :: Type } -- Andreas, 2011-04-26: type needed for higher-order sort metas - -instance Show a => Show (Judgement a) where - show (HasType a t) = show a ++ " : " ++ show t - show (IsSort a t) = show a ++ " :sort " ++ show t - ------------------------------------------------------------------------------ --- ** Generalizable variables ------------------------------------------------------------------------------ - -data DoGeneralize = YesGeneralize | NoGeneralize - deriving (Eq, Ord, Show, Data) - --- | The value of a generalizable variable. This is created to be a --- generalizable meta before checking the type to be generalized. -data GeneralizedValue = GeneralizedValue - { genvalCheckpoint :: CheckpointId - , genvalTerm :: Term - , genvalType :: Type - } deriving (Show, Data) - ---------------------------------------------------------------------------- --- ** Meta variables ---------------------------------------------------------------------------- - -data MetaVariable = - MetaVar { mvInfo :: MetaInfo - , mvPriority :: MetaPriority -- ^ some metavariables are more eager to be instantiated - , mvPermutation :: Permutation - -- ^ a metavariable doesn't have to depend on all variables - -- in the context, this "permutation" will throw away the - -- ones it does not depend on - , mvJudgement :: Judgement MetaId - , mvInstantiation :: MetaInstantiation - , mvListeners :: Set Listener -- ^ meta variables scheduled for eta-expansion but blocked by this one - , mvFrozen :: Frozen -- ^ are we past the point where we can instantiate this meta variable? - } - -data Listener = EtaExpand MetaId - | CheckConstraint Nat ProblemConstraint - -instance Eq Listener where - EtaExpand x == EtaExpand y = x == y - CheckConstraint x _ == CheckConstraint y _ = x == y - _ == _ = False - -instance Ord Listener where - EtaExpand x `compare` EtaExpand y = x `compare` y - CheckConstraint x _ `compare` CheckConstraint y _ = x `compare` y - EtaExpand{} `compare` CheckConstraint{} = LT - CheckConstraint{} `compare` EtaExpand{} = GT - --- | Frozen meta variable cannot be instantiated by unification. --- This serves to prevent the completion of a definition by its use --- outside of the current block. --- (See issues 118, 288, 399). -data Frozen - = Frozen -- ^ Do not instantiate. - | Instantiable - deriving (Eq, Show) - -data MetaInstantiation - = InstV [Arg String] Term -- ^ solved by term (abstracted over some free variables) - | Open -- ^ unsolved - | OpenInstance -- ^ open, to be instantiated by instance search - | BlockedConst Term -- ^ solution blocked by unsolved constraints - | PostponedTypeCheckingProblem (Closure TypeCheckingProblem) (TCM Bool) - --- | Solving a 'CheckArgs' constraint may or may not check the target type. If --- it did, it returns a handle to any unsolved constraints. -data CheckedTarget = CheckedTarget (Maybe ProblemId) - | NotCheckedTarget - -data TypeCheckingProblem - = CheckExpr Comparison A.Expr Type - | CheckArgs ExpandHidden Range [NamedArg A.Expr] Type Type ([Maybe Range] -> Elims -> Type -> CheckedTarget -> TCM Term) - | CheckProjAppToKnownPrincipalArg Comparison A.Expr ProjOrigin (NonemptyList QName) A.Args Type Int Term Type - | CheckLambda Comparison (Arg ([WithHiding Name], Maybe Type)) A.Expr Type - -- ^ @(λ (xs : t₀) → e) : t@ - -- This is not an instance of 'CheckExpr' as the domain type - -- has already been checked. - -- For example, when checking - -- @(λ (x y : Fin _) → e) : (x : Fin n) → ?@ - -- we want to postpone @(λ (y : Fin n) → e) : ?@ where @Fin n@ - -- is a 'Type' rather than an 'A.Expr'. - | DoQuoteTerm Comparison Term Type -- ^ Quote the given term and check type against `Term` - -instance Show MetaInstantiation where - show (InstV tel t) = "InstV " ++ show tel ++ " (" ++ show t ++ ")" - show Open = "Open" - show OpenInstance = "OpenInstance" - show (BlockedConst t) = "BlockedConst (" ++ show t ++ ")" - show (PostponedTypeCheckingProblem{}) = "PostponedTypeCheckingProblem (...)" - --- | Meta variable priority: --- When we have an equation between meta-variables, which one --- should be instantiated? --- --- Higher value means higher priority to be instantiated. -newtype MetaPriority = MetaPriority Int - deriving (Eq , Ord , Show) - -data RunMetaOccursCheck - = RunMetaOccursCheck - | DontRunMetaOccursCheck - deriving (Eq , Ord , Show) - --- | @MetaInfo@ is cloned from one meta to the next during pruning. -data MetaInfo = MetaInfo - { miClosRange :: Closure Range -- TODO: Not so nice. But we want both to have the environment of the meta (Closure) and its range. --- , miRelevance :: Relevance -- ^ Created in irrelevant position? - , miMetaOccursCheck :: RunMetaOccursCheck -- ^ Run the extended occurs check that goes in definitions? - , miNameSuggestion :: MetaNameSuggestion - -- ^ Used for printing. - -- @Just x@ if meta-variable comes from omitted argument with name @x@. - , miGeneralizable :: Arg DoGeneralize - -- ^ Should this meta be generalized if unsolved? If so, at what ArgInfo? - } - --- | Name suggestion for meta variable. Empty string means no suggestion. -type MetaNameSuggestion = String - --- | For printing, we couple a meta with its name suggestion. -data NamedMeta = NamedMeta - { nmSuggestion :: MetaNameSuggestion - , nmid :: MetaId - } - -instance Pretty NamedMeta where - pretty (NamedMeta "" x) = pretty x - pretty (NamedMeta "_" x) = pretty x - pretty (NamedMeta s x) = text $ "_" ++ s ++ prettyShow x - -type MetaStore = IntMap MetaVariable - -instance HasRange MetaInfo where - getRange = clValue . miClosRange - -instance HasRange MetaVariable where - getRange m = getRange $ getMetaInfo m - -instance SetRange MetaInfo where - setRange r m = m { miClosRange = (miClosRange m) { clValue = r }} - -instance SetRange MetaVariable where - setRange r m = m { mvInfo = setRange r (mvInfo m) } - -normalMetaPriority :: MetaPriority -normalMetaPriority = MetaPriority 0 - -lowMetaPriority :: MetaPriority -lowMetaPriority = MetaPriority (-10) - -highMetaPriority :: MetaPriority -highMetaPriority = MetaPriority 10 - -getMetaInfo :: MetaVariable -> Closure Range -getMetaInfo = miClosRange . mvInfo - -getMetaScope :: MetaVariable -> ScopeInfo -getMetaScope m = clScope $ getMetaInfo m - -getMetaEnv :: MetaVariable -> TCEnv -getMetaEnv m = clEnv $ getMetaInfo m - -getMetaSig :: MetaVariable -> Signature -getMetaSig m = clSignature $ getMetaInfo m - -getMetaRelevance :: MetaVariable -> Relevance -getMetaRelevance = envRelevance . getMetaEnv - -getMetaModality :: MetaVariable -> Modality -getMetaModality = envModality . getMetaEnv - --- Lenses - -metaFrozen :: Lens' Frozen MetaVariable -metaFrozen f mv = f (mvFrozen mv) <&> \ x -> mv { mvFrozen = x } - ---------------------------------------------------------------------------- --- ** Interaction meta variables ---------------------------------------------------------------------------- - --- | Interaction points are created by the scope checker who sets the range. --- The meta variable is created by the type checker and then hooked up to the --- interaction point. -data InteractionPoint = InteractionPoint - { ipRange :: Range -- ^ The position of the interaction point. - , ipMeta :: Maybe MetaId -- ^ The meta variable, if any, holding the type etc. - , ipSolved:: Bool -- ^ Has this interaction point already been solved? - , ipClause:: IPClause - -- ^ The clause of the interaction point (if any). - -- Used for case splitting. - } - -instance Eq InteractionPoint where (==) = (==) `on` ipMeta - --- | Data structure managing the interaction points. --- --- We never remove interaction points from this map, only set their --- 'ipSolved' to @True@. (Issue #2368) -type InteractionPoints = Map InteractionId InteractionPoint - --- | Which clause is an interaction point located in? -data IPClause = IPClause - { ipcQName :: QName -- ^ The name of the function. - , ipcClauseNo :: Int -- ^ The number of the clause of this function. - , ipcClause :: A.RHS -- ^ The original AST clause rhs. - } - | IPNoClause -- ^ The interaction point is not in the rhs of a clause. - deriving Data - -instance Eq IPClause where - IPNoClause == IPNoClause = True - IPClause x i _ == IPClause x' i' _ = x == x' && i == i' - _ == _ = False - ---------------------------------------------------------------------------- --- ** Signature ---------------------------------------------------------------------------- - -data Signature = Sig - { _sigSections :: Sections - , _sigDefinitions :: Definitions - , _sigRewriteRules:: RewriteRuleMap -- ^ The rewrite rules defined in this file. - } - deriving (Data, Show) - -sigSections :: Lens' Sections Signature -sigSections f s = - f (_sigSections s) <&> - \x -> s {_sigSections = x} - -sigDefinitions :: Lens' Definitions Signature -sigDefinitions f s = - f (_sigDefinitions s) <&> - \x -> s {_sigDefinitions = x} - -sigRewriteRules :: Lens' RewriteRuleMap Signature -sigRewriteRules f s = - f (_sigRewriteRules s) <&> - \x -> s {_sigRewriteRules = x} - -type Sections = Map ModuleName Section -type Definitions = HashMap QName Definition -type RewriteRuleMap = HashMap QName RewriteRules -type DisplayForms = HashMap QName [LocalDisplayForm] - -newtype Section = Section { _secTelescope :: Telescope } - deriving (Data, Show) - -instance Pretty Section where - pretty = pretty . _secTelescope - -secTelescope :: Lens' Telescope Section -secTelescope f s = - f (_secTelescope s) <&> - \x -> s {_secTelescope = x} - -emptySignature :: Signature -emptySignature = Sig Map.empty HMap.empty HMap.empty - --- | A @DisplayForm@ is in essence a rewrite rule --- @ --- q ts --> dt --- @ --- for a defined symbol (could be a constructor as well) @q@. --- The right hand side is a 'DisplayTerm' which is used to --- 'reify' to a more readable 'Abstract.Syntax'. --- --- The patterns @ts@ are just terms, but @var 0@ is interpreted --- as a hole. Each occurrence of @var 0@ is a new hole (pattern var). --- For each *occurrence* of @var0@ the rhs @dt@ has a free variable. --- These are instantiated when matching a display form against a --- term @q vs@ succeeds. -data DisplayForm = Display - { dfFreeVars :: Nat - -- ^ Number @n@ of free variables in 'dfRHS'. - , dfPats :: Elims - -- ^ Left hand side patterns, where @var 0@ stands for a pattern - -- variable. There should be @n@ occurrences of @var0@ in - -- 'dfPats'. - -- The 'ArgInfo' is ignored in these patterns. - , dfRHS :: DisplayTerm - -- ^ Right hand side, with @n@ free variables. - } - deriving (Data, Show) - -type LocalDisplayForm = Open DisplayForm - --- | A structured presentation of a 'Term' for reification into --- 'Abstract.Syntax'. -data DisplayTerm - = DWithApp DisplayTerm [DisplayTerm] Elims - -- ^ @(f vs | ws) es@. - -- The first 'DisplayTerm' is the parent function @f@ with its args @vs@. - -- The list of 'DisplayTerm's are the with expressions @ws@. - -- The 'Elims' are additional arguments @es@ - -- (possible in case the with-application is of function type) - -- or projections (if it is of record type). - | DCon ConHead ConInfo [Arg DisplayTerm] - -- ^ @c vs@. - | DDef QName [Elim' DisplayTerm] - -- ^ @d vs@. - | DDot Term - -- ^ @.v@. - | DTerm Term - -- ^ @v@. - deriving (Data, Show) - -instance Free DisplayForm where - freeVars' (Display n ps t) = bind (freeVars' ps) `mappend` bind' n (freeVars' t) - -instance Free DisplayTerm where - freeVars' (DWithApp t ws es) = freeVars' (t, (ws, es)) - freeVars' (DCon _ _ vs) = freeVars' vs - freeVars' (DDef _ es) = freeVars' es - freeVars' (DDot v) = freeVars' v - freeVars' (DTerm v) = freeVars' v - -instance Pretty DisplayTerm where - prettyPrec p v = - case v of - DTerm v -> prettyPrec p v - DDot v -> "." P.<> prettyPrec 10 v - DDef f es -> pretty f `pApp` es - DCon c _ vs -> pretty (conName c) `pApp` map Apply vs - DWithApp h ws es -> - mparens (p > 0) - (sep [ pretty h - , nest 2 $ fsep [ "|" <+> pretty w | w <- ws ] ]) - `pApp` es - where - pApp d els = mparens (not (null els) && p > 9) $ - sep [d, nest 2 $ fsep (map (prettyPrec 10) els)] - --- | By default, we have no display form. -defaultDisplayForm :: QName -> [LocalDisplayForm] -defaultDisplayForm c = [] - -defRelevance :: Definition -> Relevance -defRelevance = getRelevance . defArgInfo - --- | Non-linear (non-constructor) first-order pattern. -data NLPat - = PVar !Int [Arg Int] - -- ^ Matches anything (modulo non-linearity) that only contains bound - -- variables that occur in the given arguments. - | PWild - -- ^ Matches anything (e.g. irrelevant terms). - | PDef QName PElims - -- ^ Matches @f es@ - | PLam ArgInfo (Abs NLPat) - -- ^ Matches @λ x → t@ - | PPi (Dom NLPType) (Abs NLPType) - -- ^ Matches @(x : A) → B@ - | PBoundVar {-# UNPACK #-} !Int PElims - -- ^ Matches @x es@ where x is a lambda-bound variable - | PTerm Term - -- ^ Matches the term modulo β (ideally βη). - deriving (Data, Show) -type PElims = [Elim' NLPat] - -data NLPType = NLPType - { nlpTypeLevel :: NLPat -- always PWild or PVar (with all bound variables in scope) - , nlpTypeUnEl :: NLPat - } deriving (Data, Show) - -type RewriteRules = [RewriteRule] - --- | Rewrite rules can be added independently from function clauses. -data RewriteRule = RewriteRule - { rewName :: QName -- ^ Name of rewrite rule @q : Γ → f ps ≡ rhs@ - -- where @≡@ is the rewrite relation. - , rewContext :: Telescope -- ^ @Γ@. - , rewHead :: QName -- ^ @f@. - , rewPats :: PElims -- ^ @Γ ⊢ f ps : t@. - , rewRHS :: Term -- ^ @Γ ⊢ rhs : t@. - , rewType :: Type -- ^ @Γ ⊢ t@. - } - deriving (Data, Show) - -data Definition = Defn - { defArgInfo :: ArgInfo -- ^ Hiding should not be used. - , defName :: QName - , defType :: Type -- ^ Type of the lifted definition. - , defPolarity :: [Polarity] - -- ^ Variance information on arguments of the definition. - -- Does not include info for dropped parameters to - -- projection(-like) functions and constructors. - , defArgOccurrences :: [Occurrence] - -- ^ Positivity information on arguments of the definition. - -- Does not include info for dropped parameters to - -- projection(-like) functions and constructors. - - -- Sometimes Agda looks up 'Occurrence's in these lists based on - -- their position, so one might consider replacing the list - -- with, say, an 'IntMap'. However, presumably these lists tend - -- to be short, in which case 'IntMap's could be slower than - -- lists. For instance, at one point the longest list - -- encountered for the standard library (in serialised - -- interfaces) had length 27. Distribution: - -- - -- Length, number of lists - -- ----------------------- - -- - -- 0, 2444 - -- 1, 721 - -- 2, 433 - -- 3, 668 - -- 4, 602 - -- 5, 624 - -- 6, 626 - -- 7, 484 - -- 8, 375 - -- 9, 264 - -- 10, 305 - -- 11, 188 - -- 12, 171 - -- 13, 108 - -- 14, 84 - -- 15, 80 - -- 16, 38 - -- 17, 23 - -- 18, 16 - -- 19, 8 - -- 20, 7 - -- 21, 5 - -- 22, 2 - -- 23, 3 - -- 27, 1 - - , defArgGeneralizable :: NumGeneralizableArgs - -- ^ How many arguments should be generalised. - , defGeneralizedParams :: [Maybe Name] - -- ^ Gives the name of the (bound variable) parameter for named generalized - -- parameters. This is needed to bring it into scope when type checking - -- the data/record definition corresponding to a type with generalized - -- parameters. - , defDisplay :: [LocalDisplayForm] - , defMutual :: MutualId - , defCompiledRep :: CompiledRepresentation - , defInstance :: Maybe QName - -- ^ @Just q@ when this definition is an instance of class q - , defCopy :: Bool - -- ^ Has this function been created by a module - -- instantiation? - , defMatchable :: Bool - -- ^ Is the def matched against in a rewrite rule? - , defNoCompilation :: Bool - -- ^ should compilers skip this? Used for e.g. cubical's comp - , defInjective :: Bool - -- ^ Should the def be treated as injective by the pattern matching unifier? - , theDef :: Defn - } - deriving (Data, Show) - -data NumGeneralizableArgs - = NoGeneralizableArgs - | SomeGeneralizableArgs Int - -- ^ When lambda-lifting new args are generalizable if - -- 'SomeGeneralizableArgs', also when the number is zero. - deriving (Data, Show) - -theDefLens :: Lens' Defn Definition -theDefLens f d = f (theDef d) <&> \ df -> d { theDef = df } - --- | Create a definition with sensible defaults. -defaultDefn :: ArgInfo -> QName -> Type -> Defn -> Definition -defaultDefn info x t def = Defn - { defArgInfo = info - , defName = x - , defType = t - , defPolarity = [] - , defArgOccurrences = [] - , defArgGeneralizable = NoGeneralizableArgs - , defGeneralizedParams = [] - , defDisplay = defaultDisplayForm x - , defMutual = 0 - , defCompiledRep = noCompiledRep - , defInstance = Nothing - , defCopy = False - , defMatchable = False - , defNoCompilation = False - , defInjective = False - , theDef = def - } - --- | Polarity for equality and subtype checking. -data Polarity - = Covariant -- ^ monotone - | Contravariant -- ^ antitone - | Invariant -- ^ no information (mixed variance) - | Nonvariant -- ^ constant - deriving (Data, Show, Eq) - -instance Pretty Polarity where - pretty = text . \case - Covariant -> "+" - Contravariant -> "-" - Invariant -> "*" - Nonvariant -> "_" - --- | Information about whether an argument is forced by the type of a function. -data IsForced - = Forced - | NotForced - deriving (Data, Show, Eq) - --- | The backends are responsible for parsing their own pragmas. -data CompilerPragma = CompilerPragma Range String - deriving (Data, Show, Eq) - -instance HasRange CompilerPragma where - getRange (CompilerPragma r _) = r - -type BackendName = String - -jsBackendName, ghcBackendName :: BackendName -jsBackendName = "JS" -ghcBackendName = "GHC" - -type CompiledRepresentation = Map BackendName [CompilerPragma] - -noCompiledRep :: CompiledRepresentation -noCompiledRep = Map.empty - --- A face represented as a list of equality constraints. --- (r,False) ↦ (r = i0) --- (r,True ) ↦ (r = i1) -type Face = [(Term,Bool)] - --- | An alternative representation of partial elements in a telescope: --- Γ ⊢ λ Δ. [φ₁ u₁, ... , φₙ uₙ] : Δ → PartialP (∨_ᵢ φᵢ) T --- see cubicaltt paper (however we do not store the type T). -data System = System - { systemTel :: Telescope - -- ^ the telescope Δ, binding vars for the clauses, Γ ⊢ Δ - , systemClauses :: [(Face,Term)] - -- ^ a system [φ₁ u₁, ... , φₙ uₙ] where Γ, Δ ⊢ φᵢ and Γ, Δ, φᵢ ⊢ uᵢ - } deriving (Data, Show) - --- | Additional information for extended lambdas. -data ExtLamInfo = ExtLamInfo - { extLamModule :: ModuleName - -- ^ For complicated reasons the scope checker decides the QName of a - -- pattern lambda, and thus its module. We really need to decide the - -- module during type checking though, since if the lambda appears in a - -- refined context the module picked by the scope checker has very much - -- the wrong parameters. - , extLamSys :: !(Maybe System) - } deriving (Data, Show) - -modifySystem :: (System -> System) -> ExtLamInfo -> ExtLamInfo -modifySystem f e = let !e' = e { extLamSys = f <$> extLamSys e } in e' - --- | Additional information for projection 'Function's. -data Projection = Projection - { projProper :: Maybe QName - -- ^ @Nothing@ if only projection-like, @Just r@ if record projection. - -- The @r@ is the name of the record type projected from. - -- This field is updated by module application. - , projOrig :: QName - -- ^ The original projection name - -- (current name could be from module application). - , projFromType :: Arg QName - -- ^ Type projected from. Original record type if @projProper = Just{}@. - -- Also stores @ArgInfo@ of the principal argument. - -- This field is unchanged by module application. - , projIndex :: Int - -- ^ Index of the record argument. - -- Start counting with 1, because 0 means that - -- it is already applied to the record value. - -- This can happen in module instantiation, but - -- then either the record value is @var 0@, or @funProjection == Nothing@. - , projLams :: ProjLams - -- ^ Term @t@ to be be applied to record parameters and record value. - -- The parameters will be dropped. - -- In case of a proper projection, a postfix projection application - -- will be created: @t = \ pars r -> r .p@ - -- (Invariant: the number of abstractions equals 'projIndex'.) - -- In case of a projection-like function, just the function symbol - -- is returned as 'Def': @t = \ pars -> f@. - } deriving (Data, Show) - --- | Abstractions to build projection function (dropping parameters). -newtype ProjLams = ProjLams { getProjLams :: [Arg ArgName] } - deriving (Data, Show, Null) - --- | Building the projection function (which drops the parameters). -projDropPars :: Projection -> ProjOrigin -> Term --- Proper projections: -projDropPars (Projection Just{} d _ _ lams) o = - case initLast $ getProjLams lams of - Nothing -> Def d [] - Just (pars, Arg i y) -> - let core = Lam i $ Abs y $ Var 0 [Proj o d] in - List.foldr (\ (Arg ai x) -> Lam ai . NoAbs x) core pars --- Projection-like functions: -projDropPars (Projection Nothing _ _ _ lams) o | null lams = __IMPOSSIBLE__ -projDropPars (Projection Nothing d _ _ lams) o = - List.foldr (\ (Arg ai x) -> Lam ai . NoAbs x) (Def d []) $ init $ getProjLams lams - --- | The info of the principal (record) argument. -projArgInfo :: Projection -> ArgInfo -projArgInfo (Projection _ _ _ _ lams) = - maybe __IMPOSSIBLE__ getArgInfo $ lastMaybe $ getProjLams lams - --- | Should a record type admit eta-equality? -data EtaEquality - = Specified { theEtaEquality :: !HasEta } -- ^ User specifed 'eta-equality' or 'no-eta-equality'. - | Inferred { theEtaEquality :: !HasEta } -- ^ Positivity checker inferred whether eta is safe. - deriving (Data, Show, Eq) - --- | Make sure we do not overwrite a user specification. -setEtaEquality :: EtaEquality -> HasEta -> EtaEquality -setEtaEquality e@Specified{} _ = e -setEtaEquality _ b = Inferred b - -data FunctionFlag - = FunStatic -- ^ Should calls to this function be normalised at compile-time? - | FunInline -- ^ Should calls to this function be inlined by the compiler? - | FunMacro -- ^ Is this function a macro? - deriving (Data, Eq, Ord, Enum, Show) - -data CompKit = CompKit - { nameOfHComp :: Maybe QName - , nameOfTransp :: Maybe QName - } - deriving (Data, Eq, Ord, Show) - -emptyCompKit :: CompKit -emptyCompKit = CompKit Nothing Nothing - -data Defn = Axiom -- ^ Postulate - | DataOrRecSig - { datarecPars :: Int } - -- ^ Data or record type signature that doesn't yet have a definition - | GeneralizableVar -- ^ Generalizable variable (introduced in `generalize` block) - | AbstractDefn Defn - -- ^ Returned by 'getConstInfo' if definition is abstract. - | Function - { funClauses :: [Clause] - , funCompiled :: Maybe CompiledClauses - -- ^ 'Nothing' while function is still type-checked. - -- @Just cc@ after type and coverage checking and - -- translation to case trees. - , funSplitTree :: Maybe SplitTree - -- ^ The split tree constructed by the coverage - -- checker. Needed to re-compile the clauses after - -- forcing translation. - , funTreeless :: Maybe Compiled - -- ^ Intermediate representation for compiler backends. - , funCovering :: [Closure Clause] - -- ^ Covering clauses computed by coverage checking. - -- Erased by (IApply) confluence checking(?) - , funInv :: FunctionInverse - , funMutual :: Maybe [QName] - -- ^ Mutually recursive functions, @data@s and @record@s. - -- Does include this function. - -- Empty list if not recursive. - -- @Nothing@ if not yet computed (by positivity checker). - , funAbstr :: IsAbstract - , funDelayed :: Delayed - -- ^ Are the clauses of this definition delayed? - , funProjection :: Maybe Projection - -- ^ Is it a record projection? - -- If yes, then return the name of the record type and index of - -- the record argument. Start counting with 1, because 0 means that - -- it is already applied to the record. (Can happen in module - -- instantiation.) This information is used in the termination - -- checker. - , funFlags :: Set FunctionFlag - , funTerminates :: Maybe Bool - -- ^ Has this function been termination checked? Did it pass? - , funExtLam :: Maybe ExtLamInfo - -- ^ Is this function generated from an extended lambda? - -- If yes, then return the number of hidden and non-hidden lambda-lifted arguments - , funWith :: Maybe QName - -- ^ Is this a generated with-function? If yes, then what's the - -- name of the parent function. - , funCopatternLHS :: Bool - -- ^ Is this a function defined by copatterns? - } - | Datatype - { dataPars :: Nat -- ^ Number of parameters. - , dataIxs :: Nat -- ^ Number of indices. - , dataInduction :: Induction -- ^ @data@ or @codata@ (legacy). - , dataClause :: (Maybe Clause) -- ^ This might be in an instantiated module. - , dataCons :: [QName] - -- ^ Constructor names , ordered according to the order of their definition. - , dataSort :: Sort - , dataMutual :: Maybe [QName] - -- ^ Mutually recursive functions, @data@s and @record@s. - -- Does include this data type. - -- Empty if not recursive. - -- @Nothing@ if not yet computed (by positivity checker). - , dataAbstr :: IsAbstract - , dataPathCons :: [QName] -- ^ Path constructor names (subset of dataCons) - } - | Record - { recPars :: Nat - -- ^ Number of parameters. - , recClause :: Maybe Clause - -- ^ Was this record type created by a module application? - -- If yes, the clause is its definition (linking back to the original record type). - , recConHead :: ConHead - -- ^ Constructor name and fields. - , recNamedCon :: Bool - -- ^ Does this record have a @constructor@? - , recFields :: [Arg QName] - -- ^ The record field names. - , recTel :: Telescope - -- ^ The record field telescope. (Includes record parameters.) - -- Note: @TelV recTel _ == telView' recConType@. - -- Thus, @recTel@ is redundant. - , recMutual :: Maybe [QName] - -- ^ Mutually recursive functions, @data@s and @record@s. - -- Does include this record. - -- Empty if not recursive. - -- @Nothing@ if not yet computed (by positivity checker). - , recEtaEquality' :: EtaEquality - -- ^ Eta-expand at this record type? - -- @False@ for unguarded recursive records and coinductive records - -- unless the user specifies otherwise. - , recInduction :: Maybe Induction - -- ^ 'Inductive' or 'CoInductive'? Matters only for recursive records. - -- 'Nothing' means that the user did not specify it, which is an error - -- for recursive records. - , recAbstr :: IsAbstract - , recComp :: CompKit - } - | Constructor - { conPars :: Int -- ^ Number of parameters. - , conArity :: Int -- ^ Number of arguments (excluding parameters). - , conSrcCon :: ConHead -- ^ Name of (original) constructor and fields. (This might be in a module instance.) - , conData :: QName -- ^ Name of datatype or record type. - , conAbstr :: IsAbstract - , conInd :: Induction -- ^ Inductive or coinductive? - , conComp :: (CompKit, Maybe [QName]) -- ^ (cubical composition, projections) - , conForced :: [IsForced] -- ^ Which arguments are forced (i.e. determined by the type of the constructor)? - , conErased :: [Bool] -- ^ Which arguments are erased at runtime (computed during compilation to treeless) - } - | Primitive - { primAbstr :: IsAbstract - , primName :: String - , primClauses :: [Clause] - -- ^ 'null' for primitive functions, @not null@ for builtin functions. - , primInv :: FunctionInverse - -- ^ Builtin functions can have inverses. For instance, natural number addition. - , primCompiled :: Maybe CompiledClauses - -- ^ 'Nothing' for primitive functions, - -- @'Just' something@ for builtin functions. - } - -- ^ Primitive or builtin functions. - deriving (Data, Show) - -instance Pretty Definition where - pretty Defn{..} = - "Defn {" vcat - [ "defArgInfo =" pshow defArgInfo - , "defName =" pretty defName - , "defType =" pretty defType - , "defPolarity =" pshow defPolarity - , "defArgOccurrences =" pshow defArgOccurrences - , "defGeneralizedParams =" pshow defGeneralizedParams - , "defDisplay =" pshow defDisplay -- TODO: pretty DisplayForm - , "defMutual =" pshow defMutual - , "defCompiledRep =" pshow defCompiledRep - , "defInstance =" pshow defInstance - , "defCopy =" pshow defCopy - , "defMatchable =" pshow defMatchable - , "defInjective =" pshow defInjective - , "theDef =" pretty theDef ] <+> "}" - -instance Pretty Defn where - pretty Axiom = "Axiom" - pretty (DataOrRecSig n) = "DataOrRecSig" <+> pretty n - pretty GeneralizableVar{} = "GeneralizableVar" - pretty (AbstractDefn def) = "AbstractDefn" parens (pretty def) - pretty Function{..} = - "Function {" vcat - [ "funClauses =" vcat (map pretty funClauses) - , "funCompiled =" pshow funCompiled - , "funSplitTree =" pshow funSplitTree - , "funTreeless =" pshow funTreeless - , "funInv =" pshow funInv - , "funMutual =" pshow funMutual - , "funAbstr =" pshow funAbstr - , "funDelayed =" pshow funDelayed - , "funProjection =" pshow funProjection - , "funFlags =" pshow funFlags - , "funTerminates =" pshow funTerminates - , "funWith =" pshow funWith - , "funCopatternLHS =" pshow funCopatternLHS ] "}" - pretty Datatype{..} = - "Datatype {" vcat - [ "dataPars =" pshow dataPars - , "dataIxs =" pshow dataIxs - , "dataInduction =" pshow dataInduction - , "dataClause =" pretty dataClause - , "dataCons =" pshow dataCons - , "dataSort =" pretty dataSort - , "dataMutual =" pshow dataMutual - , "dataAbstr =" pshow dataAbstr ] "}" - pretty Record{..} = - "Record {" vcat - [ "recPars =" pshow recPars - , "recClause =" pretty recClause - , "recConHead =" pshow recConHead - , "recNamedCon =" pshow recNamedCon - , "recFields =" pshow recFields - , "recTel =" pretty recTel - , "recMutual =" pshow recMutual - , "recEtaEquality' =" pshow recEtaEquality' - , "recInduction =" pshow recInduction - , "recAbstr =" pshow recAbstr ] "}" - pretty Constructor{..} = - "Constructor {" vcat - [ "conPars =" pshow conPars - , "conArity =" pshow conArity - , "conSrcCon =" pshow conSrcCon - , "conData =" pshow conData - , "conAbstr =" pshow conAbstr - , "conInd =" pshow conInd - , "conErased =" pshow conErased ] "}" - pretty Primitive{..} = - "Primitive {" vcat - [ "primAbstr =" pshow primAbstr - , "primName =" pshow primName - , "primClauses =" pshow primClauses - , "primCompiled =" pshow primCompiled ] "}" - - --- | Is the record type recursive? -recRecursive :: Defn -> Bool -recRecursive (Record { recMutual = Just qs }) = not $ null qs -recRecursive _ = __IMPOSSIBLE__ - -recEtaEquality :: Defn -> HasEta -recEtaEquality = theEtaEquality . recEtaEquality' - --- | A template for creating 'Function' definitions, with sensible defaults. -emptyFunction :: Defn -emptyFunction = Function - { funClauses = [] - , funCompiled = Nothing - , funSplitTree = Nothing - , funTreeless = Nothing - , funInv = NotInjective - , funMutual = Nothing - , funAbstr = ConcreteDef - , funDelayed = NotDelayed - , funProjection = Nothing - , funFlags = Set.empty - , funTerminates = Nothing - , funExtLam = Nothing - , funWith = Nothing - , funCopatternLHS = False - , funCovering = [] - } - -funFlag :: FunctionFlag -> Lens' Bool Defn -funFlag flag f def@Function{ funFlags = flags } = - f (Set.member flag flags) <&> - \ b -> def{ funFlags = (if b then Set.insert else Set.delete) flag flags } -funFlag _ f def = f False <&> const def - -funStatic, funInline, funMacro :: Lens' Bool Defn -funStatic = funFlag FunStatic -funInline = funFlag FunInline -funMacro = funFlag FunMacro - -isMacro :: Defn -> Bool -isMacro = (^. funMacro) - --- | Checking whether we are dealing with a function yet to be defined. -isEmptyFunction :: Defn -> Bool -isEmptyFunction def = - case def of - Function { funClauses = [] } -> True - _ -> False - -isCopatternLHS :: [Clause] -> Bool -isCopatternLHS = List.any (List.any (isJust . A.isProjP) . namedClausePats) - -recCon :: Defn -> QName -recCon Record{ recConHead } = conName recConHead -recCon _ = __IMPOSSIBLE__ - -defIsRecord :: Defn -> Bool -defIsRecord Record{} = True -defIsRecord _ = False - -defIsDataOrRecord :: Defn -> Bool -defIsDataOrRecord Record{} = True -defIsDataOrRecord Datatype{} = True -defIsDataOrRecord _ = False - -defConstructors :: Defn -> [QName] -defConstructors Datatype{dataCons = cs} = cs -defConstructors Record{recConHead = c} = [conName c] -defConstructors _ = __IMPOSSIBLE__ - -newtype Fields = Fields [(C.Name, Type)] - deriving Null - --- | Did we encounter a simplifying reduction? --- In terms of CIC, that would be a iota-reduction. --- In terms of Agda, this is a constructor or literal --- pattern that matched. --- Just beta-reduction (substitution) or delta-reduction --- (unfolding of definitions) does not count as simplifying? - -data Simplification = YesSimplification | NoSimplification - deriving (Data, Eq, Show) - -instance Null Simplification where - empty = NoSimplification - null = (== NoSimplification) - -instance Semigroup Simplification where - YesSimplification <> _ = YesSimplification - NoSimplification <> s = s - -instance Monoid Simplification where - mempty = NoSimplification - mappend = (<>) - -data Reduced no yes = NoReduction no | YesReduction Simplification yes - deriving Functor - --- | Three cases: 1. not reduced, 2. reduced, but blocked, 3. reduced, not blocked. -data IsReduced - = NotReduced - | Reduced (Blocked ()) - -data MaybeReduced a = MaybeRed - { isReduced :: IsReduced - , ignoreReduced :: a - } - deriving (Functor) - -instance IsProjElim e => IsProjElim (MaybeReduced e) where - isProjElim = isProjElim . ignoreReduced - -type MaybeReducedArgs = [MaybeReduced (Arg Term)] -type MaybeReducedElims = [MaybeReduced Elim] - -notReduced :: a -> MaybeReduced a -notReduced x = MaybeRed NotReduced x - -reduced :: Blocked (Arg Term) -> MaybeReduced (Arg Term) -reduced b = case b of - NotBlocked _ (Arg _ (MetaV x _)) -> MaybeRed (Reduced $ Blocked x ()) v - _ -> MaybeRed (Reduced $ () <$ b) v - where - v = ignoreBlocking b - --- | Controlling 'reduce'. -data AllowedReduction - = ProjectionReductions -- ^ (Projection and) projection-like functions may be reduced. - | InlineReductions -- ^ Functions marked INLINE may be reduced. - | CopatternReductions -- ^ Copattern definitions may be reduced. - | FunctionReductions -- ^ Non-recursive functions and primitives may be reduced. - | RecursiveReductions -- ^ Even recursive functions may be reduced. - | LevelReductions -- ^ Reduce @'Level'@ terms. - | UnconfirmedReductions -- ^ Functions whose termination has not (yet) been confirmed. - | NonTerminatingReductions -- ^ Functions that have failed termination checking. - deriving (Show, Eq, Ord, Enum, Bounded, Data) - -type AllowedReductions = [AllowedReduction] - --- | Not quite all reductions (skip non-terminating reductions) -allReductions :: AllowedReductions -allReductions = [minBound..pred maxBound] - -data PrimFun = PrimFun - { primFunName :: QName - , primFunArity :: Arity - , primFunImplementation :: [Arg Term] -> Int -> ReduceM (Reduced MaybeReducedArgs Term) - } - -primFun :: QName -> Arity -> ([Arg Term] -> ReduceM (Reduced MaybeReducedArgs Term)) -> PrimFun -primFun q ar imp = PrimFun q ar (\ args _ -> imp args) - -defClauses :: Definition -> [Clause] -defClauses Defn{theDef = Function{funClauses = cs}} = cs -defClauses Defn{theDef = Primitive{primClauses = cs}} = cs -defClauses Defn{theDef = Datatype{dataClause = Just c}} = [c] -defClauses Defn{theDef = Record{recClause = Just c}} = [c] -defClauses _ = [] - -defCompiled :: Definition -> Maybe CompiledClauses -defCompiled Defn{theDef = Function {funCompiled = mcc}} = mcc -defCompiled Defn{theDef = Primitive{primCompiled = mcc}} = mcc -defCompiled _ = Nothing - -defParameters :: Definition -> Maybe Nat -defParameters Defn{theDef = Datatype{dataPars = n}} = Just n -defParameters Defn{theDef = Record {recPars = n}} = Just n -defParameters _ = Nothing - -defInverse :: Definition -> FunctionInverse -defInverse Defn{theDef = Function { funInv = inv }} = inv -defInverse Defn{theDef = Primitive{ primInv = inv }} = inv -defInverse _ = NotInjective - -defCompilerPragmas :: BackendName -> Definition -> [CompilerPragma] -defCompilerPragmas b = reverse . fromMaybe [] . Map.lookup b . defCompiledRep - -- reversed because we add new pragmas to the front of the list - --- | Are the clauses of this definition delayed? -defDelayed :: Definition -> Delayed -defDelayed Defn{theDef = Function{funDelayed = d}} = d -defDelayed _ = NotDelayed - --- | Has the definition failed the termination checker? -defNonterminating :: Definition -> Bool -defNonterminating Defn{theDef = Function{funTerminates = Just False}} = True -defNonterminating _ = False - --- | Has the definition not termination checked or did the check fail? -defTerminationUnconfirmed :: Definition -> Bool -defTerminationUnconfirmed Defn{theDef = Function{funTerminates = Just True}} = False -defTerminationUnconfirmed Defn{theDef = Function{funTerminates = _ }} = True -defTerminationUnconfirmed _ = False - -defAbstract :: Definition -> IsAbstract -defAbstract d = case theDef d of - Axiom{} -> ConcreteDef - DataOrRecSig{} -> ConcreteDef - GeneralizableVar{} -> ConcreteDef - AbstractDefn{} -> AbstractDef - Function{funAbstr = a} -> a - Datatype{dataAbstr = a} -> a - Record{recAbstr = a} -> a - Constructor{conAbstr = a} -> a - Primitive{primAbstr = a} -> a - -defForced :: Definition -> [IsForced] -defForced d = case theDef d of - Constructor{conForced = fs} -> fs - Axiom{} -> [] - DataOrRecSig{} -> [] - GeneralizableVar{} -> [] - AbstractDefn{} -> [] - Function{} -> [] - Datatype{} -> [] - Record{} -> [] - Primitive{} -> [] - ---------------------------------------------------------------------------- --- ** Injectivity ---------------------------------------------------------------------------- - -type FunctionInverse = FunctionInverse' Clause -type InversionMap c = Map TermHead [c] - -data FunctionInverse' c - = NotInjective - | Inverse (InversionMap c) - deriving (Data, Show, Functor) - -data TermHead = SortHead - | PiHead - | ConsHead QName - | VarHead Nat - | UnknownHead - deriving (Data, Eq, Ord, Show) - -instance Pretty TermHead where - pretty = \ case - SortHead -> "SortHead" - PiHead -> "PiHead" - ConsHead q -> "ConsHead" <+> pretty q - VarHead i -> text ("VarHead " ++ show i) - UnknownHead -> "UnknownHead" - ---------------------------------------------------------------------------- --- ** Mutual blocks ---------------------------------------------------------------------------- - -newtype MutualId = MutId Int32 - deriving (Data, Eq, Ord, Show, Num, Enum) - ---------------------------------------------------------------------------- --- ** Statistics ---------------------------------------------------------------------------- - -type Statistics = Map String Integer - ---------------------------------------------------------------------------- --- ** Trace ---------------------------------------------------------------------------- - -data Call = CheckClause Type A.SpineClause - | CheckPattern A.Pattern Telescope Type - | CheckLetBinding A.LetBinding - | InferExpr A.Expr - | CheckExprCall Comparison A.Expr Type - | CheckDotPattern A.Expr Term - | CheckPatternShadowing A.SpineClause - | CheckProjection Range QName Type - | IsTypeCall A.Expr Sort - | IsType_ A.Expr - | InferVar Name - | InferDef QName - | CheckArguments Range [NamedArg A.Expr] Type (Maybe Type) - | CheckTargetType Range Type Type - | CheckDataDef Range QName [A.LamBinding] [A.Constructor] - | CheckRecDef Range QName [A.LamBinding] [A.Constructor] - | CheckConstructor QName Telescope Sort A.Constructor - | CheckConstructorFitsIn QName Type Sort - | CheckFunDefCall Range QName [A.Clause] - | CheckPragma Range A.Pragma - | CheckPrimitive Range QName A.Expr - | CheckIsEmpty Range Type - | CheckWithFunctionType Type - | CheckSectionApplication Range ModuleName A.ModuleApplication - | CheckNamedWhere ModuleName - | ScopeCheckExpr C.Expr - | ScopeCheckDeclaration NiceDeclaration - | ScopeCheckLHS C.QName C.Pattern - | NoHighlighting - | ModuleContents -- ^ Interaction command: show module contents. - | SetRange Range -- ^ used by 'setCurrentRange' - deriving Data - -instance Pretty Call where - pretty CheckClause{} = "CheckClause" - pretty CheckPattern{} = "CheckPattern" - pretty InferExpr{} = "InferExpr" - pretty CheckExprCall{} = "CheckExprCall" - pretty CheckLetBinding{} = "CheckLetBinding" - pretty CheckProjection{} = "CheckProjection" - pretty IsTypeCall{} = "IsTypeCall" - pretty IsType_{} = "IsType_" - pretty InferVar{} = "InferVar" - pretty InferDef{} = "InferDef" - pretty CheckArguments{} = "CheckArguments" - pretty CheckTargetType{} = "CheckTargetType" - pretty CheckDataDef{} = "CheckDataDef" - pretty CheckRecDef{} = "CheckRecDef" - pretty CheckConstructor{} = "CheckConstructor" - pretty CheckConstructorFitsIn{} = "CheckConstructorFitsIn" - pretty CheckFunDefCall{} = "CheckFunDefCall" - pretty CheckPragma{} = "CheckPragma" - pretty CheckPrimitive{} = "CheckPrimitive" - pretty CheckWithFunctionType{} = "CheckWithFunctionType" - pretty CheckNamedWhere{} = "CheckNamedWhere" - pretty ScopeCheckExpr{} = "ScopeCheckExpr" - pretty ScopeCheckDeclaration{} = "ScopeCheckDeclaration" - pretty ScopeCheckLHS{} = "ScopeCheckLHS" - pretty CheckDotPattern{} = "CheckDotPattern" - pretty CheckPatternShadowing{} = "CheckPatternShadowing" - pretty SetRange{} = "SetRange" - pretty CheckSectionApplication{} = "CheckSectionApplication" - pretty CheckIsEmpty{} = "CheckIsEmpty" - pretty NoHighlighting{} = "NoHighlighting" - pretty ModuleContents{} = "ModuleContents" - -instance HasRange Call where - getRange (CheckClause _ c) = getRange c - getRange (CheckPattern p _ _) = getRange p - getRange (InferExpr e) = getRange e - getRange (CheckExprCall _ e _) = getRange e - getRange (CheckLetBinding b) = getRange b - getRange (CheckProjection r _ _) = r - getRange (IsTypeCall e s) = getRange e - getRange (IsType_ e) = getRange e - getRange (InferVar x) = getRange x - getRange (InferDef f) = getRange f - getRange (CheckArguments r _ _ _) = r - getRange (CheckTargetType r _ _) = r - getRange (CheckDataDef i _ _ _) = getRange i - getRange (CheckRecDef i _ _ _) = getRange i - getRange (CheckConstructor _ _ _ c) = getRange c - getRange (CheckConstructorFitsIn c _ _) = getRange c - getRange (CheckFunDefCall i _ _) = getRange i - getRange (CheckPragma r _) = r - getRange (CheckPrimitive i _ _) = getRange i - getRange CheckWithFunctionType{} = noRange - getRange (CheckNamedWhere m) = getRange m - getRange (ScopeCheckExpr e) = getRange e - getRange (ScopeCheckDeclaration d) = getRange d - getRange (ScopeCheckLHS _ p) = getRange p - getRange (CheckDotPattern e _) = getRange e - getRange (CheckPatternShadowing c) = getRange c - getRange (SetRange r) = r - getRange (CheckSectionApplication r _ _) = r - getRange (CheckIsEmpty r _) = r - getRange NoHighlighting = noRange - getRange ModuleContents = noRange - ---------------------------------------------------------------------------- --- ** Instance table ---------------------------------------------------------------------------- - --- | The instance table is a @Map@ associating to every name of --- record/data type/postulate its list of instances -type InstanceTable = Map QName (Set QName) - --- | When typechecking something of the following form: --- --- instance --- x : _ --- x = y --- --- it's not yet known where to add @x@, so we add it to a list of --- unresolved instances and we'll deal with it later. -type TempInstanceTable = (InstanceTable , Set QName) - ---------------------------------------------------------------------------- --- ** Builtin things ---------------------------------------------------------------------------- - -data BuiltinDescriptor - = BuiltinData (TCM Type) [String] - | BuiltinDataCons (TCM Type) - | BuiltinPrim String (Term -> TCM ()) - | BuiltinPostulate Relevance (TCM Type) - | BuiltinUnknown (Maybe (TCM Type)) (Term -> Type -> TCM ()) - -- ^ Builtin of any kind. - -- Type can be checked (@Just t@) or inferred (@Nothing@). - -- The second argument is the hook for the verification function. - -data BuiltinInfo = - BuiltinInfo { builtinName :: String - , builtinDesc :: BuiltinDescriptor } - -type BuiltinThings pf = Map String (Builtin pf) - -data Builtin pf - = Builtin Term - | Prim pf - deriving (Show, Functor, Foldable, Traversable) - ---------------------------------------------------------------------------- --- * Highlighting levels ---------------------------------------------------------------------------- - --- | How much highlighting should be sent to the user interface? - -data HighlightingLevel - = None - | NonInteractive - | Interactive - -- ^ This includes both non-interactive highlighting and - -- interactive highlighting of the expression that is currently - -- being type-checked. - deriving (Eq, Ord, Show, Read, Data) - --- | How should highlighting be sent to the user interface? - -data HighlightingMethod - = Direct - -- ^ Via stdout. - | Indirect - -- ^ Both via files and via stdout. - deriving (Eq, Show, Read, Data) - --- | @ifTopLevelAndHighlightingLevelIs l b m@ runs @m@ when we're --- type-checking the top-level module and either the highlighting --- level is /at least/ @l@ or @b@ is 'True'. - -ifTopLevelAndHighlightingLevelIsOr :: - MonadTCM tcm => HighlightingLevel -> Bool -> tcm () -> tcm () -ifTopLevelAndHighlightingLevelIsOr l b m = do - e <- askTC - when (envModuleNestingLevel e == 0 && - (envHighlightingLevel e >= l || b)) - m - --- | @ifTopLevelAndHighlightingLevelIs l m@ runs @m@ when we're --- type-checking the top-level module and the highlighting level is --- /at least/ @l@. - -ifTopLevelAndHighlightingLevelIs :: - MonadTCM tcm => HighlightingLevel -> tcm () -> tcm () -ifTopLevelAndHighlightingLevelIs l = - ifTopLevelAndHighlightingLevelIsOr l False - ---------------------------------------------------------------------------- --- * Type checking environment ---------------------------------------------------------------------------- - -data TCEnv = - TCEnv { envContext :: Context - , envLetBindings :: LetBindings - , envCurrentModule :: ModuleName - , envCurrentPath :: Maybe AbsolutePath - -- ^ The path to the file that is currently being - -- type-checked. 'Nothing' if we do not have a file - -- (like in interactive mode see @CommandLine@). - , envAnonymousModules :: [(ModuleName, Nat)] -- ^ anonymous modules and their number of free variables - , envImportPath :: [C.TopLevelModuleName] -- ^ to detect import cycles - , envMutualBlock :: Maybe MutualId -- ^ the current (if any) mutual block - , envTerminationCheck :: TerminationCheck () -- ^ are we inside the scope of a termination pragma - , envSolvingConstraints :: Bool - -- ^ Are we currently in the process of solving active constraints? - , envCheckingWhere :: Bool - -- ^ Have we stepped into the where-declarations of a clause? - -- Everything under a @where@ will be checked with this flag on. - , envWorkingOnTypes :: Bool - -- ^ Are we working on types? Turned on by 'workOnTypes'. - , envAssignMetas :: Bool - -- ^ Are we allowed to assign metas? - , envActiveProblems :: Set ProblemId - , envAbstractMode :: AbstractMode - -- ^ When checking the typesignature of a public definition - -- or the body of a non-abstract definition this is true. - -- To prevent information about abstract things leaking - -- outside the module. - , envModality :: Modality - -- ^ 'Relevance' component: - -- Are we checking an irrelevant argument? (=@Irrelevant@) - -- Then top-level irrelevant declarations are enabled. - -- Other value: @Relevant@, then only relevant decls. are available. - -- - -- 'Quantity' component: - -- Are we checking a runtime-irrelevant thing? (='Quantity0') - -- Then runtime-irrelevant things are usable. - -- Other value: @Quantity1@, runtime relevant. - -- @Quantityω@ is not allowed here, see Bob Atkey, LiCS 2018. - , envDisplayFormsEnabled :: Bool - -- ^ Sometimes we want to disable display forms. - , envRange :: Range - , envHighlightingRange :: Range - -- ^ Interactive highlighting uses this range rather - -- than 'envRange'. - , envClause :: IPClause - -- ^ What is the current clause we are type-checking? - -- Will be recorded in interaction points in this clause. - , envCall :: Maybe (Closure Call) - -- ^ what we're doing at the moment - , envHighlightingLevel :: HighlightingLevel - -- ^ Set to 'None' when imported modules are - -- type-checked. - , envHighlightingMethod :: HighlightingMethod - , envModuleNestingLevel :: !Int - -- ^ This number indicates how far away from the - -- top-level module Agda has come when chasing - -- modules. The level of a given module is not - -- necessarily the same as the length, in the module - -- dependency graph, of the shortest path from the - -- top-level module; it depends on in which order - -- Agda chooses to chase dependencies. - , envExpandLast :: ExpandHidden - -- ^ When type-checking an alias f=e, we do not want - -- to insert hidden arguments in the end, because - -- these will become unsolved metas. - , envAppDef :: Maybe QName - -- ^ We are reducing an application of this function. - -- (For debugging of incomplete matches only.) - , envSimplification :: Simplification - -- ^ Did we encounter a simplification (proper match) - -- during the current reduction process? - , envAllowedReductions :: AllowedReductions - , envInjectivityDepth :: Int - -- ^ Injectivity can cause non-termination for unsolvable contraints - -- (#431, #3067). Keep a limit on the nesting depth of injectivity - -- uses. - , envCompareBlocked :: Bool - -- ^ Can we compare blocked things during conversion? - -- No by default. - -- Yes for rewriting feature. - , envPrintDomainFreePi :: Bool - -- ^ When @True@, types will be omitted from printed pi types if they - -- can be inferred. - , envPrintMetasBare :: Bool - -- ^ When @True@, throw away meta numbers and meta elims. - -- This is used for reifying terms for feeding into the - -- user's source code, e.g., for the interaction tactics @solveAll@. - , envInsideDotPattern :: Bool - -- ^ Used by the scope checker to make sure that certain forms - -- of expressions are not used inside dot patterns: extended - -- lambdas and let-expressions. - , envUnquoteFlags :: UnquoteFlags - , envInstanceDepth :: !Int - -- ^ Until we get a termination checker for instance search (#1743) we - -- limit the search depth to ensure termination. - , envIsDebugPrinting :: Bool - , envPrintingPatternLambdas :: [QName] - -- ^ #3004: pattern lambdas with copatterns may refer to themselves. We - -- don't have a good story for what to do in this case, but at least - -- printing shouldn't loop. Here we keep track of which pattern lambdas - -- we are currently in the process of printing. - , envCallByNeed :: Bool - -- ^ Use call-by-need evaluation for reductions. - , envCurrentCheckpoint :: CheckpointId - -- ^ Checkpoints track the evolution of the context as we go - -- under binders or refine it by pattern matching. - , envCheckpoints :: Map CheckpointId Substitution - -- ^ Keeps the substitution from each previous checkpoint to - -- the current context. - , envGeneralizeMetas :: DoGeneralize - -- ^ Should new metas generalized over. - , envGeneralizedVars :: Map QName GeneralizedValue - -- ^ Values for used generalizable variables. - , envCheckOptionConsistency :: Bool - -- ^ Do we check that options in imported files are - -- consistent with each other? - } - deriving Data - -initEnv :: TCEnv -initEnv = TCEnv { envContext = [] - , envLetBindings = Map.empty - , envCurrentModule = noModuleName - , envCurrentPath = Nothing - , envAnonymousModules = [] - , envImportPath = [] - , envMutualBlock = Nothing - , envTerminationCheck = TerminationCheck - , envSolvingConstraints = False - , envCheckingWhere = False - , envActiveProblems = Set.empty - , envWorkingOnTypes = False - , envAssignMetas = True - , envAbstractMode = ConcreteMode - -- Andreas, 2013-02-21: This was 'AbstractMode' until now. - -- However, top-level checks for mutual blocks, such as - -- constructor-headedness, should not be able to look into - -- abstract definitions unless abstract themselves. - -- (See also discussion on issue 796.) - -- The initial mode should be 'ConcreteMode', ensuring you - -- can only look into abstract things in an abstract - -- definition (which sets 'AbstractMode'). - , envModality = Modality Relevant Quantity1 - , envDisplayFormsEnabled = True - , envRange = noRange - , envHighlightingRange = noRange - , envClause = IPNoClause - , envCall = Nothing - , envHighlightingLevel = None - , envHighlightingMethod = Indirect - , envModuleNestingLevel = -1 - , envExpandLast = ExpandLast - , envAppDef = Nothing - , envSimplification = NoSimplification - , envAllowedReductions = allReductions - , envInjectivityDepth = 0 - , envCompareBlocked = False - , envPrintDomainFreePi = False - , envPrintMetasBare = False - , envInsideDotPattern = False - , envUnquoteFlags = defaultUnquoteFlags - , envInstanceDepth = 0 - , envIsDebugPrinting = False - , envPrintingPatternLambdas = [] - , envCallByNeed = True - , envCurrentCheckpoint = 0 - , envCheckpoints = Map.singleton 0 IdS - , envGeneralizeMetas = NoGeneralize - , envGeneralizedVars = Map.empty - , envCheckOptionConsistency = True - } - --- | Project 'Relevance' component of 'TCEnv'. -envRelevance :: TCEnv -> Relevance -envRelevance = modRelevance . envModality - -data UnquoteFlags = UnquoteFlags - { _unquoteNormalise :: Bool } - deriving Data - -defaultUnquoteFlags :: UnquoteFlags -defaultUnquoteFlags = UnquoteFlags - { _unquoteNormalise = False } - -unquoteNormalise :: Lens' Bool UnquoteFlags -unquoteNormalise f e = f (_unquoteNormalise e) <&> \ x -> e { _unquoteNormalise = x } - -eUnquoteNormalise :: Lens' Bool TCEnv -eUnquoteNormalise = eUnquoteFlags . unquoteNormalise - --- * e-prefixed lenses ------------------------------------------------------------------------- - -eContext :: Lens' Context TCEnv -eContext f e = f (envContext e) <&> \ x -> e { envContext = x } - -eLetBindings :: Lens' LetBindings TCEnv -eLetBindings f e = f (envLetBindings e) <&> \ x -> e { envLetBindings = x } - -eCurrentModule :: Lens' ModuleName TCEnv -eCurrentModule f e = f (envCurrentModule e) <&> \ x -> e { envCurrentModule = x } - -eCurrentPath :: Lens' (Maybe AbsolutePath) TCEnv -eCurrentPath f e = f (envCurrentPath e) <&> \ x -> e { envCurrentPath = x } - -eAnonymousModules :: Lens' [(ModuleName, Nat)] TCEnv -eAnonymousModules f e = f (envAnonymousModules e) <&> \ x -> e { envAnonymousModules = x } - -eImportPath :: Lens' [C.TopLevelModuleName] TCEnv -eImportPath f e = f (envImportPath e) <&> \ x -> e { envImportPath = x } - -eMutualBlock :: Lens' (Maybe MutualId) TCEnv -eMutualBlock f e = f (envMutualBlock e) <&> \ x -> e { envMutualBlock = x } - -eTerminationCheck :: Lens' (TerminationCheck ()) TCEnv -eTerminationCheck f e = f (envTerminationCheck e) <&> \ x -> e { envTerminationCheck = x } - -eSolvingConstraints :: Lens' Bool TCEnv -eSolvingConstraints f e = f (envSolvingConstraints e) <&> \ x -> e { envSolvingConstraints = x } - -eCheckingWhere :: Lens' Bool TCEnv -eCheckingWhere f e = f (envCheckingWhere e) <&> \ x -> e { envCheckingWhere = x } - -eWorkingOnTypes :: Lens' Bool TCEnv -eWorkingOnTypes f e = f (envWorkingOnTypes e) <&> \ x -> e { envWorkingOnTypes = x } - -eAssignMetas :: Lens' Bool TCEnv -eAssignMetas f e = f (envAssignMetas e) <&> \ x -> e { envAssignMetas = x } - -eActiveProblems :: Lens' (Set ProblemId) TCEnv -eActiveProblems f e = f (envActiveProblems e) <&> \ x -> e { envActiveProblems = x } - -eAbstractMode :: Lens' AbstractMode TCEnv -eAbstractMode f e = f (envAbstractMode e) <&> \ x -> e { envAbstractMode = x } - -eModality :: Lens' Modality TCEnv -eModality f e = f (envModality e) <&> \ x -> e { envModality = x } - -eRelevance :: Lens' Relevance TCEnv -eRelevance = eModality . lModRelevance - -eQuantity :: Lens' Quantity TCEnv -eQuantity = eModality . lModQuantity - -eDisplayFormsEnabled :: Lens' Bool TCEnv -eDisplayFormsEnabled f e = f (envDisplayFormsEnabled e) <&> \ x -> e { envDisplayFormsEnabled = x } - -eRange :: Lens' Range TCEnv -eRange f e = f (envRange e) <&> \ x -> e { envRange = x } - -eHighlightingRange :: Lens' Range TCEnv -eHighlightingRange f e = f (envHighlightingRange e) <&> \ x -> e { envHighlightingRange = x } - -eCall :: Lens' (Maybe (Closure Call)) TCEnv -eCall f e = f (envCall e) <&> \ x -> e { envCall = x } - -eHighlightingLevel :: Lens' HighlightingLevel TCEnv -eHighlightingLevel f e = f (envHighlightingLevel e) <&> \ x -> e { envHighlightingLevel = x } - -eHighlightingMethod :: Lens' HighlightingMethod TCEnv -eHighlightingMethod f e = f (envHighlightingMethod e) <&> \ x -> e { envHighlightingMethod = x } - -eModuleNestingLevel :: Lens' Int TCEnv -eModuleNestingLevel f e = f (envModuleNestingLevel e) <&> \ x -> e { envModuleNestingLevel = x } - -eExpandLast :: Lens' ExpandHidden TCEnv -eExpandLast f e = f (envExpandLast e) <&> \ x -> e { envExpandLast = x } - -eAppDef :: Lens' (Maybe QName) TCEnv -eAppDef f e = f (envAppDef e) <&> \ x -> e { envAppDef = x } - -eSimplification :: Lens' Simplification TCEnv -eSimplification f e = f (envSimplification e) <&> \ x -> e { envSimplification = x } - -eAllowedReductions :: Lens' AllowedReductions TCEnv -eAllowedReductions f e = f (envAllowedReductions e) <&> \ x -> e { envAllowedReductions = x } - -eInjectivityDepth :: Lens' Int TCEnv -eInjectivityDepth f e = f (envInjectivityDepth e) <&> \ x -> e { envInjectivityDepth = x } - -eCompareBlocked :: Lens' Bool TCEnv -eCompareBlocked f e = f (envCompareBlocked e) <&> \ x -> e { envCompareBlocked = x } - -ePrintDomainFreePi :: Lens' Bool TCEnv -ePrintDomainFreePi f e = f (envPrintDomainFreePi e) <&> \ x -> e { envPrintDomainFreePi = x } - -eInsideDotPattern :: Lens' Bool TCEnv -eInsideDotPattern f e = f (envInsideDotPattern e) <&> \ x -> e { envInsideDotPattern = x } - -eUnquoteFlags :: Lens' UnquoteFlags TCEnv -eUnquoteFlags f e = f (envUnquoteFlags e) <&> \ x -> e { envUnquoteFlags = x } - -eInstanceDepth :: Lens' Int TCEnv -eInstanceDepth f e = f (envInstanceDepth e) <&> \ x -> e { envInstanceDepth = x } - -eIsDebugPrinting :: Lens' Bool TCEnv -eIsDebugPrinting f e = f (envIsDebugPrinting e) <&> \ x -> e { envIsDebugPrinting = x } - -ePrintingPatternLambdas :: Lens' [QName] TCEnv -ePrintingPatternLambdas f e = f (envPrintingPatternLambdas e) <&> \ x -> e { envPrintingPatternLambdas = x } - -eCallByNeed :: Lens' Bool TCEnv -eCallByNeed f e = f (envCallByNeed e) <&> \ x -> e { envCallByNeed = x } - -eCurrentCheckpoint :: Lens' CheckpointId TCEnv -eCurrentCheckpoint f e = f (envCurrentCheckpoint e) <&> \ x -> e { envCurrentCheckpoint = x } - -eCheckpoints :: Lens' (Map CheckpointId Substitution) TCEnv -eCheckpoints f e = f (envCheckpoints e) <&> \ x -> e { envCheckpoints = x } - -eGeneralizeMetas :: Lens' DoGeneralize TCEnv -eGeneralizeMetas f e = f (envGeneralizeMetas e) <&> \ x -> e { envGeneralizeMetas = x } - -eGeneralizedVars :: Lens' (Map QName GeneralizedValue) TCEnv -eGeneralizedVars f e = f (envGeneralizedVars e) <&> \ x -> e { envGeneralizedVars = x } - ---------------------------------------------------------------------------- --- ** Context ---------------------------------------------------------------------------- - --- | The @Context@ is a stack of 'ContextEntry's. -type Context = [ContextEntry] -type ContextEntry = Dom (Name, Type) - ---------------------------------------------------------------------------- --- ** Let bindings ---------------------------------------------------------------------------- - -type LetBindings = Map Name (Open (Term, Dom Type)) - ---------------------------------------------------------------------------- --- ** Abstract mode ---------------------------------------------------------------------------- - -data AbstractMode - = AbstractMode -- ^ Abstract things in the current module can be accessed. - | ConcreteMode -- ^ No abstract things can be accessed. - | IgnoreAbstractMode -- ^ All abstract things can be accessed. - deriving (Data, Show, Eq) - -aDefToMode :: IsAbstract -> AbstractMode -aDefToMode AbstractDef = AbstractMode -aDefToMode ConcreteDef = ConcreteMode - -aModeToDef :: AbstractMode -> IsAbstract -aModeToDef AbstractMode = AbstractDef -aModeToDef ConcreteMode = ConcreteDef -aModeToDef _ = __IMPOSSIBLE__ - ---------------------------------------------------------------------------- --- ** Insertion of implicit arguments ---------------------------------------------------------------------------- - -data ExpandHidden - = ExpandLast -- ^ Add implicit arguments in the end until type is no longer hidden 'Pi'. - | DontExpandLast -- ^ Do not append implicit arguments. - deriving (Eq, Data) - --- | A candidate solution for an instance meta is a term with its type. --- It may be the case that the candidate is not fully applied yet or --- of the wrong type, hence the need for the type. -data Candidate = Candidate { candidateTerm :: Term - , candidateType :: Type - , candidateOverlappable :: Bool - } - deriving (Show, Data) - -instance Free Candidate where - freeVars' (Candidate t u _) = freeVars' (t, u) - ---------------------------------------------------------------------------- --- * Type checking warnings (aka non-fatal errors) ---------------------------------------------------------------------------- - --- | A non-fatal error is an error which does not prevent us from --- checking the document further and interacting with the user. - -data Warning - = NicifierIssue DeclarationWarning - | TerminationIssue [TerminationError] - | UnreachableClauses QName [[NamedArg DeBruijnPattern]] - | CoverageIssue QName [(Telescope, [NamedArg DeBruijnPattern])] - -- ^ `CoverageIssue f pss` means that `pss` are not covered in `f` - | CoverageNoExactSplit QName [Clause] - | NotStrictlyPositive QName (Seq OccursWhere) - | UnsolvedMetaVariables [Range] -- ^ Do not use directly with 'warning' - | UnsolvedInteractionMetas [Range] -- ^ Do not use directly with 'warning' - | UnsolvedConstraints Constraints - -- ^ Do not use directly with 'warning' - | CantGeneralizeOverSorts [MetaId] - | AbsurdPatternRequiresNoRHS [NamedArg DeBruijnPattern] - | OldBuiltin String String - -- ^ In `OldBuiltin old new`, the BUILTIN old has been replaced by new - | EmptyRewritePragma - -- ^ If the user wrote just @{-\# REWRITE \#-}@. - | IllformedAsClause String - -- ^ If the user wrote something other than an unqualified name - -- in the @as@ clause of an @import@ statement. - -- The 'String' gives optionally extra explanation. - | UselessPublic - -- ^ If the user opens a module public before the module header. - -- (See issue #2377.) - | UselessInline QName - | WrongInstanceDeclaration - | InstanceWithExplicitArg QName - -- ^ An instance was declared with an implicit argument, which means it - -- will never actually be considered by instance search. - | InstanceNoOutputTypeName Doc - -- ^ The type of an instance argument doesn't end in a named or - -- variable type, so it will never be considered by instance search. - | InstanceArgWithExplicitArg Doc - -- ^ As InstanceWithExplicitArg, but for local bindings rather than - -- top-level instances. - | InversionDepthReached QName - -- ^ The --inversion-max-depth was reached. - -- Generic warnings for one-off things - | GenericWarning Doc - -- ^ Harmless generic warning (not an error) - | GenericNonFatalError Doc - -- ^ Generic error which doesn't abort proceedings (not a warning) - -- Safe flag errors - | SafeFlagPostulate C.Name - | SafeFlagPragma [String] - | SafeFlagNonTerminating - | SafeFlagTerminating - | SafeFlagWithoutKFlagPrimEraseEquality - | WithoutKFlagPrimEraseEquality - | SafeFlagNoPositivityCheck - | SafeFlagPolarity - | SafeFlagNoUniverseCheck - | ParseWarning ParseWarning - | LibraryWarning LibWarning - | DeprecationWarning String String String - -- ^ `DeprecationWarning old new version`: - -- `old` is deprecated, use `new` instead. This will be an error in Agda `version`. - | UserWarning String - -- ^ User-defined warning (e.g. to mention that a name is deprecated) - | ModuleDoesntExport C.QName [C.ImportedName] - -- ^ Some imported names are not actually exported by the source module - | InfectiveImport String ModuleName - -- ^ Importing a file using an infective option into one which doesn't - | CoInfectiveImport String ModuleName - -- ^ Importing a file not using a coinfective option from one which does - deriving (Show , Data) - - -warningName :: Warning -> WarningName -warningName w = case w of - -- special cases - NicifierIssue dw -> declarationWarningName dw - ParseWarning pw -> parseWarningName pw - LibraryWarning lw -> libraryWarningName lw - -- typechecking errors - CantGeneralizeOverSorts{} -> CantGeneralizeOverSorts_ - AbsurdPatternRequiresNoRHS{} -> AbsurdPatternRequiresNoRHS_ - CoverageIssue{} -> CoverageIssue_ - CoverageNoExactSplit{} -> CoverageNoExactSplit_ - DeprecationWarning{} -> DeprecationWarning_ - EmptyRewritePragma -> EmptyRewritePragma_ - IllformedAsClause{} -> IllformedAsClause_ - WrongInstanceDeclaration{} -> WrongInstanceDeclaration_ - InstanceWithExplicitArg{} -> InstanceWithExplicitArg_ - InstanceNoOutputTypeName{} -> InstanceNoOutputTypeName_ - InstanceArgWithExplicitArg{} -> InstanceArgWithExplicitArg_ - GenericNonFatalError{} -> GenericNonFatalError_ - GenericWarning{} -> GenericWarning_ - InversionDepthReached{} -> InversionDepthReached_ - ModuleDoesntExport{} -> ModuleDoesntExport_ - NotStrictlyPositive{} -> NotStrictlyPositive_ - OldBuiltin{} -> OldBuiltin_ - SafeFlagNoPositivityCheck -> SafeFlagNoPositivityCheck_ - SafeFlagNonTerminating -> SafeFlagNonTerminating_ - SafeFlagNoUniverseCheck -> SafeFlagNoUniverseCheck_ - SafeFlagPolarity -> SafeFlagPolarity_ - SafeFlagPostulate{} -> SafeFlagPostulate_ - SafeFlagPragma{} -> SafeFlagPragma_ - SafeFlagWithoutKFlagPrimEraseEquality -> SafeFlagWithoutKFlagPrimEraseEquality_ - WithoutKFlagPrimEraseEquality -> WithoutKFlagPrimEraseEquality_ - SafeFlagTerminating -> SafeFlagTerminating_ - TerminationIssue{} -> TerminationIssue_ - UnreachableClauses{} -> UnreachableClauses_ - UnsolvedInteractionMetas{} -> UnsolvedInteractionMetas_ - UnsolvedConstraints{} -> UnsolvedConstraints_ - UnsolvedMetaVariables{} -> UnsolvedMetaVariables_ - UselessInline{} -> UselessInline_ - UselessPublic -> UselessPublic_ - UserWarning{} -> UserWarning_ - InfectiveImport{} -> InfectiveImport_ - CoInfectiveImport{} -> CoInfectiveImport_ - - -data TCWarning - = TCWarning - { tcWarningRange :: Range - -- ^ Range where the warning was raised - , tcWarning :: Warning - -- ^ The warning itself - , tcWarningPrintedWarning :: Doc - -- ^ The warning printed in the state and environment where it was raised - , tcWarningCached :: Bool - -- ^ Should the warning be affected by caching. - } - deriving Show - - -tcWarningOrigin :: TCWarning -> SrcFile -tcWarningOrigin = rangeFile . tcWarningRange - -instance HasRange TCWarning where - getRange = tcWarningRange - --- used for merging lists of warnings -instance Eq TCWarning where - x == y = equalHeadConstructors (tcWarning x) (tcWarning y) - && getRange x == getRange y - -equalHeadConstructors :: Warning -> Warning -> Bool -equalHeadConstructors = (==) `on` toConstr - -getPartialDefs :: ReadTCState tcm => tcm [QName] -getPartialDefs = do - tcst <- getTCState - return $ mapMaybe (extractQName . tcWarning) - $ tcst ^. stTCWarnings where - - extractQName :: Warning -> Maybe QName - extractQName (CoverageIssue f _) = Just f - extractQName _ = Nothing - ---------------------------------------------------------------------------- --- * Type checking errors ---------------------------------------------------------------------------- - --- | Information about a call. - -data CallInfo = CallInfo - { callInfoTarget :: QName - -- ^ Target function name. - , callInfoRange :: Range - -- ^ Range of the target function. - , callInfoCall :: Closure Term - -- ^ To be formatted representation of the call. - } deriving (Data, Show) - --- no Eq, Ord instances: too expensive! (see issues 851, 852) - --- | We only 'show' the name of the callee. -instance Pretty CallInfo where pretty = pretty . callInfoTarget -instance AllNames CallInfo where allNames = singleton . callInfoTarget - --- UNUSED, but keep! --- -- | Call pathes are sequences of 'CallInfo's starting from a 'callSource'. --- data CallPath = CallPath --- { callSource :: QName --- -- ^ The originator of the first call. --- , callInfos :: [CallInfo] --- -- ^ The calls, in order from source to final target. --- } --- deriving (Show) - --- -- | 'CallPath'es can be connected, but there is no empty callpath. --- -- Thus, they form a semigroup, but we choose to abuse 'Monoid'. --- instance Monoid CallPath where --- mempty = __IMPOSSIBLE__ --- mappend (CallPath src cs) (CallPath _ cs') = CallPath src $ cs ++ cs' - --- | Information about a mutual block which did not pass the --- termination checker. - -data TerminationError = TerminationError - { termErrFunctions :: [QName] - -- ^ The functions which failed to check. (May not include - -- automatically generated functions.) - , termErrCalls :: [CallInfo] - -- ^ The problematic call sites. - } deriving (Data, Show) - --- | Error when splitting a pattern variable into possible constructor patterns. -data SplitError - = NotADatatype (Closure Type) -- ^ Neither data type nor record. - | IrrelevantDatatype (Closure Type) -- ^ Data type, but in irrelevant position. - | ErasedDatatype (Closure Type) -- ^ Data type, but in erased position. - | CoinductiveDatatype (Closure Type) -- ^ Split on codata not allowed. - -- UNUSED, but keep! - -- -- | NoRecordConstructor Type -- ^ record type, but no constructor - | UnificationStuck - { cantSplitConName :: QName -- ^ Constructor. - , cantSplitTel :: Telescope -- ^ Context for indices. - , cantSplitConIdx :: Args -- ^ Inferred indices (from type of constructor). - , cantSplitGivenIdx :: Args -- ^ Expected indices (from checking pattern). - , cantSplitFailures :: [UnificationFailure] -- ^ Reason(s) why unification got stuck. - } - | CosplitCatchall - -- ^ Copattern split with a catchall - | CosplitNoTarget - -- ^ We do not know the target type of the clause. - | CosplitNoRecordType (Closure Type) - -- ^ Target type is not a record type. - | CannotCreateMissingClause QName (Telescope,[NamedArg DeBruijnPattern]) Doc (Closure (Abs Type)) - - | GenericSplitError String - deriving (Show) - -data NegativeUnification - = UnifyConflict Telescope Term Term - | UnifyCycle Telescope Int Term - deriving (Show) - -data UnificationFailure - = UnifyIndicesNotVars Telescope Type Term Term Args -- ^ Failed to apply injectivity to constructor of indexed datatype - | UnifyRecursiveEq Telescope Type Int Term -- ^ Can't solve equation because variable occurs in (type of) lhs - | UnifyReflexiveEq Telescope Type Term -- ^ Can't solve reflexive equation because --without-K is enabled - deriving (Show) - -data UnquoteError - = BadVisibility String (Arg I.Term) - | ConInsteadOfDef QName String String - | DefInsteadOfCon QName String String - | NonCanonical String I.Term - | BlockedOnMeta TCState MetaId - | UnquotePanic String - deriving (Show) - -data TypeError - = InternalError String - | NotImplemented String - | NotSupported String - | CompilationError String - | PropMustBeSingleton - | DataMustEndInSort Term -{- UNUSED - | DataTooManyParameters - -- ^ In @data D xs where@ the number of parameters @xs@ does not fit the - -- the parameters given in the forward declaraion @data D Gamma : T@. --} - | ShouldEndInApplicationOfTheDatatype Type - -- ^ The target of a constructor isn't an application of its - -- datatype. The 'Type' records what it does target. - | ShouldBeAppliedToTheDatatypeParameters Term Term - -- ^ The target of a constructor isn't its datatype applied to - -- something that isn't the parameters. First term is the correct - -- target and the second term is the actual target. - | ShouldBeApplicationOf Type QName - -- ^ Expected a type to be an application of a particular datatype. - | ConstructorPatternInWrongDatatype QName QName -- ^ constructor, datatype - | CantResolveOverloadedConstructorsTargetingSameDatatype QName [QName] - -- ^ Datatype, constructors. - | DoesNotConstructAnElementOf QName Type -- ^ constructor, type - | WrongHidingInLHS - -- ^ The left hand side of a function definition has a hidden argument - -- where a non-hidden was expected. - | WrongHidingInLambda Type - -- ^ Expected a non-hidden function and found a hidden lambda. - | WrongHidingInApplication Type - -- ^ A function is applied to a hidden argument where a non-hidden was expected. - | WrongNamedArgument (NamedArg A.Expr) - -- ^ A function is applied to a hidden named argument it does not have. - | WrongIrrelevanceInLambda - -- ^ Wrong user-given relevance annotation in lambda. - | WrongQuantityInLambda - -- ^ Wrong user-given quantity annotation in lambda. - | HidingMismatch Hiding Hiding - -- ^ The given hiding does not correspond to the expected hiding. - | RelevanceMismatch Relevance Relevance - -- ^ The given relevance does not correspond to the expected relevane. - | UninstantiatedDotPattern A.Expr - | ForcedConstructorNotInstantiated A.Pattern - | IlltypedPattern A.Pattern Type - | IllformedProjectionPattern A.Pattern - | CannotEliminateWithPattern (NamedArg A.Pattern) Type - | WrongNumberOfConstructorArguments QName Nat Nat - | ShouldBeEmpty Type [DeBruijnPattern] - | ShouldBeASort Type - -- ^ The given type should have been a sort. - | ShouldBePi Type - -- ^ The given type should have been a pi. - | ShouldBePath Type - | ShouldBeRecordType Type - | ShouldBeRecordPattern DeBruijnPattern - | NotAProjectionPattern (NamedArg A.Pattern) - | NotAProperTerm - | InvalidTypeSort Sort - -- ^ This sort is not a type expression. - | InvalidType Term - -- ^ This term is not a type expression. - | FunctionTypeInSizeUniv Term - -- ^ This term, a function type constructor, lives in - -- @SizeUniv@, which is not allowed. - | SplitOnIrrelevant (Dom Type) - -- UNUSED: -- | SplitOnErased (Dom Type) - | SplitOnNonVariable Term Type - | DefinitionIsIrrelevant QName - | VariableIsIrrelevant Name - | VariableIsErased Name --- | UnequalLevel Comparison Term Term -- UNUSED - | UnequalTerms Comparison Term Term Type - | UnequalTypes Comparison Type Type --- | UnequalTelescopes Comparison Telescope Telescope -- UNUSED - | UnequalRelevance Comparison Term Term - -- ^ The two function types have different relevance. - | UnequalHiding Term Term - -- ^ The two function types have different hiding. - | UnequalSorts Sort Sort - | UnequalBecauseOfUniverseConflict Comparison Term Term - | NotLeqSort Sort Sort - | MetaCannotDependOn MetaId [Nat] Nat - -- ^ The arguments are the meta variable, the parameters it can - -- depend on and the paratemeter that it wants to depend on. - | MetaOccursInItself MetaId - | MetaIrrelevantSolution MetaId Term - | GenericError String - | GenericDocError Doc - | BuiltinMustBeConstructor String A.Expr - | NoSuchBuiltinName String - | DuplicateBuiltinBinding String Term Term - | NoBindingForBuiltin String - | NoSuchPrimitiveFunction String - | DuplicatePrimitiveBinding String QName QName - | ShadowedModule C.Name [A.ModuleName] - | BuiltinInParameterisedModule String - | IllegalLetInTelescope C.TypedBinding - | NoRHSRequiresAbsurdPattern [NamedArg A.Pattern] - | TooManyFields QName [C.Name] [C.Name] - -- ^ Record type, fields not supplied by user, non-fields not supplied. - | DuplicateFields [C.Name] - | DuplicateConstructors [C.Name] - | WithOnFreeVariable A.Expr Term - | UnexpectedWithPatterns [A.Pattern] - | WithClausePatternMismatch A.Pattern (NamedArg DeBruijnPattern) - | FieldOutsideRecord - | ModuleArityMismatch A.ModuleName Telescope [NamedArg A.Expr] - | GeneralizeCyclicDependency - | GeneralizeUnsolvedMeta - -- Coverage errors --- UNUSED: | IncompletePatternMatching Term [Elim] -- can only happen if coverage checking is switched off - | SplitError SplitError - | ImpossibleConstructor QName NegativeUnification - -- Positivity errors - | TooManyPolarities QName Int - -- Import errors - | LocalVsImportedModuleClash ModuleName - | SolvedButOpenHoles - -- ^ Some interaction points (holes) have not been filled by user. - -- There are not 'UnsolvedMetas' since unification solved them. - -- This is an error, since interaction points are never filled - -- without user interaction. - | CyclicModuleDependency [C.TopLevelModuleName] - | FileNotFound C.TopLevelModuleName [AbsolutePath] - | OverlappingProjects AbsolutePath C.TopLevelModuleName C.TopLevelModuleName - | AmbiguousTopLevelModuleName C.TopLevelModuleName [AbsolutePath] - | ModuleNameUnexpected C.TopLevelModuleName C.TopLevelModuleName - -- ^ Found module name, expected module name. - | ModuleNameDoesntMatchFileName C.TopLevelModuleName [AbsolutePath] - | ClashingFileNamesFor ModuleName [AbsolutePath] - | ModuleDefinedInOtherFile C.TopLevelModuleName AbsolutePath AbsolutePath - -- ^ Module name, file from which it was loaded, file which - -- the include path says contains the module. - -- Scope errors - | BothWithAndRHS - | AbstractConstructorNotInScope A.QName - | NotInScope [C.QName] - | NoSuchModule C.QName - | AmbiguousName C.QName (NonemptyList A.QName) - | AmbiguousModule C.QName (NonemptyList A.ModuleName) - | ClashingDefinition C.QName A.QName - | ClashingModule A.ModuleName A.ModuleName - | ClashingImport C.Name A.QName - | ClashingModuleImport C.Name A.ModuleName - | PatternShadowsConstructor C.Name A.QName - | DuplicateImports C.QName [C.ImportedName] - | InvalidPattern C.Pattern - | RepeatedVariablesInPattern [C.Name] - | GeneralizeNotSupportedHere A.QName - | MultipleFixityDecls [(C.Name, [Fixity'])] - | MultiplePolarityPragmas [C.Name] - -- Concrete to Abstract errors - | NotAModuleExpr C.Expr - -- ^ The expr was used in the right hand side of an implicit module - -- definition, but it wasn't of the form @m Delta@. - | NotAnExpression C.Expr - | NotAValidLetBinding NiceDeclaration - | NotValidBeforeField NiceDeclaration - | NothingAppliedToHiddenArg C.Expr - | NothingAppliedToInstanceArg C.Expr - -- Pattern synonym errors - | BadArgumentsToPatternSynonym A.AmbiguousQName - | TooFewArgumentsToPatternSynonym A.AmbiguousQName - | CannotResolveAmbiguousPatternSynonym (NonemptyList (A.QName, A.PatternSynDefn)) - | UnusedVariableInPatternSynonym - -- Operator errors - | NoParseForApplication [C.Expr] - | AmbiguousParseForApplication [C.Expr] [C.Expr] - | NoParseForLHS LHSOrPatSyn C.Pattern - | AmbiguousParseForLHS LHSOrPatSyn C.Pattern [C.Pattern] - | OperatorInformation [NotationSection] TypeError -{- UNUSED - | NoParseForPatternSynonym C.Pattern - | AmbiguousParseForPatternSynonym C.Pattern [C.Pattern] --} - -- Usage errors - -- Instance search errors - | InstanceNoCandidate Type [(Term, TCErr)] - -- Reflection errors - | UnquoteFailed UnquoteError - | DeBruijnIndexOutOfScope Nat Telescope [Name] - -- Language option errors - | NeedOptionCopatterns - | NeedOptionRewriting - | NeedOptionProp - -- Failure associated to warnings - | NonFatalErrors [TCWarning] - -- Instance search errors - | InstanceSearchDepthExhausted Term Type Int - | TriedToCopyConstrainedPrim QName - deriving Show - --- | Distinguish error message when parsing lhs or pattern synonym, resp. -data LHSOrPatSyn = IsLHS | IsPatSyn deriving (Eq, Show) - --- | Type-checking errors. - -data TCErr - = TypeError - { tcErrState :: TCState - -- ^ The state in which the error was raised. - , tcErrClosErr :: Closure TypeError - -- ^ The environment in which the error as raised plus the error. - } - | Exception Range Doc - | IOException TCState Range E.IOException - -- ^ The first argument is the state in which the error was - -- raised. - | PatternErr - -- ^ The exception which is usually caught. - -- Raised for pattern violations during unification ('assignV') - -- but also in other situations where we want to backtrack. - -instance Error TCErr where - strMsg = Exception noRange . text . strMsg - -instance Show TCErr where - show (TypeError _ e) = show (envRange $ clEnv e) ++ ": " ++ show (clValue e) - show (Exception r d) = show r ++ ": " ++ render d - show (IOException _ r e) = show r ++ ": " ++ show e - show PatternErr{} = "Pattern violation (you shouldn't see this)" - -instance HasRange TCErr where - getRange (TypeError _ cl) = envRange $ clEnv cl - getRange (Exception r _) = r - getRange (IOException s r _) = r - getRange PatternErr{} = noRange - -instance E.Exception TCErr - ------------------------------------------------------------------------------ --- * Accessing options ------------------------------------------------------------------------------ - -class (Functor m, Applicative m, Monad m) => HasOptions m where - -- | Returns the pragma options which are currently in effect. - pragmaOptions :: m PragmaOptions - -- | Returns the command line options which are currently in effect. - commandLineOptions :: m CommandLineOptions - -instance MonadIO m => HasOptions (TCMT m) where - pragmaOptions = useTC stPragmaOptions - - commandLineOptions = do - p <- useTC stPragmaOptions - cl <- stPersistentOptions . stPersistentState <$> getTC - return $ cl { optPragmaOptions = p } - -instance HasOptions m => HasOptions (ExceptT e m) where - pragmaOptions = lift pragmaOptions - commandLineOptions = lift commandLineOptions - -instance HasOptions m => HasOptions (ListT m) where - pragmaOptions = lift pragmaOptions - commandLineOptions = lift commandLineOptions - -instance HasOptions m => HasOptions (MaybeT m) where - pragmaOptions = lift pragmaOptions - commandLineOptions = lift commandLineOptions - -instance HasOptions m => HasOptions (ReaderT r m) where - pragmaOptions = lift pragmaOptions - commandLineOptions = lift commandLineOptions - -instance HasOptions m => HasOptions (StateT s m) where - pragmaOptions = lift pragmaOptions - commandLineOptions = lift commandLineOptions - -instance (HasOptions m, Monoid w) => HasOptions (WriterT w m) where - pragmaOptions = lift pragmaOptions - commandLineOptions = lift commandLineOptions - --- Ternary options are annoying to deal with so we provide auxiliary --- definitions using @collapseDefault@. - -sizedTypesOption :: HasOptions m => m Bool -sizedTypesOption = collapseDefault . optSizedTypes <$> pragmaOptions - -guardednessOption :: HasOptions m => m Bool -guardednessOption = collapseDefault . optGuardedness <$> pragmaOptions - -withoutKOption :: HasOptions m => m Bool -withoutKOption = collapseDefault . optWithoutK <$> pragmaOptions - ------------------------------------------------------------------------------ --- * The reduce monad ------------------------------------------------------------------------------ - --- | Environment of the reduce monad. -data ReduceEnv = ReduceEnv - { redEnv :: TCEnv -- ^ Read only access to environment. - , redSt :: TCState -- ^ Read only access to state (signature, metas...). - } - -mapRedEnv :: (TCEnv -> TCEnv) -> ReduceEnv -> ReduceEnv -mapRedEnv f s = s { redEnv = f (redEnv s) } - -mapRedSt :: (TCState -> TCState) -> ReduceEnv -> ReduceEnv -mapRedSt f s = s { redSt = f (redSt s) } - -mapRedEnvSt :: (TCEnv -> TCEnv) -> (TCState -> TCState) -> ReduceEnv - -> ReduceEnv -mapRedEnvSt f g (ReduceEnv e s) = ReduceEnv (f e) (g s) - --- Lenses -reduceEnv :: Lens' TCEnv ReduceEnv -reduceEnv f s = f (redEnv s) <&> \ e -> s { redEnv = e } - -reduceSt :: Lens' TCState ReduceEnv -reduceSt f s = f (redSt s) <&> \ e -> s { redSt = e } - -newtype ReduceM a = ReduceM { unReduceM :: ReduceEnv -> a } --- deriving (Functor, Applicative, Monad) - -onReduceEnv :: (ReduceEnv -> ReduceEnv) -> ReduceM a -> ReduceM a -onReduceEnv f (ReduceM m) = ReduceM (m . f) - -fmapReduce :: (a -> b) -> ReduceM a -> ReduceM b -fmapReduce f (ReduceM m) = ReduceM $ \ e -> f $! m e -{-# INLINE fmapReduce #-} - -apReduce :: ReduceM (a -> b) -> ReduceM a -> ReduceM b -apReduce (ReduceM f) (ReduceM x) = ReduceM $ \ e -> f e $! x e -{-# INLINE apReduce #-} - -bindReduce :: ReduceM a -> (a -> ReduceM b) -> ReduceM b -bindReduce (ReduceM m) f = ReduceM $ \ e -> unReduceM (f $! m e) e -{-# INLINE bindReduce #-} - -instance Functor ReduceM where - fmap = fmapReduce - -instance Applicative ReduceM where - pure x = ReduceM (const x) - (<*>) = apReduce - -instance Monad ReduceM where - return = pure - (>>=) = bindReduce - (>>) = (*>) -#if __GLASGOW_HASKELL__ >= 800 - fail = Fail.fail - -instance Fail.MonadFail ReduceM where - fail = error -#endif - -instance ReadTCState ReduceM where - getTCState = ReduceM redSt - withTCState f = onReduceEnv $ mapRedSt f - -runReduceM :: ReduceM a -> TCM a -runReduceM m = do - e <- askTC - s <- getTC - return $! unReduceM m (ReduceEnv e s) - -runReduceF :: (a -> ReduceM b) -> TCM (a -> b) -runReduceF f = do - e <- askTC - s <- getTC - return $ \x -> unReduceM (f x) (ReduceEnv e s) - -instance MonadTCEnv ReduceM where - askTC = ReduceM redEnv - localTC = onReduceEnv . mapRedEnv - -useR :: (ReadTCState m) => Lens' a TCState -> m a -useR l = (^.l) <$> getTCState - -askR :: ReduceM ReduceEnv -askR = ReduceM ask - -localR :: (ReduceEnv -> ReduceEnv) -> ReduceM a -> ReduceM a -localR f = ReduceM . local f . unReduceM - -instance HasOptions ReduceM where - pragmaOptions = useR stPragmaOptions - commandLineOptions = do - p <- useR stPragmaOptions - cl <- stPersistentOptions . stPersistentState <$> getTCState - return $ cl{ optPragmaOptions = p } - -class ( Applicative m - , MonadTCEnv m - , ReadTCState m - , HasOptions m - ) => MonadReduce m where - liftReduce :: ReduceM a -> m a - -instance MonadReduce m => MonadReduce (MaybeT m) where - liftReduce = lift . liftReduce - -instance MonadReduce m => MonadReduce (ListT m) where - liftReduce = lift . liftReduce - -instance MonadReduce m => MonadReduce (ExceptT err m) where - liftReduce = lift . liftReduce - -instance MonadReduce m => MonadReduce (ReaderT r m) where - liftReduce = lift . liftReduce - -instance (Monoid w, MonadReduce m) => MonadReduce (WriterT w m) where - liftReduce = lift . liftReduce - -instance MonadReduce m => MonadReduce (StateT w m) where - liftReduce = lift . liftReduce - -instance MonadReduce ReduceM where - liftReduce = id - ---------------------------------------------------------------------------- --- * Monad with read-only 'TCEnv' ---------------------------------------------------------------------------- - --- | @MonadTCEnv@ made into its own dedicated service class. --- This allows us to use 'MonadReader' for 'ReaderT' extensions of @TCM@. -class Monad m => MonadTCEnv m where - askTC :: m TCEnv - localTC :: (TCEnv -> TCEnv) -> m a -> m a - -instance MonadTCEnv m => MonadTCEnv (MaybeT m) where - askTC = lift askTC - localTC = mapMaybeT . localTC - -instance MonadTCEnv m => MonadTCEnv (ListT m) where - askTC = lift askTC - localTC = mapListT . localTC - -instance MonadTCEnv m => MonadTCEnv (ExceptT err m) where - askTC = lift askTC - localTC = mapExceptT . localTC - -instance MonadTCEnv m => MonadTCEnv (ReaderT r m) where - askTC = lift askTC - localTC = mapReaderT . localTC - -instance (Monoid w, MonadTCEnv m) => MonadTCEnv (WriterT w m) where - askTC = lift askTC - localTC = mapWriterT . localTC - -instance MonadTCEnv m => MonadTCEnv (StateT s m) where - askTC = lift askTC - localTC = mapStateT . localTC - -asksTC :: MonadTCEnv m => (TCEnv -> a) -> m a -asksTC f = f <$> askTC - -viewTC :: MonadTCEnv m => Lens' a TCEnv -> m a -viewTC l = asksTC (^. l) - --- | Modify the lens-indicated part of the @TCEnv@ in a subcomputation. -locallyTC :: MonadTCEnv m => Lens' a TCEnv -> (a -> a) -> m b -> m b -locallyTC l = localTC . over l - ---------------------------------------------------------------------------- --- * Monad with mutable 'TCState' ---------------------------------------------------------------------------- - --- | @MonadTCState@ made into its own dedicated service class. --- This allows us to use 'MonadState' for 'StateT' extensions of @TCM@. -class Monad m => MonadTCState m where - getTC :: m TCState - putTC :: TCState -> m () - modifyTC :: (TCState -> TCState) -> m () - - {-# MINIMAL getTC, (putTC | modifyTC) #-} - putTC = modifyTC . const - modifyTC f = putTC . f =<< getTC - -instance MonadTCState m => MonadTCState (MaybeT m) where - getTC = lift getTC - putTC = lift . putTC - modifyTC = lift . modifyTC - -instance MonadTCState m => MonadTCState (ListT m) where - getTC = lift getTC - putTC = lift . putTC - modifyTC = lift . modifyTC - -instance MonadTCState m => MonadTCState (ExceptT err m) where - getTC = lift getTC - putTC = lift . putTC - modifyTC = lift . modifyTC - -instance MonadTCState m => MonadTCState (ReaderT r m) where - getTC = lift getTC - putTC = lift . putTC - modifyTC = lift . modifyTC - -instance (Monoid w, MonadTCState m) => MonadTCState (WriterT w m) where - getTC = lift getTC - putTC = lift . putTC - modifyTC = lift . modifyTC - -instance MonadTCState m => MonadTCState (StateT s m) where - getTC = lift getTC - putTC = lift . putTC - modifyTC = lift . modifyTC - --- ** @TCState@ accessors (no lenses) - -getsTC :: MonadTCState m => (TCState -> a) -> m a -getsTC f = f <$> getTC - --- | A variant of 'modifyTC' in which the computation is strict in the --- new state. -modifyTC' :: MonadTCState m => (TCState -> TCState) -> m () -modifyTC' f = do - s' <- getTC - putTC $! f s' - --- SEE TC.Monad.State --- -- | Restore the 'TCState' after computation. --- localTCState :: MonadTCState m => m a -> m a --- localTCState = bracket_ getTC putTC - --- ** @TCState@ accessors via lenses - -useTC :: MonadTCState m => Lens' a TCState -> m a -useTC l = do - !x <- getsTC (^. l) - return x - -infix 4 `setTCLens` - --- | Overwrite the part of the 'TCState' focused on by the lens. -setTCLens :: MonadTCState m => Lens' a TCState -> a -> m () -setTCLens l = modifyTC . set l - --- | Modify the part of the 'TCState' focused on by the lens. -modifyTCLens :: MonadTCState m => Lens' a TCState -> (a -> a) -> m () -modifyTCLens l = modifyTC . over l - --- | Modify a part of the state monadically. -modifyTCLensM :: MonadTCState m => Lens' a TCState -> (a -> m a) -> m () -modifyTCLensM l f = putTC =<< l f =<< getTC - --- | Modify the lens-indicated part of the 'TCState' locally. -locallyTCState :: MonadTCState m => Lens' a TCState -> (a -> a) -> m b -> m b -locallyTCState l f k = do - old <- useTC l - modifyTCLens l f - x <- k - setTCLens l old - return x - - ---------------------------------------------------------------------------- --- * Type checking monad transformer ---------------------------------------------------------------------------- - --- | The type checking monad transformer. --- Adds readonly 'TCEnv' and mutable 'TCState'. -newtype TCMT m a = TCM { unTCM :: IORef TCState -> TCEnv -> m a } - -instance MonadIO m => MonadTCEnv (TCMT m) where - askTC = TCM $ \ _ e -> return e - localTC f (TCM m) = TCM $ \ s e -> m s (f e) - -instance MonadIO m => MonadTCState (TCMT m) where - getTC = TCM $ \ r _e -> liftIO (readIORef r) - putTC s = TCM $ \ r _e -> liftIO (writeIORef r s) - -type TCM = TCMT IO - -class ( Applicative tcm, MonadIO tcm - , MonadTCEnv tcm - , MonadTCState tcm - , HasOptions tcm - ) => MonadTCM tcm where - liftTCM :: TCM a -> tcm a - -instance MonadIO m => ReadTCState (TCMT m) where - getTCState = getTC - withTCState f m = __IMPOSSIBLE__ -- should probably not be used - -instance MonadError TCErr (TCMT IO) where - throwError = liftIO . E.throwIO - catchError m h = TCM $ \r e -> do - oldState <- liftIO (readIORef r) - unTCM m r e `E.catch` \err -> do - -- Reset the state, but do not forget changes to the persistent - -- component. Not for pattern violations. - case err of - PatternErr -> return () - _ -> - liftIO $ do - newState <- readIORef r - writeIORef r $ oldState { stPersistentState = stPersistentState newState } - unTCM (h err) r e - -instance MonadIO m => MonadReduce (TCMT m) where - liftReduce = liftTCM . runReduceM - -instance (IsString a, MonadIO m) => IsString (TCMT m a) where - fromString s = return (fromString s) - --- | Interaction monad. - -type IM = TCMT (Haskeline.InputT IO) - -runIM :: IM a -> TCM a -runIM = mapTCMT (Haskeline.runInputT Haskeline.defaultSettings) - -instance MonadError TCErr IM where - throwError = liftIO . E.throwIO - catchError m h = mapTCMT liftIO $ runIM m `catchError` (runIM . h) - --- | Preserve the state of the failing computation. -catchError_ :: TCM a -> (TCErr -> TCM a) -> TCM a -catchError_ m h = TCM $ \r e -> - unTCM m r e - `E.catch` \err -> unTCM (h err) r e - --- | Execute a finalizer even when an exception is thrown. --- Does not catch any errors. --- In case both the regular computation and the finalizer --- throw an exception, the one of the finalizer is propagated. -finally_ :: TCM a -> TCM b -> TCM a -finally_ m f = do - x <- m `catchError_` \ err -> f >> throwError err - _ <- f - return x - -{-# SPECIALIZE INLINE mapTCMT :: (forall a. IO a -> IO a) -> TCM a -> TCM a #-} -mapTCMT :: (forall a. m a -> n a) -> TCMT m a -> TCMT n a -mapTCMT f (TCM m) = TCM $ \s e -> f (m s e) - -pureTCM :: MonadIO m => (TCState -> TCEnv -> a) -> TCMT m a -pureTCM f = TCM $ \r e -> do - s <- liftIO $ readIORef r - return (f s e) - -{-# RULES "liftTCM/id" liftTCM = id #-} -instance MonadIO m => MonadTCM (TCMT m) where - liftTCM = mapTCMT liftIO - -instance MonadTCM tcm => MonadTCM (MaybeT tcm) where - liftTCM = lift . liftTCM - -instance MonadTCM tcm => MonadTCM (ListT tcm) where - liftTCM = lift . liftTCM - -instance MonadTCM tcm => MonadTCM (ExceptT err tcm) where - liftTCM = lift . liftTCM - -instance (Monoid w, MonadTCM tcm) => MonadTCM (WriterT w tcm) where - liftTCM = lift . liftTCM - -instance (MonadTCM tcm) => MonadTCM (StateT s tcm) where - liftTCM = lift . liftTCM - -instance (MonadTCM tcm) => MonadTCM (ReaderT r tcm) where - liftTCM = lift . liftTCM - -instance MonadTrans TCMT where - lift m = TCM $ \_ _ -> m - --- We want a special monad implementation of fail. -instance MonadIO m => Monad (TCMT m) where - return = pure - (>>=) = bindTCMT - (>>) = (*>) -#if __GLASGOW_HASKELL__ < 800 - fail = internalError -#else - fail = Fail.fail - -instance MonadIO m => Fail.MonadFail (TCMT m) where - fail = internalError -#endif - --- One goal of the definitions and pragmas below is to inline the --- monad operations as much as possible. This doesn't seem to have a --- large effect on the performance of the normal executable, but (at --- least on one machine/configuration) it has a massive effect on the --- performance of the profiling executable [1], and reduces the time --- attributed to bind from over 90% to about 25%. --- --- [1] When compiled with -auto-all and run with -p: roughly 750% --- faster for one example. - -returnTCMT :: MonadIO m => a -> TCMT m a -returnTCMT = \x -> TCM $ \_ _ -> return x -{-# INLINE returnTCMT #-} - -bindTCMT :: MonadIO m => TCMT m a -> (a -> TCMT m b) -> TCMT m b -bindTCMT = \(TCM m) k -> TCM $ \r e -> m r e >>= \x -> unTCM (k x) r e -{-# INLINE bindTCMT #-} - -thenTCMT :: MonadIO m => TCMT m a -> TCMT m b -> TCMT m b -thenTCMT = \(TCM m1) (TCM m2) -> TCM $ \r e -> m1 r e >> m2 r e -{-# INLINE thenTCMT #-} - -instance MonadIO m => Functor (TCMT m) where - fmap = fmapTCMT - -fmapTCMT :: MonadIO m => (a -> b) -> TCMT m a -> TCMT m b -fmapTCMT = \f (TCM m) -> TCM $ \r e -> liftM f (m r e) -{-# INLINE fmapTCMT #-} - -instance MonadIO m => Applicative (TCMT m) where - pure = returnTCMT - (<*>) = apTCMT - -apTCMT :: MonadIO m => TCMT m (a -> b) -> TCMT m a -> TCMT m b -apTCMT = \(TCM mf) (TCM m) -> TCM $ \r e -> ap (mf r e) (m r e) -{-# INLINE apTCMT #-} - -instance MonadIO m => MonadIO (TCMT m) where - liftIO m = TCM $ \s e -> do - let r = envRange e - liftIO $ wrap s r $ do - x <- m - x `seq` return x - where - wrap s r m = E.catch m $ \e -> do - s <- readIORef s - E.throwIO $ IOException s r e - --- | We store benchmark statistics in an IORef. --- This enables benchmarking pure computation, see --- "Agda.Benchmarking". -instance MonadBench Phase TCM where - getBenchmark = liftIO $ getBenchmark - putBenchmark = liftIO . putBenchmark - finally = finally_ - -instance Null (TCM Doc) where - empty = return empty - null = __IMPOSSIBLE__ - --- | Short-cutting disjunction forms a monoid. -instance Semigroup (TCM Any) where - ma <> mb = Any <$> do (getAny <$> ma) `or2M` (getAny <$> mb) - -instance Monoid (TCM Any) where - mempty = return mempty - mappend = (<>) - -patternViolation :: TCM a -patternViolation = throwError PatternErr - -internalError :: MonadTCM tcm => String -> tcm a -internalError s = typeError $ InternalError s - -genericError :: MonadTCM tcm => String -> tcm a -genericError = typeError . GenericError - -{-# SPECIALIZE genericDocError :: Doc -> TCM a #-} -genericDocError :: MonadTCM tcm => Doc -> tcm a -genericDocError = typeError . GenericDocError - -{-# SPECIALIZE typeError :: TypeError -> TCM a #-} -typeError :: MonadTCM tcm => TypeError -> tcm a -typeError err = liftTCM $ throwError =<< typeError_ err - -{-# SPECIALIZE typeError_ :: TypeError -> TCM TCErr #-} -typeError_ :: MonadTCM tcm => TypeError -> tcm TCErr -typeError_ err = liftTCM $ TypeError <$> getTC <*> buildClosure err - --- | Running the type checking monad (most general form). -{-# SPECIALIZE runTCM :: TCEnv -> TCState -> TCM a -> IO (a, TCState) #-} -runTCM :: MonadIO m => TCEnv -> TCState -> TCMT m a -> m (a, TCState) -runTCM e s m = do - r <- liftIO $ newIORef s - a <- unTCM m r e - s <- liftIO $ readIORef r - return (a, s) - --- | Running the type checking monad on toplevel (with initial state). -runTCMTop :: TCM a -> IO (Either TCErr a) -runTCMTop m = (Right <$> runTCMTop' m) `E.catch` (return . Left) - -runTCMTop' :: MonadIO m => TCMT m a -> m a -runTCMTop' m = do - r <- liftIO $ newIORef initState - unTCM m r initEnv - --- | 'runSafeTCM' runs a safe 'TCM' action (a 'TCM' action which cannot fail) --- in the initial environment. - -runSafeTCM :: TCM a -> TCState -> IO (a, TCState) -runSafeTCM m st = runTCM initEnv st m `E.catch` (\ (e :: TCErr) -> __IMPOSSIBLE__) --- runSafeTCM m st = either__IMPOSSIBLE__ return <$> do --- -- Errors must be impossible. --- runTCM $ do --- putTC st --- a <- m --- st <- getTC --- return (a, st) - --- | Runs the given computation in a separate thread, with /a copy/ of --- the current state and environment. --- --- Note that Agda sometimes uses actual, mutable state. If the --- computation given to @forkTCM@ tries to /modify/ this state, then --- bad things can happen, because accesses are not mutually exclusive. --- The @forkTCM@ function has been added mainly to allow the thread to --- /read/ (a snapshot of) the current state in a convenient way. --- --- Note also that exceptions which are raised in the thread are not --- propagated to the parent, so the thread should not do anything --- important. - -forkTCM :: TCM a -> TCM () -forkTCM m = do - s <- getTC - e <- askTC - liftIO $ void $ C.forkIO $ void $ runTCM e s m - - --- | Base name for extended lambda patterns -extendedLambdaName :: String -extendedLambdaName = ".extendedlambda" - --- | Check whether we have an definition from an extended lambda. -isExtendedLambdaName :: A.QName -> Bool -isExtendedLambdaName = (extendedLambdaName `List.isPrefixOf`) . prettyShow . nameConcrete . qnameName - --- | Name of absurdLambda definitions. -absurdLambdaName :: String -absurdLambdaName = ".absurdlambda" - --- | Check whether we have an definition from an absurd lambda. -isAbsurdLambdaName :: QName -> Bool -isAbsurdLambdaName = (absurdLambdaName ==) . prettyShow . qnameName - --- | Base name for generalized variable projections -generalizedFieldName :: String -generalizedFieldName = ".generalizedField-" - --- | Check whether we have a generalized variable field -getGeneralizedFieldName :: A.QName -> Maybe String -getGeneralizedFieldName q - | List.isPrefixOf generalizedFieldName strName = Just (drop (length generalizedFieldName) strName) - | otherwise = Nothing - where strName = prettyShow $ nameConcrete $ qnameName q - ---------------------------------------------------------------------------- --- * KillRange instances ---------------------------------------------------------------------------- - -instance KillRange Signature where - killRange (Sig secs defs rews) = killRange2 Sig secs defs rews - -instance KillRange Sections where - killRange = fmap killRange - -instance KillRange Definitions where - killRange = fmap killRange - -instance KillRange RewriteRuleMap where - killRange = fmap killRange - -instance KillRange Section where - killRange (Section tel) = killRange1 Section tel - -instance KillRange Definition where - killRange (Defn ai name t pols occs gens gpars displ mut compiled inst copy ma nc inj def) = - killRange16 Defn ai name t pols occs gens gpars displ mut compiled inst copy ma nc inj def - -- TODO clarify: Keep the range in the defName field? - -instance KillRange NumGeneralizableArgs where - killRange = id - -instance KillRange NLPat where - killRange (PVar x y) = killRange2 PVar x y - killRange (PWild) = PWild - killRange (PDef x y) = killRange2 PDef x y - killRange (PLam x y) = killRange2 PLam x y - killRange (PPi x y) = killRange2 PPi x y - killRange (PBoundVar x y) = killRange2 PBoundVar x y - killRange (PTerm x) = killRange1 PTerm x - -instance KillRange NLPType where - killRange (NLPType s a) = killRange2 NLPType s a - -instance KillRange RewriteRule where - killRange (RewriteRule q gamma f es rhs t) = - killRange6 RewriteRule q gamma f es rhs t - -instance KillRange CompiledRepresentation where - killRange = id - - -instance KillRange EtaEquality where - killRange = id - -instance KillRange System where - killRange (System tel sys) = System (killRange tel) (killRange sys) - -instance KillRange ExtLamInfo where - killRange (ExtLamInfo m sys) = killRange2 ExtLamInfo m sys - -instance KillRange FunctionFlag where - killRange = id - -instance KillRange CompKit where - killRange = id - -instance KillRange Defn where - killRange def = - case def of - Axiom -> Axiom - DataOrRecSig n -> DataOrRecSig n - GeneralizableVar -> GeneralizableVar - AbstractDefn{} -> __IMPOSSIBLE__ -- only returned by 'getConstInfo'! - Function cls comp ct tt covering inv mut isAbs delayed proj flags term extlam with copat -> - killRange15 Function cls comp ct tt covering inv mut isAbs delayed proj flags term extlam with copat - Datatype a b c d e f g h i -> killRange8 Datatype a b c d e f g h i - Record a b c d e f g h i j k -> killRange11 Record a b c d e f g h i j k - Constructor a b c d e f g h i -> killRange9 Constructor a b c d e f g h i +{-# LANGUAGE CPP #-} +{-# LANGUAGE BangPatterns #-} +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE TypeFamilies #-} -- for type equality ~ + +module Agda.TypeChecking.Monad.Base where + +import Prelude hiding (null) + +import qualified Control.Concurrent as C +import qualified Control.Exception as E + +import qualified Control.Monad.Fail as Fail + +import Control.Monad.State +import Control.Monad.Reader +import Control.Monad.Writer hiding ((<>)) +import Control.Monad.Trans.Identity +import Control.Monad.Trans.Maybe +import Control.Applicative hiding (empty) + +import Data.Array (Ix) +import Data.Function +import Data.Int +import Data.IntMap (IntMap) +import qualified Data.IntMap as IntMap +import qualified Data.List as List +import Data.List.NonEmpty (NonEmpty(..)) +import qualified Data.List.NonEmpty as NonEmpty +import Data.Maybe +import Data.Map (Map) +import qualified Data.Map as Map -- hiding (singleton, null, empty) +import Data.Monoid ( Monoid, mempty, mappend ) +import Data.Sequence (Seq) +import Data.Set (Set) +import qualified Data.Set as Set -- hiding (singleton, null, empty) +import Data.HashMap.Strict (HashMap) +import qualified Data.HashMap.Strict as HMap +import Data.Semigroup ( Semigroup, (<>)) --, Any(..) ) +import Data.Data (Data, toConstr) +import Data.Foldable (Foldable) +import Data.String +import Data.Text.Lazy (Text) +import qualified Data.Text.Lazy as T + +import Data.IORef + +import qualified System.Console.Haskeline as Haskeline + +import Agda.Benchmarking (Benchmark, Phase) + +import Agda.Syntax.Concrete (TopLevelModuleName) +import Agda.Syntax.Common +import qualified Agda.Syntax.Concrete as C +import Agda.Syntax.Concrete.Definitions + (NiceDeclaration, DeclarationWarning, declarationWarningName) +import qualified Agda.Syntax.Abstract as A +import Agda.Syntax.Abstract (AllNames) +import Agda.Syntax.Internal as I +import Agda.Syntax.Internal.Generic (TermLike(..)) +import Agda.Syntax.Parser (ParseWarning) +import Agda.Syntax.Parser.Monad (parseWarningName) +import Agda.Syntax.Treeless (Compiled) +import Agda.Syntax.Notation +import Agda.Syntax.Position +import Agda.Syntax.Scope.Base +import qualified Agda.Syntax.Info as Info + +import Agda.TypeChecking.CompiledClause +import Agda.TypeChecking.Coverage.SplitTree +import Agda.TypeChecking.Positivity.Occurrence +import Agda.TypeChecking.Free.Lazy (Free(freeVars'), underBinder', underBinder) + +-- Args, defined in Agda.Syntax.Treeless and exported from Agda.Compiler.Backend +-- conflicts with Args, defined in Agda.Syntax.Internal and also imported here. +-- This only matters when interpreted in ghci, which sees all of the module's +-- exported symbols, not just the ones defined in the `.hs-boot`. See the +-- comment in ../../Compiler/Backend.hs-boot +import {-# SOURCE #-} Agda.Compiler.Backend hiding (Args) + +import Agda.Interaction.Options +import Agda.Interaction.Options.Warnings +import {-# SOURCE #-} Agda.Interaction.Response + (InteractionOutputCallback, defaultInteractionOutputCallback) +import Agda.Interaction.Highlighting.Precise + (CompressedFile, HighlightingInfo) +import Agda.Interaction.Library + +import Agda.Utils.Benchmark (MonadBench(..)) +import Agda.Utils.Except + ( Error(strMsg) + , ExceptT + , MonadError(catchError, throwError) + , mapExceptT + ) +import Agda.Utils.FileName +import Agda.Utils.Functor +import Agda.Utils.Hash +import Agda.Utils.Lens +import Agda.Utils.List +import Agda.Utils.ListT +import qualified Agda.Utils.Maybe.Strict as Strict +import Agda.Utils.Monad +import Agda.Utils.Null +import Agda.Utils.Permutation +import Agda.Utils.Pretty +import Agda.Utils.Singleton +import Agda.Utils.SmallSet (SmallSet) +import qualified Agda.Utils.SmallSet as SmallSet +import Agda.Utils.Update +import Agda.Utils.WithDefault ( collapseDefault ) + +import Agda.Utils.Impossible + +--------------------------------------------------------------------------- +-- * Type checking state +--------------------------------------------------------------------------- + +data TCState = TCSt + { stPreScopeState :: !PreScopeState + -- ^ The state which is frozen after scope checking. + , stPostScopeState :: !PostScopeState + -- ^ The state which is modified after scope checking. + , stPersistentState :: !PersistentTCState + -- ^ State which is forever, like a diamond. + } + +class Monad m => ReadTCState m where + getTCState :: m TCState + locallyTCState :: Lens' a TCState -> (a -> a) -> m b -> m b + + withTCState :: (TCState -> TCState) -> m a -> m a + withTCState = locallyTCState id + +instance ReadTCState m => ReadTCState (MaybeT m) where + getTCState = lift getTCState + locallyTCState l = mapMaybeT . locallyTCState l + +instance ReadTCState m => ReadTCState (ListT m) where + getTCState = lift getTCState + locallyTCState l f = ListT . locallyTCState l f . runListT + +instance ReadTCState m => ReadTCState (ExceptT err m) where + getTCState = lift getTCState + locallyTCState l = mapExceptT . locallyTCState l + +instance ReadTCState m => ReadTCState (ReaderT r m) where + getTCState = lift getTCState + locallyTCState l = mapReaderT . locallyTCState l + +instance (Monoid w, ReadTCState m) => ReadTCState (WriterT w m) where + getTCState = lift getTCState + locallyTCState l = mapWriterT . locallyTCState l + +instance ReadTCState m => ReadTCState (StateT s m) where + getTCState = lift getTCState + locallyTCState l = mapStateT . locallyTCState l + +instance Show TCState where + show _ = "TCSt{}" + +data PreScopeState = PreScopeState + { stPreTokens :: !CompressedFile -- from lexer + -- ^ Highlighting info for tokens (but not those tokens for + -- which highlighting exists in 'stSyntaxInfo'). + , stPreImports :: !Signature -- XX populated by scope checker + -- ^ Imported declared identifiers. + -- Those most not be serialized! + , stPreImportedModules :: !(Set ModuleName) -- imports logic + , stPreModuleToSource :: !ModuleToSource -- imports + , stPreVisitedModules :: !VisitedModules -- imports + , stPreScope :: !ScopeInfo + -- generated by scope checker, current file: + -- which modules you have, public definitions, current file, maps concrete names to abstract names. + , stPrePatternSyns :: !A.PatternSynDefns + -- ^ Pattern synonyms of the current file. Serialized. + , stPrePatternSynImports :: !A.PatternSynDefns + -- ^ Imported pattern synonyms. Must not be serialized! + , stPreGeneralizedVars :: !(Strict.Maybe (Set QName)) + -- ^ Collected generalizable variables; used during scope checking of terms + , stPrePragmaOptions :: !PragmaOptions + -- ^ Options applying to the current file. @OPTIONS@ + -- pragmas only affect this field. + , stPreImportedBuiltins :: !(BuiltinThings PrimFun) + , stPreImportedDisplayForms :: !DisplayForms + -- ^ Display forms added by someone else to imported identifiers + , stPreImportedInstanceDefs :: !InstanceTable + , stPreForeignCode :: !(Map BackendName [ForeignCode]) + -- ^ @{-\# FOREIGN \#-}@ code that should be included in the compiled output. + -- Does not include code for imported modules. + , stPreFreshInteractionId :: !InteractionId + , stPreImportedUserWarnings :: !(Map A.QName String) + -- ^ Imported @UserWarning@s, not to be stored in the @Interface@ + , stPreLocalUserWarnings :: !(Map A.QName String) + -- ^ Locally defined @UserWarning@s, to be stored in the @Interface@ + , stPreWarningOnImport :: !(Strict.Maybe String) + -- ^ Whether the current module should raise a warning when opened + , stPreImportedPartialDefs :: !(Set QName) + -- ^ Imported partial definitions, not to be stored in the @Interface@ + } + +type DisambiguatedNames = IntMap A.QName + +type ConcreteNames = Map Name [C.Name] + +data PostScopeState = PostScopeState + { stPostSyntaxInfo :: !CompressedFile + -- ^ Highlighting info. + , stPostDisambiguatedNames :: !DisambiguatedNames + -- ^ Disambiguation carried out by the type checker. + -- Maps position of first name character to disambiguated @'A.QName'@ + -- for each @'A.AmbiguousQName'@ already passed by the type checker. + , stPostMetaStore :: !MetaStore + , stPostInteractionPoints :: !InteractionPoints -- scope checker first + , stPostAwakeConstraints :: !Constraints + , stPostSleepingConstraints :: !Constraints + , stPostDirty :: !Bool -- local + -- ^ Dirty when a constraint is added, used to prevent pointer update. + -- Currently unused. + , stPostOccursCheckDefs :: !(Set QName) -- local + -- ^ Definitions to be considered during occurs check. + -- Initialized to the current mutual block before the check. + -- During occurs check, we remove definitions from this set + -- as soon we have checked them. + , stPostSignature :: !Signature + -- ^ Declared identifiers of the current file. + -- These will be serialized after successful type checking. + , stPostModuleCheckpoints :: !(Map ModuleName CheckpointId) + -- ^ For each module remember the checkpoint corresponding to the orignal + -- context of the module parameters. + , stPostImportsDisplayForms :: !DisplayForms + -- ^ Display forms we add for imported identifiers + , stPostCurrentModule :: !(Strict.Maybe ModuleName) + -- ^ The current module is available after it has been type + -- checked. + , stPostInstanceDefs :: !TempInstanceTable + , stPostConcreteNames :: !ConcreteNames + -- ^ Map keeping track of concrete names assigned to each abstract name + -- (can be more than one name in case the first one is shadowed) + , stPostUsedNames :: !(Map RawName [RawName]) + -- ^ Map keeping track for each name root (= name w/o numeric + -- suffixes) what names with the same root have been used during a + -- TC computation. This information is used to build the + -- @ShadowingNames@ map. + , stPostShadowingNames :: !(Map Name [RawName]) + -- ^ Map keeping track for each (abstract) name the list of all + -- (raw) names that it could maybe be shadowed by. + , stPostStatistics :: !Statistics + -- ^ Counters to collect various statistics about meta variables etc. + -- Only for current file. + , stPostTCWarnings :: ![TCWarning] + , stPostMutualBlocks :: !(Map MutualId MutualBlock) + , stPostLocalBuiltins :: !(BuiltinThings PrimFun) + , stPostFreshMetaId :: !MetaId + , stPostFreshMutualId :: !MutualId + , stPostFreshProblemId :: !ProblemId + , stPostFreshCheckpointId :: !CheckpointId + , stPostFreshInt :: !Int + , stPostFreshNameId :: !NameId + , stPostAreWeCaching :: !Bool + , stPostPostponeInstanceSearch :: !Bool + , stPostConsideringInstance :: !Bool + , stPostInstantiateBlocking :: !Bool + -- ^ Should we instantiate away blocking metas? + -- This can produce ill-typed terms but they are often more readable. See issue #3606. + -- Best set to True only for calls to pretty*/reify to limit unwanted reductions. + , stPostLocalPartialDefs :: !(Set QName) + -- ^ Local partial definitions, to be stored in the @Interface@ + } + +-- | A mutual block of names in the signature. +data MutualBlock = MutualBlock + { mutualInfo :: Info.MutualInfo + -- ^ The original info of the mutual block. + , mutualNames :: Set QName + } deriving (Show, Eq) + +instance Null MutualBlock where + empty = MutualBlock empty empty + +-- | A part of the state which is not reverted when an error is thrown +-- or the state is reset. +data PersistentTCState = PersistentTCSt + { stDecodedModules :: DecodedModules + , stPersistentOptions :: CommandLineOptions + , stInteractionOutputCallback :: InteractionOutputCallback + -- ^ Callback function to call when there is a response + -- to give to the interactive frontend. + -- See the documentation of 'InteractionOutputCallback'. + , stBenchmark :: !Benchmark + -- ^ Structure to track how much CPU time was spent on which Agda phase. + -- Needs to be a strict field to avoid space leaks! + , stAccumStatistics :: !Statistics + -- ^ Should be strict field. + , stPersistLoadedFileCache :: !(Strict.Maybe LoadedFileCache) + -- ^ Cached typechecking state from the last loaded file. + -- Should be @Nothing@ when checking imports. + , stPersistBackends :: [Backend] + -- ^ Current backends with their options + } + +data LoadedFileCache = LoadedFileCache + { lfcCached :: !CachedTypeCheckLog + , lfcCurrent :: !CurrentTypeCheckLog + } + +-- | A log of what the type checker does and states after the action is +-- completed. The cached version is stored first executed action first. +type CachedTypeCheckLog = [(TypeCheckAction, PostScopeState)] + +-- | Like 'CachedTypeCheckLog', but storing the log for an ongoing type +-- checking of a module. Stored in reverse order (last performed action +-- first). +type CurrentTypeCheckLog = [(TypeCheckAction, PostScopeState)] + +-- | A complete log for a module will look like this: +-- +-- * 'Pragmas' +-- +-- * 'EnterSection', entering the main module. +-- +-- * 'Decl'/'EnterSection'/'LeaveSection', for declarations and nested +-- modules +-- +-- * 'LeaveSection', leaving the main module. +data TypeCheckAction + = EnterSection !Info.ModuleInfo !ModuleName !A.Telescope + | LeaveSection !ModuleName + | Decl !A.Declaration + -- ^ Never a Section or ScopeDecl + | Pragmas !PragmaOptions + +-- | Empty persistent state. + +initPersistentState :: PersistentTCState +initPersistentState = PersistentTCSt + { stPersistentOptions = defaultOptions + , stDecodedModules = Map.empty + , stInteractionOutputCallback = defaultInteractionOutputCallback + , stBenchmark = empty + , stAccumStatistics = Map.empty + , stPersistLoadedFileCache = empty + , stPersistBackends = [] + } + +-- | Empty state of type checker. + +initPreScopeState :: PreScopeState +initPreScopeState = PreScopeState + { stPreTokens = mempty + , stPreImports = emptySignature + , stPreImportedModules = Set.empty + , stPreModuleToSource = Map.empty + , stPreVisitedModules = Map.empty + , stPreScope = emptyScopeInfo + , stPrePatternSyns = Map.empty + , stPrePatternSynImports = Map.empty + , stPreGeneralizedVars = mempty + , stPrePragmaOptions = defaultInteractionOptions + , stPreImportedBuiltins = Map.empty + , stPreImportedDisplayForms = HMap.empty + , stPreImportedInstanceDefs = Map.empty + , stPreForeignCode = Map.empty + , stPreFreshInteractionId = 0 + , stPreImportedUserWarnings = Map.empty + , stPreLocalUserWarnings = Map.empty + , stPreWarningOnImport = empty + , stPreImportedPartialDefs = Set.empty + } + +initPostScopeState :: PostScopeState +initPostScopeState = PostScopeState + { stPostSyntaxInfo = mempty + , stPostDisambiguatedNames = IntMap.empty + , stPostMetaStore = IntMap.empty + , stPostInteractionPoints = Map.empty + , stPostAwakeConstraints = [] + , stPostSleepingConstraints = [] + , stPostDirty = False + , stPostOccursCheckDefs = Set.empty + , stPostSignature = emptySignature + , stPostModuleCheckpoints = Map.empty + , stPostImportsDisplayForms = HMap.empty + , stPostCurrentModule = empty + , stPostInstanceDefs = (Map.empty , Set.empty) + , stPostConcreteNames = Map.empty + , stPostUsedNames = Map.empty + , stPostShadowingNames = Map.empty + , stPostStatistics = Map.empty + , stPostTCWarnings = [] + , stPostMutualBlocks = Map.empty + , stPostLocalBuiltins = Map.empty + , stPostFreshMetaId = 0 + , stPostFreshMutualId = 0 + , stPostFreshProblemId = 1 + , stPostFreshCheckpointId = 1 + , stPostFreshInt = 0 + , stPostFreshNameId = NameId 0 0 + , stPostAreWeCaching = False + , stPostPostponeInstanceSearch = False + , stPostConsideringInstance = False + , stPostInstantiateBlocking = False + , stPostLocalPartialDefs = Set.empty + } + +initState :: TCState +initState = TCSt + { stPreScopeState = initPreScopeState + , stPostScopeState = initPostScopeState + , stPersistentState = initPersistentState + } + +-- * st-prefixed lenses +------------------------------------------------------------------------ + +stTokens :: Lens' CompressedFile TCState +stTokens f s = + f (stPreTokens (stPreScopeState s)) <&> + \x -> s {stPreScopeState = (stPreScopeState s) {stPreTokens = x}} + +stImports :: Lens' Signature TCState +stImports f s = + f (stPreImports (stPreScopeState s)) <&> + \x -> s {stPreScopeState = (stPreScopeState s) {stPreImports = x}} + +stImportedModules :: Lens' (Set ModuleName) TCState +stImportedModules f s = + f (stPreImportedModules (stPreScopeState s)) <&> + \x -> s {stPreScopeState = (stPreScopeState s) {stPreImportedModules = x}} + +stModuleToSource :: Lens' ModuleToSource TCState +stModuleToSource f s = + f (stPreModuleToSource (stPreScopeState s)) <&> + \x -> s {stPreScopeState = (stPreScopeState s) {stPreModuleToSource = x}} + +stVisitedModules :: Lens' VisitedModules TCState +stVisitedModules f s = + f (stPreVisitedModules (stPreScopeState s)) <&> + \x -> s {stPreScopeState = (stPreScopeState s) {stPreVisitedModules = x}} + +stScope :: Lens' ScopeInfo TCState +stScope f s = + f (stPreScope (stPreScopeState s)) <&> + \x -> s {stPreScopeState = (stPreScopeState s) {stPreScope = x}} + +stPatternSyns :: Lens' A.PatternSynDefns TCState +stPatternSyns f s = + f (stPrePatternSyns (stPreScopeState s)) <&> + \x -> s {stPreScopeState = (stPreScopeState s) {stPrePatternSyns = x}} + +stPatternSynImports :: Lens' A.PatternSynDefns TCState +stPatternSynImports f s = + f (stPrePatternSynImports (stPreScopeState s)) <&> + \x -> s {stPreScopeState = (stPreScopeState s) {stPrePatternSynImports = x}} + +stGeneralizedVars :: Lens' (Maybe (Set QName)) TCState +stGeneralizedVars f s = + f (Strict.toLazy $ stPreGeneralizedVars (stPreScopeState s)) <&> + \x -> s {stPreScopeState = (stPreScopeState s) {stPreGeneralizedVars = Strict.toStrict x}} + +stPragmaOptions :: Lens' PragmaOptions TCState +stPragmaOptions f s = + f (stPrePragmaOptions (stPreScopeState s)) <&> + \x -> s {stPreScopeState = (stPreScopeState s) {stPrePragmaOptions = x}} + +stImportedBuiltins :: Lens' (BuiltinThings PrimFun) TCState +stImportedBuiltins f s = + f (stPreImportedBuiltins (stPreScopeState s)) <&> + \x -> s {stPreScopeState = (stPreScopeState s) {stPreImportedBuiltins = x}} + +stForeignCode :: Lens' (Map BackendName [ForeignCode]) TCState +stForeignCode f s = + f (stPreForeignCode (stPreScopeState s)) <&> + \x -> s {stPreScopeState = (stPreScopeState s) {stPreForeignCode = x}} + +stFreshInteractionId :: Lens' InteractionId TCState +stFreshInteractionId f s = + f (stPreFreshInteractionId (stPreScopeState s)) <&> + \x -> s {stPreScopeState = (stPreScopeState s) {stPreFreshInteractionId = x}} + +stImportedUserWarnings :: Lens' (Map A.QName String) TCState +stImportedUserWarnings f s = + f (stPreImportedUserWarnings (stPreScopeState s)) <&> + \ x -> s {stPreScopeState = (stPreScopeState s) {stPreImportedUserWarnings = x}} + +stLocalUserWarnings :: Lens' (Map A.QName String) TCState +stLocalUserWarnings f s = + f (stPreLocalUserWarnings (stPreScopeState s)) <&> + \ x -> s {stPreScopeState = (stPreScopeState s) {stPreLocalUserWarnings = x}} + +getUserWarnings :: ReadTCState m => m (Map A.QName String) +getUserWarnings = do + iuw <- useR stImportedUserWarnings + luw <- useR stLocalUserWarnings + return $ iuw `Map.union` luw + +stWarningOnImport :: Lens' (Maybe String) TCState +stWarningOnImport f s = + f (Strict.toLazy $ stPreWarningOnImport (stPreScopeState s)) <&> + \ x -> s {stPreScopeState = (stPreScopeState s) {stPreWarningOnImport = Strict.toStrict x}} + +stImportedPartialDefs :: Lens' (Set QName) TCState +stImportedPartialDefs f s = + f (stPreImportedPartialDefs (stPreScopeState s)) <&> + \ x -> s {stPreScopeState = (stPreScopeState s) {stPreImportedPartialDefs = x}} + +stLocalPartialDefs :: Lens' (Set QName) TCState +stLocalPartialDefs f s = + f (stPostLocalPartialDefs (stPostScopeState s)) <&> + \ x -> s {stPostScopeState = (stPostScopeState s) {stPostLocalPartialDefs = x}} + +getPartialDefs :: ReadTCState m => m (Set QName) +getPartialDefs = do + ipd <- useR stImportedPartialDefs + lpd <- useR stLocalPartialDefs + return $ ipd `Set.union` lpd + +stLoadedFileCache :: Lens' (Maybe LoadedFileCache) TCState +stLoadedFileCache f s = + f (Strict.toLazy $ stPersistLoadedFileCache (stPersistentState s)) <&> + \x -> s {stPersistentState = (stPersistentState s) {stPersistLoadedFileCache = Strict.toStrict x}} + +stBackends :: Lens' [Backend] TCState +stBackends f s = + f (stPersistBackends (stPersistentState s)) <&> + \x -> s {stPersistentState = (stPersistentState s) {stPersistBackends = x}} + +stFreshNameId :: Lens' NameId TCState +stFreshNameId f s = + f (stPostFreshNameId (stPostScopeState s)) <&> + \x -> s {stPostScopeState = (stPostScopeState s) {stPostFreshNameId = x}} + +stSyntaxInfo :: Lens' CompressedFile TCState +stSyntaxInfo f s = + f (stPostSyntaxInfo (stPostScopeState s)) <&> + \x -> s {stPostScopeState = (stPostScopeState s) {stPostSyntaxInfo = x}} + +stDisambiguatedNames :: Lens' DisambiguatedNames TCState +stDisambiguatedNames f s = + f (stPostDisambiguatedNames (stPostScopeState s)) <&> + \x -> s {stPostScopeState = (stPostScopeState s) {stPostDisambiguatedNames = x}} + +stMetaStore :: Lens' MetaStore TCState +stMetaStore f s = + f (stPostMetaStore (stPostScopeState s)) <&> + \x -> s {stPostScopeState = (stPostScopeState s) {stPostMetaStore = x}} + +stInteractionPoints :: Lens' InteractionPoints TCState +stInteractionPoints f s = + f (stPostInteractionPoints (stPostScopeState s)) <&> + \x -> s {stPostScopeState = (stPostScopeState s) {stPostInteractionPoints = x}} + +stAwakeConstraints :: Lens' Constraints TCState +stAwakeConstraints f s = + f (stPostAwakeConstraints (stPostScopeState s)) <&> + \x -> s {stPostScopeState = (stPostScopeState s) {stPostAwakeConstraints = x}} + +stSleepingConstraints :: Lens' Constraints TCState +stSleepingConstraints f s = + f (stPostSleepingConstraints (stPostScopeState s)) <&> + \x -> s {stPostScopeState = (stPostScopeState s) {stPostSleepingConstraints = x}} + +stDirty :: Lens' Bool TCState +stDirty f s = + f (stPostDirty (stPostScopeState s)) <&> + \x -> s {stPostScopeState = (stPostScopeState s) {stPostDirty = x}} + +stOccursCheckDefs :: Lens' (Set QName) TCState +stOccursCheckDefs f s = + f (stPostOccursCheckDefs (stPostScopeState s)) <&> + \x -> s {stPostScopeState = (stPostScopeState s) {stPostOccursCheckDefs = x}} + +stSignature :: Lens' Signature TCState +stSignature f s = + f (stPostSignature (stPostScopeState s)) <&> + \x -> s {stPostScopeState = (stPostScopeState s) {stPostSignature = x}} + +stModuleCheckpoints :: Lens' (Map ModuleName CheckpointId) TCState +stModuleCheckpoints f s = + f (stPostModuleCheckpoints (stPostScopeState s)) <&> + \x -> s {stPostScopeState = (stPostScopeState s) {stPostModuleCheckpoints = x}} + +stImportsDisplayForms :: Lens' DisplayForms TCState +stImportsDisplayForms f s = + f (stPostImportsDisplayForms (stPostScopeState s)) <&> + \x -> s {stPostScopeState = (stPostScopeState s) {stPostImportsDisplayForms = x}} + +stImportedDisplayForms :: Lens' DisplayForms TCState +stImportedDisplayForms f s = + f (stPreImportedDisplayForms (stPreScopeState s)) <&> + \x -> s {stPreScopeState = (stPreScopeState s) {stPreImportedDisplayForms = x}} + +stCurrentModule :: Lens' (Maybe ModuleName) TCState +stCurrentModule f s = + f (Strict.toLazy $ stPostCurrentModule (stPostScopeState s)) <&> + \x -> s {stPostScopeState = (stPostScopeState s) {stPostCurrentModule = Strict.toStrict x}} + +stImportedInstanceDefs :: Lens' InstanceTable TCState +stImportedInstanceDefs f s = + f (stPreImportedInstanceDefs (stPreScopeState s)) <&> + \x -> s {stPreScopeState = (stPreScopeState s) {stPreImportedInstanceDefs = x}} + +stInstanceDefs :: Lens' TempInstanceTable TCState +stInstanceDefs f s = + f (stPostInstanceDefs (stPostScopeState s)) <&> + \x -> s {stPostScopeState = (stPostScopeState s) {stPostInstanceDefs = x}} + +stConcreteNames :: Lens' ConcreteNames TCState +stConcreteNames f s = + f (stPostConcreteNames (stPostScopeState s)) <&> + \x -> s {stPostScopeState = (stPostScopeState s) {stPostConcreteNames = x}} + +stUsedNames :: Lens' (Map RawName [RawName]) TCState +stUsedNames f s = + f (stPostUsedNames (stPostScopeState s)) <&> + \x -> s {stPostScopeState = (stPostScopeState s) {stPostUsedNames = x}} + +stShadowingNames :: Lens' (Map Name [RawName]) TCState +stShadowingNames f s = + f (stPostShadowingNames (stPostScopeState s)) <&> + \x -> s {stPostScopeState = (stPostScopeState s) {stPostShadowingNames = x}} + +stStatistics :: Lens' Statistics TCState +stStatistics f s = + f (stPostStatistics (stPostScopeState s)) <&> + \x -> s {stPostScopeState = (stPostScopeState s) {stPostStatistics = x}} + +stTCWarnings :: Lens' [TCWarning] TCState +stTCWarnings f s = + f (stPostTCWarnings (stPostScopeState s)) <&> + \x -> s {stPostScopeState = (stPostScopeState s) {stPostTCWarnings = x}} + +stMutualBlocks :: Lens' (Map MutualId MutualBlock) TCState +stMutualBlocks f s = + f (stPostMutualBlocks (stPostScopeState s)) <&> + \x -> s {stPostScopeState = (stPostScopeState s) {stPostMutualBlocks = x}} + +stLocalBuiltins :: Lens' (BuiltinThings PrimFun) TCState +stLocalBuiltins f s = + f (stPostLocalBuiltins (stPostScopeState s)) <&> + \x -> s {stPostScopeState = (stPostScopeState s) {stPostLocalBuiltins = x}} + +stFreshMetaId :: Lens' MetaId TCState +stFreshMetaId f s = + f (stPostFreshMetaId (stPostScopeState s)) <&> + \x -> s {stPostScopeState = (stPostScopeState s) {stPostFreshMetaId = x}} + +stFreshMutualId :: Lens' MutualId TCState +stFreshMutualId f s = + f (stPostFreshMutualId (stPostScopeState s)) <&> + \x -> s {stPostScopeState = (stPostScopeState s) {stPostFreshMutualId = x}} + +stFreshProblemId :: Lens' ProblemId TCState +stFreshProblemId f s = + f (stPostFreshProblemId (stPostScopeState s)) <&> + \x -> s {stPostScopeState = (stPostScopeState s) {stPostFreshProblemId = x}} + +stFreshCheckpointId :: Lens' CheckpointId TCState +stFreshCheckpointId f s = + f (stPostFreshCheckpointId (stPostScopeState s)) <&> + \x -> s {stPostScopeState = (stPostScopeState s) {stPostFreshCheckpointId = x}} + +stFreshInt :: Lens' Int TCState +stFreshInt f s = + f (stPostFreshInt (stPostScopeState s)) <&> + \x -> s {stPostScopeState = (stPostScopeState s) {stPostFreshInt = x}} + +-- use @areWeCaching@ from the Caching module instead. +stAreWeCaching :: Lens' Bool TCState +stAreWeCaching f s = + f (stPostAreWeCaching (stPostScopeState s)) <&> + \x -> s {stPostScopeState = (stPostScopeState s) {stPostAreWeCaching = x}} + +stPostponeInstanceSearch :: Lens' Bool TCState +stPostponeInstanceSearch f s = + f (stPostPostponeInstanceSearch (stPostScopeState s)) <&> + \x -> s {stPostScopeState = (stPostScopeState s) {stPostPostponeInstanceSearch = x}} + +stConsideringInstance :: Lens' Bool TCState +stConsideringInstance f s = + f (stPostConsideringInstance (stPostScopeState s)) <&> + \x -> s {stPostScopeState = (stPostScopeState s) {stPostConsideringInstance = x}} + +stInstantiateBlocking :: Lens' Bool TCState +stInstantiateBlocking f s = + f (stPostInstantiateBlocking (stPostScopeState s)) <&> + \x -> s {stPostScopeState = (stPostScopeState s) {stPostInstantiateBlocking = x}} + +stBuiltinThings :: TCState -> BuiltinThings PrimFun +stBuiltinThings s = (s^.stLocalBuiltins) `Map.union` (s^.stImportedBuiltins) + + +-- * Fresh things +------------------------------------------------------------------------ + +class Enum i => HasFresh i where + freshLens :: Lens' i TCState + nextFresh' :: i -> i + nextFresh' = succ + +nextFresh :: HasFresh i => TCState -> (i, TCState) +nextFresh s = + let !c = s^.freshLens + in (c, set freshLens (nextFresh' c) s) + +class Monad m => MonadFresh i m where + fresh :: m i + +instance MonadFresh i m => MonadFresh i (ReaderT r m) where + fresh = lift fresh + +instance MonadFresh i m => MonadFresh i (StateT s m) where + fresh = lift fresh + +instance HasFresh i => MonadFresh i TCM where + fresh = do + !s <- getTC + let (!c , !s') = nextFresh s + putTC s' + return c + +instance HasFresh MetaId where + freshLens = stFreshMetaId + +instance HasFresh MutualId where + freshLens = stFreshMutualId + +instance HasFresh InteractionId where + freshLens = stFreshInteractionId + +instance HasFresh NameId where + freshLens = stFreshNameId + -- nextFresh increments the current fresh name by 2 so @NameId@s used + -- before caching starts do not overlap with the ones used after. + nextFresh' = succ . succ + +instance HasFresh Int where + freshLens = stFreshInt + +newtype ProblemId = ProblemId Nat + deriving (Data, Eq, Ord, Enum, Real, Integral, Num) + +-- TODO: 'Show' should output Haskell-parseable representations. +-- The following instance is deprecated, and Pretty[TCM] should be used +-- instead. Later, simply derive Show for this type. + +-- ASR (28 December 2014). This instance is not used anymore (module +-- the test suite) when reporting errors. See Issue 1293. + +-- This particular Show instance is ok because of the Num instance. +instance Show ProblemId where + show (ProblemId n) = show n + +instance Pretty ProblemId where + pretty (ProblemId n) = pretty n + +instance HasFresh ProblemId where + freshLens = stFreshProblemId + +newtype CheckpointId = CheckpointId Int + deriving (Data, Eq, Ord, Enum, Real, Integral, Num) + +instance Show CheckpointId where + show (CheckpointId n) = show n + +instance Pretty CheckpointId where + pretty (CheckpointId n) = pretty n + +instance HasFresh CheckpointId where + freshLens = stFreshCheckpointId + +freshName :: MonadFresh NameId m => Range -> String -> m Name +freshName r s = do + i <- fresh + return $ mkName r i s + +freshNoName :: MonadFresh NameId m => Range -> m Name +freshNoName r = + do i <- fresh + return $ Name i (C.NoName noRange i) r noFixity' False + +freshNoName_ :: MonadFresh NameId m => m Name +freshNoName_ = freshNoName noRange + +freshRecordName :: MonadFresh NameId m => m Name +freshRecordName = do + i <- fresh + return $ Name i (C.Name noRange C.NotInScope [C.Id "r"]) noRange noFixity' True + +-- | Create a fresh name from @a@. +class FreshName a where + freshName_ :: MonadFresh NameId m => a -> m Name + +instance FreshName (Range, String) where + freshName_ = uncurry freshName + +instance FreshName String where + freshName_ = freshName noRange + +instance FreshName Range where + freshName_ = freshNoName + +instance FreshName () where + freshName_ () = freshNoName_ + +--------------------------------------------------------------------------- +-- ** Managing file names +--------------------------------------------------------------------------- + +-- | Maps top-level module names to the corresponding source file +-- names. + +type ModuleToSource = Map TopLevelModuleName AbsolutePath + +-- | Maps source file names to the corresponding top-level module +-- names. + +type SourceToModule = Map AbsolutePath TopLevelModuleName + +-- | Creates a 'SourceToModule' map based on 'stModuleToSource'. +-- +-- O(n log n). +-- +-- For a single reverse lookup in 'stModuleToSource', +-- rather use 'lookupModuleFromSourse'. + +sourceToModule :: TCM SourceToModule +sourceToModule = + Map.fromList + . List.map (\(m, f) -> (f, m)) + . Map.toList + <$> useTC stModuleToSource + +-- | Lookup an 'AbsolutePath' in 'sourceToModule'. +-- +-- O(n). + +lookupModuleFromSource :: ReadTCState m => AbsolutePath -> m (Maybe TopLevelModuleName) +lookupModuleFromSource f = + fmap fst . List.find ((f ==) . snd) . Map.toList <$> useR stModuleToSource + + +--------------------------------------------------------------------------- +-- ** Associating concrete names to an abstract name +--------------------------------------------------------------------------- + +-- | A monad that has read and write access to the stConcreteNames +-- part of the TCState. Basically, this is a synonym for `MonadState +-- ConcreteNames m` (which cannot be used directly because of the +-- limitations of Haskell's typeclass system). +class Monad m => MonadStConcreteNames m where + runStConcreteNames :: StateT ConcreteNames m a -> m a + + useConcreteNames :: m ConcreteNames + useConcreteNames = runStConcreteNames get + + modifyConcreteNames :: (ConcreteNames -> ConcreteNames) -> m () + modifyConcreteNames = runStConcreteNames . modify + +instance MonadStConcreteNames TCM where + runStConcreteNames m = stateTCLensM stConcreteNames $ runStateT m + +instance MonadStConcreteNames m => MonadStConcreteNames (ReaderT r m) where + runStConcreteNames m = ReaderT $ runStConcreteNames . StateT . (flip $ runReaderT . runStateT m) + +instance MonadStConcreteNames m => MonadStConcreteNames (StateT s m) where + runStConcreteNames m = StateT $ \s -> runStConcreteNames $ StateT $ \ns -> do + ((x,ns'),s') <- runStateT (runStateT m ns) s + return ((x,s'),ns') + +--------------------------------------------------------------------------- +-- ** Interface +--------------------------------------------------------------------------- + +data ModuleInfo = ModuleInfo + { miInterface :: Interface + , miWarnings :: Bool + -- ^ 'True' if warnings were encountered when the module was type + -- checked. + , miPrimitive :: Bool + -- ^ 'True' if the module is a primitive module, which should always + -- be importable. + } + +-- Note that the use of 'C.TopLevelModuleName' here is a potential +-- performance problem, because these names do not contain unique +-- identifiers. + +type VisitedModules = Map C.TopLevelModuleName ModuleInfo +type DecodedModules = Map C.TopLevelModuleName Interface + +data ForeignCode = ForeignCode Range String + deriving Show + +data Interface = Interface + { iSourceHash :: Hash + -- ^ Hash of the source code. + , iSource :: Text + -- ^ The source code. The source code is stored so that the HTML + -- and LaTeX backends can generate their output without having to + -- re-read the (possibly out of date) source code. + , iFileType :: FileType + -- ^ Source file type, determined from the file extension + , iImportedModules :: [(ModuleName, Hash)] + -- ^ Imported modules and their hashes. + , iModuleName :: ModuleName + -- ^ Module name of this interface. + , iScope :: Map ModuleName Scope + -- ^ Scope defined by this module. + -- + -- Andreas, AIM XX: Too avoid duplicate serialization, this field is + -- not serialized, so if you deserialize an interface, @iScope@ + -- will be empty. + -- But 'constructIScope' constructs 'iScope' from 'iInsideScope'. + , iInsideScope :: ScopeInfo + -- ^ Scope after we loaded this interface. + -- Used in 'Agda.Interaction.BasicOps.AtTopLevel' + -- and 'Agda.Interaction.CommandLine.interactionLoop'. + , iSignature :: Signature + , iDisplayForms :: DisplayForms + -- ^ Display forms added for imported identifiers. + , iUserWarnings :: Map A.QName String + -- ^ User warnings for imported identifiers + , iImportWarning :: Maybe String + -- ^ Whether this module should raise a warning when imported + , iBuiltin :: BuiltinThings (String, QName) + , iForeignCode :: Map BackendName [ForeignCode] + , iHighlighting :: HighlightingInfo + , iPragmaOptions :: [OptionsPragma] + -- ^ Pragma options set in the file. + , iOptionsUsed :: PragmaOptions + -- ^ Options/features used when checking the file (can be different + -- from options set directly in the file). + , iPatternSyns :: A.PatternSynDefns + , iWarnings :: [TCWarning] + , iPartialDefs :: Set QName + } + deriving Show + +instance Pretty Interface where + pretty (Interface + sourceH source fileT importedM moduleN scope insideS signature + display userwarn importwarn builtin foreignCode highlighting pragmaO + oUsed patternS warnings partialdefs) = + + hang "Interface" 2 $ vcat + [ "source hash:" <+> (pretty . show) sourceH + , "source:" $$ nest 2 (text $ T.unpack source) + , "file type:" <+> (pretty . show) fileT + , "imported modules:" <+> (pretty . show) importedM + , "module name:" <+> pretty moduleN + , "scope:" <+> (pretty . show) scope + , "inside scope:" <+> (pretty . show) insideS + , "signature:" <+> (pretty . show) signature + , "display:" <+> (pretty . show) display + , "user warnings:" <+> (pretty . show) userwarn + , "import warning:" <+> (pretty . show) importwarn + , "builtin:" <+> (pretty . show) builtin + , "Foreign code:" <+> (pretty . show) foreignCode + , "highlighting:" <+> (pretty . show) highlighting + , "pragma options:" <+> (pretty . show) pragmaO + , "options used:" <+> (pretty . show) oUsed + , "pattern syns:" <+> (pretty . show) patternS + , "warnings:" <+> (pretty . show) warnings + , "partial definitions:" <+> (pretty . show) partialdefs + ] + +-- | Combines the source hash and the (full) hashes of the imported modules. +iFullHash :: Interface -> Hash +iFullHash i = combineHashes $ iSourceHash i : List.map snd (iImportedModules i) + +--------------------------------------------------------------------------- +-- ** Closure +--------------------------------------------------------------------------- + +data Closure a = Closure + { clSignature :: Signature + , clEnv :: TCEnv + , clScope :: ScopeInfo + , clModuleCheckpoints :: Map ModuleName CheckpointId + , clValue :: a + } + deriving (Data, Functor, Foldable) + +instance Show a => Show (Closure a) where + show cl = "Closure { clValue = " ++ show (clValue cl) ++ " }" + +instance HasRange a => HasRange (Closure a) where + getRange = getRange . clValue + +class LensClosure a b | b -> a where + lensClosure :: Lens' (Closure a) b + +instance LensClosure a (Closure a) where + lensClosure = id + +instance LensTCEnv (Closure a) where + lensTCEnv f cl = (f $! clEnv cl) <&> \ env -> cl { clEnv = env } + +buildClosure :: (MonadTCEnv m, ReadTCState m) => a -> m (Closure a) +buildClosure x = do + env <- askTC + sig <- useR stSignature + scope <- useR stScope + cps <- useR stModuleCheckpoints + return $ Closure sig env scope cps x + +--------------------------------------------------------------------------- +-- ** Constraints +--------------------------------------------------------------------------- + +type Constraints = [ProblemConstraint] + +data ProblemConstraint = PConstr + { constraintProblems :: Set ProblemId + , theConstraint :: Closure Constraint + } + deriving (Data, Show) + +instance HasRange ProblemConstraint where + getRange = getRange . theConstraint + +data Constraint + = ValueCmp Comparison CompareAs Term Term + | ValueCmpOnFace Comparison Term Type Term Term + | ElimCmp [Polarity] [IsForced] Type Term [Elim] [Elim] + | TelCmp Type Type Comparison Telescope Telescope -- ^ the two types are for the error message only + | SortCmp Comparison Sort Sort + | LevelCmp Comparison Level Level +-- | ShortCut MetaId Term Type +-- -- ^ A delayed instantiation. Replaces @ValueCmp@ in 'postponeTypeCheckingProblem'. + | HasBiggerSort Sort + | HasPTSRule (Dom Type) (Abs Sort) + | CheckMetaInst MetaId + | UnBlock MetaId + | Guarded Constraint ProblemId + | IsEmpty Range Type + -- ^ The range is the one of the absurd pattern. + | CheckSizeLtSat Term + -- ^ Check that the 'Term' is either not a SIZELT or a non-empty SIZELT. + | FindInstance MetaId (Maybe MetaId) (Maybe [Candidate]) + -- ^ the first argument is the instance argument, the second one is the meta + -- on which the constraint may be blocked on and the third one is the list + -- of candidates (or Nothing if we haven’t determined the list of + -- candidates yet) + | CheckFunDef Delayed A.DefInfo QName [A.Clause] + | UnquoteTactic (Maybe MetaId) Term Term Type -- ^ First argument is computation and the others are hole and goal type + deriving (Data, Show) + +instance HasRange Constraint where + getRange (IsEmpty r t) = r + getRange _ = noRange +{- no Range instances for Term, Type, Elm, Tele, Sort, Level, MetaId + getRange (ValueCmp cmp a u v) = getRange (a,u,v) + getRange (ElimCmp pol a v es es') = getRange (a,v,es,es') + getRange (TelCmp a b cmp tel tel') = getRange (a,b,tel,tel') + getRange (SortCmp cmp s s') = getRange (s,s') + getRange (LevelCmp cmp l l') = getRange (l,l') + getRange (UnBlock x) = getRange x + getRange (Guarded c pid) = getRange c + getRange (FindInstance x cands) = getRange x +-} + +instance Free Constraint where + freeVars' c = + case c of + ValueCmp _ t u v -> freeVars' (t, (u, v)) + ValueCmpOnFace _ p t u v -> freeVars' (p, (t, (u, v))) + ElimCmp _ _ t u es es' -> freeVars' ((t, u), (es, es')) + TelCmp _ _ _ tel tel' -> freeVars' (tel, tel') + SortCmp _ s s' -> freeVars' (s, s') + LevelCmp _ l l' -> freeVars' (l, l') + UnBlock _ -> mempty + Guarded c _ -> freeVars' c + IsEmpty _ t -> freeVars' t + CheckSizeLtSat u -> freeVars' u + FindInstance _ _ cs -> freeVars' cs + CheckFunDef _ _ _ _ -> mempty + HasBiggerSort s -> freeVars' s + HasPTSRule a s -> freeVars' (a , s) + UnquoteTactic _ t h g -> freeVars' (t, (h, g)) + CheckMetaInst m -> mempty + +instance TermLike Constraint where + foldTerm f = \case + ValueCmp _ t u v -> foldTerm f (t, u, v) + ValueCmpOnFace _ p t u v -> foldTerm f (p, t, u, v) + ElimCmp _ _ t u es es' -> foldTerm f (t, u, es, es') + LevelCmp _ l l' -> foldTerm f (Level l, Level l') + IsEmpty _ t -> foldTerm f t + CheckSizeLtSat u -> foldTerm f u + UnquoteTactic _ t h g -> foldTerm f (t, h, g) + Guarded c _ -> foldTerm f c + TelCmp _ _ _ tel1 tel2 -> foldTerm f (tel1, tel2) + SortCmp _ s1 s2 -> foldTerm f (Sort s1, Sort s2) + UnBlock _ -> mempty + FindInstance _ _ _ -> mempty + CheckFunDef _ _ _ _ -> mempty + HasBiggerSort s -> foldTerm f s + HasPTSRule a s -> foldTerm f (a, Sort <$> s) + CheckMetaInst m -> mempty + traverseTermM f c = __IMPOSSIBLE__ -- Not yet implemented + + +data Comparison = CmpEq | CmpLeq + deriving (Eq, Data, Show) + +instance Pretty Comparison where + pretty CmpEq = "=" + pretty CmpLeq = "=<" + +-- | An extension of 'Comparison' to @>=@. +data CompareDirection = DirEq | DirLeq | DirGeq + deriving (Eq, Show) + +instance Pretty CompareDirection where + pretty = text . \case + DirEq -> "=" + DirLeq -> "=<" + DirGeq -> ">=" + +-- | Embed 'Comparison' into 'CompareDirection'. +fromCmp :: Comparison -> CompareDirection +fromCmp CmpEq = DirEq +fromCmp CmpLeq = DirLeq + +-- | Flip the direction of comparison. +flipCmp :: CompareDirection -> CompareDirection +flipCmp DirEq = DirEq +flipCmp DirLeq = DirGeq +flipCmp DirGeq = DirLeq + +-- | Turn a 'Comparison' function into a 'CompareDirection' function. +-- +-- Property: @dirToCmp f (fromCmp cmp) = f cmp@ +dirToCmp :: (Comparison -> a -> a -> c) -> CompareDirection -> a -> a -> c +dirToCmp cont DirEq = cont CmpEq +dirToCmp cont DirLeq = cont CmpLeq +dirToCmp cont DirGeq = flip $ cont CmpLeq + +-- | We can either compare two terms at a given type, or compare two +-- types without knowing (or caring about) their sorts. +data CompareAs + = AsTermsOf Type -- ^ @Type@ should not be @Size@. + -- But currently, we do not rely on this invariant. + | AsSizes -- ^ Replaces @AsTermsOf Size@. + | AsTypes + deriving (Data, Show) + +instance Free CompareAs where + freeVars' (AsTermsOf a) = freeVars' a + freeVars' AsSizes = mempty + freeVars' AsTypes = mempty + +instance TermLike CompareAs where + foldTerm f (AsTermsOf a) = foldTerm f a + foldTerm f AsSizes = mempty + foldTerm f AsTypes = mempty + + traverseTermM f = \case + AsTermsOf a -> AsTermsOf <$> traverseTermM f a + AsSizes -> return AsSizes + AsTypes -> return AsTypes + +--------------------------------------------------------------------------- +-- * Open things +--------------------------------------------------------------------------- + +-- | A thing tagged with the context it came from. +data Open a = OpenThing { openThingCheckpoint :: CheckpointId, openThing :: a } + deriving (Data, Show, Functor, Foldable, Traversable) + +instance Decoration Open where + traverseF f (OpenThing cp x) = OpenThing cp <$> f x + +--------------------------------------------------------------------------- +-- * Judgements +-- +-- Used exclusively for typing of meta variables. +--------------------------------------------------------------------------- + +-- | Parametrized since it is used without MetaId when creating a new meta. +data Judgement a + = HasType + { jMetaId :: a + , jComparison :: Comparison -- ^ are we checking (@CmpLeq@) or inferring (@CmpEq@) the type? + , jMetaType :: Type + } + | IsSort + { jMetaId :: a + , jMetaType :: Type -- Andreas, 2011-04-26: type needed for higher-order sort metas + } + +instance Show a => Show (Judgement a) where + show (HasType a cmp t) = show a ++ " : " ++ show t + show (IsSort a t) = show a ++ " :sort " ++ show t + +----------------------------------------------------------------------------- +-- ** Generalizable variables +----------------------------------------------------------------------------- + +data DoGeneralize = YesGeneralize | NoGeneralize + deriving (Eq, Ord, Show, Data) + +-- | The value of a generalizable variable. This is created to be a +-- generalizable meta before checking the type to be generalized. +data GeneralizedValue = GeneralizedValue + { genvalCheckpoint :: CheckpointId + , genvalTerm :: Term + , genvalType :: Type + } deriving (Show, Data) + +--------------------------------------------------------------------------- +-- ** Meta variables +--------------------------------------------------------------------------- + +data MetaVariable = + MetaVar { mvInfo :: MetaInfo + , mvPriority :: MetaPriority -- ^ some metavariables are more eager to be instantiated + , mvPermutation :: Permutation + -- ^ a metavariable doesn't have to depend on all variables + -- in the context, this "permutation" will throw away the + -- ones it does not depend on + , mvJudgement :: Judgement MetaId + , mvInstantiation :: MetaInstantiation + , mvListeners :: Set Listener -- ^ meta variables scheduled for eta-expansion but blocked by this one + , mvFrozen :: Frozen -- ^ are we past the point where we can instantiate this meta variable? + , mvTwin :: Maybe MetaId -- ^ @Just m@ means this meta will be equated to @m@ when the latter is unblocked. See @blockedTermOnProblem@. + } + +data Listener = EtaExpand MetaId + | CheckConstraint Nat ProblemConstraint + +instance Eq Listener where + EtaExpand x == EtaExpand y = x == y + CheckConstraint x _ == CheckConstraint y _ = x == y + _ == _ = False + +instance Ord Listener where + EtaExpand x `compare` EtaExpand y = x `compare` y + CheckConstraint x _ `compare` CheckConstraint y _ = x `compare` y + EtaExpand{} `compare` CheckConstraint{} = LT + CheckConstraint{} `compare` EtaExpand{} = GT + +-- | Frozen meta variable cannot be instantiated by unification. +-- This serves to prevent the completion of a definition by its use +-- outside of the current block. +-- (See issues 118, 288, 399). +data Frozen + = Frozen -- ^ Do not instantiate. + | Instantiable + deriving (Eq, Show) + +data MetaInstantiation + = InstV [Arg String] Term -- ^ solved by term (abstracted over some free variables) + | Open -- ^ unsolved + | OpenInstance -- ^ open, to be instantiated by instance search + | BlockedConst Term -- ^ solution blocked by unsolved constraints + | PostponedTypeCheckingProblem (Closure TypeCheckingProblem) (TCM Bool) + +-- | Solving a 'CheckArgs' constraint may or may not check the target type. If +-- it did, it returns a handle to any unsolved constraints. +data CheckedTarget = CheckedTarget (Maybe ProblemId) + | NotCheckedTarget + +data TypeCheckingProblem + = CheckExpr Comparison A.Expr Type + | CheckArgs ExpandHidden Range [NamedArg A.Expr] Type Type ([Maybe Range] -> Elims -> Type -> CheckedTarget -> TCM Term) + | CheckProjAppToKnownPrincipalArg Comparison A.Expr ProjOrigin (NonEmpty QName) A.Args Type Int Term Type + | CheckLambda Comparison (Arg ([WithHiding Name], Maybe Type)) A.Expr Type + -- ^ @(λ (xs : t₀) → e) : t@ + -- This is not an instance of 'CheckExpr' as the domain type + -- has already been checked. + -- For example, when checking + -- @(λ (x y : Fin _) → e) : (x : Fin n) → ?@ + -- we want to postpone @(λ (y : Fin n) → e) : ?@ where @Fin n@ + -- is a 'Type' rather than an 'A.Expr'. + | DoQuoteTerm Comparison Term Type -- ^ Quote the given term and check type against `Term` + +instance Show MetaInstantiation where + show (InstV tel t) = "InstV " ++ show tel ++ " (" ++ show t ++ ")" + show Open = "Open" + show OpenInstance = "OpenInstance" + show (BlockedConst t) = "BlockedConst (" ++ show t ++ ")" + show (PostponedTypeCheckingProblem{}) = "PostponedTypeCheckingProblem (...)" + +-- | Meta variable priority: +-- When we have an equation between meta-variables, which one +-- should be instantiated? +-- +-- Higher value means higher priority to be instantiated. +newtype MetaPriority = MetaPriority Int + deriving (Eq , Ord , Show) + +data RunMetaOccursCheck + = RunMetaOccursCheck + | DontRunMetaOccursCheck + deriving (Eq , Ord , Show) + +-- | @MetaInfo@ is cloned from one meta to the next during pruning. +data MetaInfo = MetaInfo + { miClosRange :: Closure Range -- TODO: Not so nice. But we want both to have the environment of the meta (Closure) and its range. +-- , miRelevance :: Relevance -- ^ Created in irrelevant position? + , miMetaOccursCheck :: RunMetaOccursCheck -- ^ Run the extended occurs check that goes in definitions? + , miNameSuggestion :: MetaNameSuggestion + -- ^ Used for printing. + -- @Just x@ if meta-variable comes from omitted argument with name @x@. + , miGeneralizable :: Arg DoGeneralize + -- ^ Should this meta be generalized if unsolved? If so, at what ArgInfo? + } + +-- | Name suggestion for meta variable. Empty string means no suggestion. +type MetaNameSuggestion = String + +-- | For printing, we couple a meta with its name suggestion. +data NamedMeta = NamedMeta + { nmSuggestion :: MetaNameSuggestion + , nmid :: MetaId + } + +instance Pretty NamedMeta where + pretty (NamedMeta "" x) = pretty x + pretty (NamedMeta "_" x) = pretty x + pretty (NamedMeta s x) = text $ "_" ++ s ++ prettyShow x + +type MetaStore = IntMap MetaVariable + +instance HasRange MetaInfo where + getRange = clValue . miClosRange + +instance HasRange MetaVariable where + getRange m = getRange $ getMetaInfo m + +instance SetRange MetaInfo where + setRange r m = m { miClosRange = (miClosRange m) { clValue = r }} + +instance SetRange MetaVariable where + setRange r m = m { mvInfo = setRange r (mvInfo m) } + +normalMetaPriority :: MetaPriority +normalMetaPriority = MetaPriority 0 + +lowMetaPriority :: MetaPriority +lowMetaPriority = MetaPriority (-10) + +highMetaPriority :: MetaPriority +highMetaPriority = MetaPriority 10 + +getMetaInfo :: MetaVariable -> Closure Range +getMetaInfo = miClosRange . mvInfo + +getMetaScope :: MetaVariable -> ScopeInfo +getMetaScope m = clScope $ getMetaInfo m + +getMetaEnv :: MetaVariable -> TCEnv +getMetaEnv m = clEnv $ getMetaInfo m + +getMetaSig :: MetaVariable -> Signature +getMetaSig m = clSignature $ getMetaInfo m + +getMetaRelevance :: MetaVariable -> Relevance +getMetaRelevance = getRelevance . getMetaEnv + +getMetaModality :: MetaVariable -> Modality +-- Andrea 23/02/2020: use getModality to enforce invariants of the +-- envModality field. +getMetaModality = getModality . getMetaEnv + +-- Lenses + +metaFrozen :: Lens' Frozen MetaVariable +metaFrozen f mv = f (mvFrozen mv) <&> \ x -> mv { mvFrozen = x } + +_mvInfo :: Lens' MetaInfo MetaVariable +_mvInfo f mv = (f $! mvInfo mv) <&> \ mi -> mv { mvInfo = mi } + +-- Lenses onto Closure Range + +instance LensClosure Range MetaInfo where + lensClosure f mi = (f $! miClosRange mi) <&> \ cl -> mi { miClosRange = cl } + +instance LensClosure Range MetaVariable where + lensClosure = _mvInfo . lensClosure + +-- Lenses onto IsAbstract + +instance LensIsAbstract TCEnv where + lensIsAbstract f env = + -- Andreas, 2019-08-19 + -- Using $! to prevent space leaks like #1829. + -- This can crash when trying to get IsAbstract from IgnoreAbstractMode. + (f $! fromMaybe __IMPOSSIBLE__ (aModeToDef $ envAbstractMode env)) + <&> \ a -> env { envAbstractMode = aDefToMode a } + +instance LensIsAbstract (Closure a) where + lensIsAbstract = lensTCEnv . lensIsAbstract + +instance LensIsAbstract MetaInfo where + lensIsAbstract = lensClosure . lensIsAbstract + +--------------------------------------------------------------------------- +-- ** Interaction meta variables +--------------------------------------------------------------------------- + +-- | Interaction points are created by the scope checker who sets the range. +-- The meta variable is created by the type checker and then hooked up to the +-- interaction point. +data InteractionPoint = InteractionPoint + { ipRange :: Range -- ^ The position of the interaction point. + , ipMeta :: Maybe MetaId -- ^ The meta variable, if any, holding the type etc. + , ipSolved:: Bool -- ^ Has this interaction point already been solved? + , ipClause:: IPClause + -- ^ The clause of the interaction point (if any). + -- Used for case splitting. + } + +instance Eq InteractionPoint where (==) = (==) `on` ipMeta + +-- | Data structure managing the interaction points. +-- +-- We never remove interaction points from this map, only set their +-- 'ipSolved' to @True@. (Issue #2368) +type InteractionPoints = Map InteractionId InteractionPoint + + +-- | Flag to indicate whether the meta is overapplied in the +-- constraint. A meta is overapplied if it has more arguments than +-- the size of the telescope in its creation environment +-- (as stored in MetaInfo). +data Overapplied = Overapplied | NotOverapplied deriving (Eq, Show, Data) + +-- | Datatype representing a single boundary condition: +-- x_0 = u_0, ... ,x_n = u_n ⊢ t = ?n es +data IPBoundary' t = IPBoundary + { ipbEquations :: [(t,t)] -- ^ [x_0 = u_0, ... ,x_n = u_n] + , ipbValue :: t -- ^ @t@ + , ipbMetaApp :: t -- ^ @?n es@ + , ipbOverapplied :: Overapplied -- ^ Is @?n@ overapplied in @?n es@ ? + } + deriving (Show, Data, Functor, Foldable, Traversable) + +type IPBoundary = IPBoundary' Term + +-- | Which clause is an interaction point located in? +data IPClause = IPClause + { ipcQName :: QName -- ^ The name of the function. + , ipcClauseNo :: Int -- ^ The number of the clause of this function. + , ipcType :: Type -- ^ The type of the function + , ipcWithSub :: Maybe Substitution -- ^ Module parameter substitution + , ipcClause :: A.SpineClause -- ^ The original AST clause. + , ipcClosure :: Closure () -- ^ Environment for rechecking the clause. + , ipcBoundary :: [Closure IPBoundary] -- ^ The boundary imposed by the LHS. + } + | IPNoClause -- ^ The interaction point is not in the rhs of a clause. + deriving (Data) + +instance Eq IPClause where + IPNoClause == IPNoClause = True + IPClause x i _ _ _ _ _ == IPClause x' i' _ _ _ _ _ = x == x' && i == i' + _ == _ = False + +--------------------------------------------------------------------------- +-- ** Signature +--------------------------------------------------------------------------- + +data Signature = Sig + { _sigSections :: Sections + , _sigDefinitions :: Definitions + , _sigRewriteRules:: RewriteRuleMap -- ^ The rewrite rules defined in this file. + } + deriving (Data, Show) + +sigSections :: Lens' Sections Signature +sigSections f s = + f (_sigSections s) <&> + \x -> s {_sigSections = x} + +sigDefinitions :: Lens' Definitions Signature +sigDefinitions f s = + f (_sigDefinitions s) <&> + \x -> s {_sigDefinitions = x} + +sigRewriteRules :: Lens' RewriteRuleMap Signature +sigRewriteRules f s = + f (_sigRewriteRules s) <&> + \x -> s {_sigRewriteRules = x} + +type Sections = Map ModuleName Section +type Definitions = HashMap QName Definition +type RewriteRuleMap = HashMap QName RewriteRules +type DisplayForms = HashMap QName [LocalDisplayForm] + +newtype Section = Section { _secTelescope :: Telescope } + deriving (Data, Show) + +instance Pretty Section where + pretty = pretty . _secTelescope + +secTelescope :: Lens' Telescope Section +secTelescope f s = + f (_secTelescope s) <&> + \x -> s {_secTelescope = x} + +emptySignature :: Signature +emptySignature = Sig Map.empty HMap.empty HMap.empty + +-- | A @DisplayForm@ is in essence a rewrite rule +-- @ +-- q ts --> dt +-- @ +-- for a defined symbol (could be a constructor as well) @q@. +-- The right hand side is a 'DisplayTerm' which is used to +-- 'reify' to a more readable 'Abstract.Syntax'. +-- +-- The patterns @ts@ are just terms, but @var 0@ is interpreted +-- as a hole. Each occurrence of @var 0@ is a new hole (pattern var). +-- For each *occurrence* of @var0@ the rhs @dt@ has a free variable. +-- These are instantiated when matching a display form against a +-- term @q vs@ succeeds. +data DisplayForm = Display + { dfFreeVars :: Nat + -- ^ Number @n@ of free variables in 'dfRHS'. + , dfPats :: Elims + -- ^ Left hand side patterns, where @var 0@ stands for a pattern + -- variable. There should be @n@ occurrences of @var0@ in + -- 'dfPats'. + -- The 'ArgInfo' is ignored in these patterns. + , dfRHS :: DisplayTerm + -- ^ Right hand side, with @n@ free variables. + } + deriving (Data, Show) + +type LocalDisplayForm = Open DisplayForm + +-- | A structured presentation of a 'Term' for reification into +-- 'Abstract.Syntax'. +data DisplayTerm + = DWithApp DisplayTerm [DisplayTerm] Elims + -- ^ @(f vs | ws) es@. + -- The first 'DisplayTerm' is the parent function @f@ with its args @vs@. + -- The list of 'DisplayTerm's are the with expressions @ws@. + -- The 'Elims' are additional arguments @es@ + -- (possible in case the with-application is of function type) + -- or projections (if it is of record type). + | DCon ConHead ConInfo [Arg DisplayTerm] + -- ^ @c vs@. + | DDef QName [Elim' DisplayTerm] + -- ^ @d vs@. + | DDot Term + -- ^ @.v@. + | DTerm Term + -- ^ @v@. + deriving (Data, Show) + +instance Free DisplayForm where + freeVars' (Display n ps t) = underBinder (freeVars' ps) `mappend` underBinder' n (freeVars' t) + +instance Free DisplayTerm where + freeVars' (DWithApp t ws es) = freeVars' (t, (ws, es)) + freeVars' (DCon _ _ vs) = freeVars' vs + freeVars' (DDef _ es) = freeVars' es + freeVars' (DDot v) = freeVars' v + freeVars' (DTerm v) = freeVars' v + +instance Pretty DisplayTerm where + prettyPrec p v = + case v of + DTerm v -> prettyPrec p v + DDot v -> "." <> prettyPrec 10 v + DDef f es -> pretty f `pApp` es + DCon c _ vs -> pretty (conName c) `pApp` map Apply vs + DWithApp h ws es -> + mparens (p > 0) + (sep [ pretty h + , nest 2 $ fsep [ "|" <+> pretty w | w <- ws ] ]) + `pApp` es + where + pApp :: Pretty el => Doc -> [el] -> Doc + pApp d els = mparens (not (null els) && p > 9) $ + sep [d, nest 2 $ fsep (map (prettyPrec 10) els)] + +-- | By default, we have no display form. +defaultDisplayForm :: QName -> [LocalDisplayForm] +defaultDisplayForm c = [] + +-- | Non-linear (non-constructor) first-order pattern. +data NLPat + = PVar !Int [Arg Int] + -- ^ Matches anything (modulo non-linearity) that only contains bound + -- variables that occur in the given arguments. + | PDef QName PElims + -- ^ Matches @f es@ + | PLam ArgInfo (Abs NLPat) + -- ^ Matches @λ x → t@ + | PPi (Dom NLPType) (Abs NLPType) + -- ^ Matches @(x : A) → B@ + | PSort NLPSort + -- ^ Matches a sort of the given shape. + | PBoundVar {-# UNPACK #-} !Int PElims + -- ^ Matches @x es@ where x is a lambda-bound variable + | PTerm Term + -- ^ Matches the term modulo β (ideally βη). + deriving (Data, Show) +type PElims = [Elim' NLPat] + +data NLPType = NLPType + { nlpTypeSort :: NLPSort + , nlpTypeUnEl :: NLPat + } deriving (Data, Show) + +data NLPSort + = PType NLPat + | PProp NLPat + | PInf + | PSizeUniv + deriving (Data, Show) + +type RewriteRules = [RewriteRule] + +-- | Rewrite rules can be added independently from function clauses. +data RewriteRule = RewriteRule + { rewName :: QName -- ^ Name of rewrite rule @q : Γ → f ps ≡ rhs@ + -- where @≡@ is the rewrite relation. + , rewContext :: Telescope -- ^ @Γ@. + , rewHead :: QName -- ^ @f@. + , rewPats :: PElims -- ^ @Γ ⊢ f ps : t@. + , rewRHS :: Term -- ^ @Γ ⊢ rhs : t@. + , rewType :: Type -- ^ @Γ ⊢ t@. + } + deriving (Data, Show) + +data Definition = Defn + { defArgInfo :: ArgInfo -- ^ Hiding should not be used. + , defName :: QName -- ^ The canonical name, used e.g. in compilation. + , defType :: Type -- ^ Type of the lifted definition. + , defPolarity :: [Polarity] + -- ^ Variance information on arguments of the definition. + -- Does not include info for dropped parameters to + -- projection(-like) functions and constructors. + , defArgOccurrences :: [Occurrence] + -- ^ Positivity information on arguments of the definition. + -- Does not include info for dropped parameters to + -- projection(-like) functions and constructors. + + -- Sometimes Agda looks up 'Occurrence's in these lists based on + -- their position, so one might consider replacing the list + -- with, say, an 'IntMap'. However, presumably these lists tend + -- to be short, in which case 'IntMap's could be slower than + -- lists. For instance, at one point the longest list + -- encountered for the standard library (in serialised + -- interfaces) had length 27. Distribution: + -- + -- Length, number of lists + -- ----------------------- + -- + -- 0, 2444 + -- 1, 721 + -- 2, 433 + -- 3, 668 + -- 4, 602 + -- 5, 624 + -- 6, 626 + -- 7, 484 + -- 8, 375 + -- 9, 264 + -- 10, 305 + -- 11, 188 + -- 12, 171 + -- 13, 108 + -- 14, 84 + -- 15, 80 + -- 16, 38 + -- 17, 23 + -- 18, 16 + -- 19, 8 + -- 20, 7 + -- 21, 5 + -- 22, 2 + -- 23, 3 + -- 27, 1 + + , defArgGeneralizable :: NumGeneralizableArgs + -- ^ How many arguments should be generalised. + , defGeneralizedParams :: [Maybe Name] + -- ^ Gives the name of the (bound variable) parameter for named generalized + -- parameters. This is needed to bring it into scope when type checking + -- the data/record definition corresponding to a type with generalized + -- parameters. + , defDisplay :: [LocalDisplayForm] + , defMutual :: MutualId + , defCompiledRep :: CompiledRepresentation + , defInstance :: Maybe QName + -- ^ @Just q@ when this definition is an instance of class q + , defCopy :: Bool + -- ^ Has this function been created by a module + -- instantiation? + , defMatchable :: Set QName + -- ^ The set of symbols with rewrite rules that match against this symbol + , defNoCompilation :: Bool + -- ^ should compilers skip this? Used for e.g. cubical's comp + , defInjective :: Bool + -- ^ Should the def be treated as injective by the pattern matching unifier? + , defCopatternLHS :: Bool + -- ^ Is this a function defined by copatterns? + , defBlocked :: Blocked_ + -- ^ What blocking tag to use when we cannot reduce this def? + -- Used when checking a function definition is blocked on a meta + -- in the type. + , theDef :: Defn + } + deriving (Data, Show) + +instance LensArgInfo Definition where + getArgInfo = defArgInfo + mapArgInfo f def = def { defArgInfo = f $ defArgInfo def } + +instance LensModality Definition where +instance LensQuantity Definition where +instance LensRelevance Definition where + +data NumGeneralizableArgs + = NoGeneralizableArgs + | SomeGeneralizableArgs Int + -- ^ When lambda-lifting new args are generalizable if + -- 'SomeGeneralizableArgs', also when the number is zero. + deriving (Data, Show) + +theDefLens :: Lens' Defn Definition +theDefLens f d = f (theDef d) <&> \ df -> d { theDef = df } + +-- | Create a definition with sensible defaults. +defaultDefn :: ArgInfo -> QName -> Type -> Defn -> Definition +defaultDefn info x t def = Defn + { defArgInfo = info + , defName = x + , defType = t + , defPolarity = [] + , defArgOccurrences = [] + , defArgGeneralizable = NoGeneralizableArgs + , defGeneralizedParams = [] + , defDisplay = defaultDisplayForm x + , defMutual = 0 + , defCompiledRep = noCompiledRep + , defInstance = Nothing + , defCopy = False + , defMatchable = Set.empty + , defNoCompilation = False + , defInjective = False + , defCopatternLHS = False + , defBlocked = NotBlocked ReallyNotBlocked () + , theDef = def + } + +-- | Polarity for equality and subtype checking. +data Polarity + = Covariant -- ^ monotone + | Contravariant -- ^ antitone + | Invariant -- ^ no information (mixed variance) + | Nonvariant -- ^ constant + deriving (Data, Show, Eq) + +instance Pretty Polarity where + pretty = text . \case + Covariant -> "+" + Contravariant -> "-" + Invariant -> "*" + Nonvariant -> "_" + +-- | Information about whether an argument is forced by the type of a function. +data IsForced + = Forced + | NotForced + deriving (Data, Show, Eq) + +-- | The backends are responsible for parsing their own pragmas. +data CompilerPragma = CompilerPragma Range String + deriving (Data, Show, Eq) + +instance HasRange CompilerPragma where + getRange (CompilerPragma r _) = r + +type BackendName = String + +jsBackendName, ghcBackendName :: BackendName +jsBackendName = "JS" +ghcBackendName = "GHC" + +type CompiledRepresentation = Map BackendName [CompilerPragma] + +noCompiledRep :: CompiledRepresentation +noCompiledRep = Map.empty + +-- A face represented as a list of equality constraints. +-- (r,False) ↦ (r = i0) +-- (r,True ) ↦ (r = i1) +type Face = [(Term,Bool)] + +-- | An alternative representation of partial elements in a telescope: +-- Γ ⊢ λ Δ. [φ₁ u₁, ... , φₙ uₙ] : Δ → PartialP (∨_ᵢ φᵢ) T +-- see cubicaltt paper (however we do not store the type T). +data System = System + { systemTel :: Telescope + -- ^ the telescope Δ, binding vars for the clauses, Γ ⊢ Δ + , systemClauses :: [(Face,Term)] + -- ^ a system [φ₁ u₁, ... , φₙ uₙ] where Γ, Δ ⊢ φᵢ and Γ, Δ, φᵢ ⊢ uᵢ + } deriving (Data, Show) + +-- | Additional information for extended lambdas. +data ExtLamInfo = ExtLamInfo + { extLamModule :: ModuleName + -- ^ For complicated reasons the scope checker decides the QName of a + -- pattern lambda, and thus its module. We really need to decide the + -- module during type checking though, since if the lambda appears in a + -- refined context the module picked by the scope checker has very much + -- the wrong parameters. + , extLamSys :: !(Strict.Maybe System) + } deriving (Data, Show) + +modifySystem :: (System -> System) -> ExtLamInfo -> ExtLamInfo +modifySystem f e = let !e' = e { extLamSys = f <$> extLamSys e } in e' + +-- | Additional information for projection 'Function's. +data Projection = Projection + { projProper :: Maybe QName + -- ^ @Nothing@ if only projection-like, @Just r@ if record projection. + -- The @r@ is the name of the record type projected from. + -- This field is updated by module application. + , projOrig :: QName + -- ^ The original projection name + -- (current name could be from module application). + , projFromType :: Arg QName + -- ^ Type projected from. Original record type if @projProper = Just{}@. + -- Also stores @ArgInfo@ of the principal argument. + -- This field is unchanged by module application. + , projIndex :: Int + -- ^ Index of the record argument. + -- Start counting with 1, because 0 means that + -- it is already applied to the record value. + -- This can happen in module instantiation, but + -- then either the record value is @var 0@, or @funProjection == Nothing@. + , projLams :: ProjLams + -- ^ Term @t@ to be be applied to record parameters and record value. + -- The parameters will be dropped. + -- In case of a proper projection, a postfix projection application + -- will be created: @t = \ pars r -> r .p@ + -- (Invariant: the number of abstractions equals 'projIndex'.) + -- In case of a projection-like function, just the function symbol + -- is returned as 'Def': @t = \ pars -> f@. + } deriving (Data, Show) + +-- | Abstractions to build projection function (dropping parameters). +newtype ProjLams = ProjLams { getProjLams :: [Arg ArgName] } + deriving (Data, Show, Null) + +-- | Building the projection function (which drops the parameters). +projDropPars :: Projection -> ProjOrigin -> Term +-- Proper projections: +projDropPars (Projection Just{} d _ _ lams) o = + case initLast $ getProjLams lams of + Nothing -> Def d [] + Just (pars, Arg i y) -> + let core = Lam i $ Abs y $ Var 0 [Proj o d] in + List.foldr (\ (Arg ai x) -> Lam ai . NoAbs x) core pars +-- Projection-like functions: +projDropPars (Projection Nothing _ _ _ lams) o | null lams = __IMPOSSIBLE__ +projDropPars (Projection Nothing d _ _ lams) o = + List.foldr (\ (Arg ai x) -> Lam ai . NoAbs x) (Def d []) $ init $ getProjLams lams + +-- | The info of the principal (record) argument. +projArgInfo :: Projection -> ArgInfo +projArgInfo (Projection _ _ _ _ lams) = + maybe __IMPOSSIBLE__ getArgInfo $ lastMaybe $ getProjLams lams + +-- | Should a record type admit eta-equality? +data EtaEquality + = Specified { theEtaEquality :: !HasEta } -- ^ User specifed 'eta-equality' or 'no-eta-equality'. + | Inferred { theEtaEquality :: !HasEta } -- ^ Positivity checker inferred whether eta is safe. + deriving (Data, Show, Eq) + +-- | Make sure we do not overwrite a user specification. +setEtaEquality :: EtaEquality -> HasEta -> EtaEquality +setEtaEquality e@Specified{} _ = e +setEtaEquality _ b = Inferred b + +data FunctionFlag + = FunStatic -- ^ Should calls to this function be normalised at compile-time? + | FunInline -- ^ Should calls to this function be inlined by the compiler? + | FunMacro -- ^ Is this function a macro? + deriving (Data, Eq, Ord, Enum, Show) + +data CompKit = CompKit + { nameOfHComp :: Maybe QName + , nameOfTransp :: Maybe QName + } + deriving (Data, Eq, Ord, Show) + +emptyCompKit :: CompKit +emptyCompKit = CompKit Nothing Nothing + +data Defn = Axiom -- ^ Postulate + | DataOrRecSig + { datarecPars :: Int } + -- ^ Data or record type signature that doesn't yet have a definition + | GeneralizableVar -- ^ Generalizable variable (introduced in `generalize` block) + | AbstractDefn Defn + -- ^ Returned by 'getConstInfo' if definition is abstract. + | Function + { funClauses :: [Clause] + , funCompiled :: Maybe CompiledClauses + -- ^ 'Nothing' while function is still type-checked. + -- @Just cc@ after type and coverage checking and + -- translation to case trees. + , funSplitTree :: Maybe SplitTree + -- ^ The split tree constructed by the coverage + -- checker. Needed to re-compile the clauses after + -- forcing translation. + , funTreeless :: Maybe Compiled + -- ^ Intermediate representation for compiler backends. + , funCovering :: [Clause] + -- ^ Covering clauses computed by coverage checking. + -- Erased by (IApply) confluence checking(?) + , funInv :: FunctionInverse + , funMutual :: Maybe [QName] + -- ^ Mutually recursive functions, @data@s and @record@s. + -- Does include this function. + -- Empty list if not recursive. + -- @Nothing@ if not yet computed (by positivity checker). + , funAbstr :: IsAbstract + , funDelayed :: Delayed + -- ^ Are the clauses of this definition delayed? + , funProjection :: Maybe Projection + -- ^ Is it a record projection? + -- If yes, then return the name of the record type and index of + -- the record argument. Start counting with 1, because 0 means that + -- it is already applied to the record. (Can happen in module + -- instantiation.) This information is used in the termination + -- checker. + , funFlags :: Set FunctionFlag + , funTerminates :: Maybe Bool + -- ^ Has this function been termination checked? Did it pass? + , funExtLam :: Maybe ExtLamInfo + -- ^ Is this function generated from an extended lambda? + -- If yes, then return the number of hidden and non-hidden lambda-lifted arguments + , funWith :: Maybe QName + -- ^ Is this a generated with-function? If yes, then what's the + -- name of the parent function. + } + | Datatype + { dataPars :: Nat -- ^ Number of parameters. + , dataIxs :: Nat -- ^ Number of indices. + , dataClause :: (Maybe Clause) -- ^ This might be in an instantiated module. + , dataCons :: [QName] + -- ^ Constructor names , ordered according to the order of their definition. + , dataSort :: Sort + , dataMutual :: Maybe [QName] + -- ^ Mutually recursive functions, @data@s and @record@s. + -- Does include this data type. + -- Empty if not recursive. + -- @Nothing@ if not yet computed (by positivity checker). + , dataAbstr :: IsAbstract + , dataPathCons :: [QName] -- ^ Path constructor names (subset of dataCons) + } + | Record + { recPars :: Nat + -- ^ Number of parameters. + , recClause :: Maybe Clause + -- ^ Was this record type created by a module application? + -- If yes, the clause is its definition (linking back to the original record type). + , recConHead :: ConHead + -- ^ Constructor name and fields. + , recNamedCon :: Bool + -- ^ Does this record have a @constructor@? + , recFields :: [Dom QName] + -- ^ The record field names. + , recTel :: Telescope + -- ^ The record field telescope. (Includes record parameters.) + -- Note: @TelV recTel _ == telView' recConType@. + -- Thus, @recTel@ is redundant. + , recMutual :: Maybe [QName] + -- ^ Mutually recursive functions, @data@s and @record@s. + -- Does include this record. + -- Empty if not recursive. + -- @Nothing@ if not yet computed (by positivity checker). + , recEtaEquality' :: EtaEquality + -- ^ Eta-expand at this record type? + -- @False@ for unguarded recursive records and coinductive records + -- unless the user specifies otherwise. + , recInduction :: Maybe Induction + -- ^ 'Inductive' or 'CoInductive'? Matters only for recursive records. + -- 'Nothing' means that the user did not specify it, which is an error + -- for recursive records. + , recAbstr :: IsAbstract + , recComp :: CompKit + } + | Constructor + { conPars :: Int -- ^ Number of parameters. + , conArity :: Int -- ^ Number of arguments (excluding parameters). + , conSrcCon :: ConHead -- ^ Name of (original) constructor and fields. (This might be in a module instance.) + , conData :: QName -- ^ Name of datatype or record type. + , conAbstr :: IsAbstract + , conInd :: Induction -- ^ Inductive or coinductive? + , conComp :: CompKit -- ^ Cubical composition. + , conProj :: Maybe [QName] -- ^ Projections. 'Nothing' if not yet computed. + , conForced :: [IsForced] + -- ^ Which arguments are forced (i.e. determined by the type of the constructor)? + -- Either this list is empty (if the forcing analysis isn't run), or its length is @conArity@. + , conErased :: Maybe [Bool] + -- ^ Which arguments are erased at runtime (computed during compilation to treeless)? + -- 'True' means erased, 'False' means retained. + -- 'Nothing' if no erasure analysis has been performed yet. + -- The length of the list is @conArity@. + } + | Primitive + { primAbstr :: IsAbstract + , primName :: String + , primClauses :: [Clause] + -- ^ 'null' for primitive functions, @not null@ for builtin functions. + , primInv :: FunctionInverse + -- ^ Builtin functions can have inverses. For instance, natural number addition. + , primCompiled :: Maybe CompiledClauses + -- ^ 'Nothing' for primitive functions, + -- @'Just' something@ for builtin functions. + } + -- ^ Primitive or builtin functions. + deriving (Data, Show) + +instance Pretty Definition where + pretty Defn{..} = + "Defn {" vcat + [ "defArgInfo =" pshow defArgInfo + , "defName =" pretty defName + , "defType =" pretty defType + , "defPolarity =" pshow defPolarity + , "defArgOccurrences =" pshow defArgOccurrences + , "defGeneralizedParams =" pshow defGeneralizedParams + , "defDisplay =" pshow defDisplay -- TODO: pretty DisplayForm + , "defMutual =" pshow defMutual + , "defCompiledRep =" pshow defCompiledRep + , "defInstance =" pshow defInstance + , "defCopy =" pshow defCopy + , "defMatchable =" pshow (Set.toList defMatchable) + , "defInjective =" pshow defInjective + , "defCopatternLHS =" pshow defCopatternLHS + , "theDef =" pretty theDef ] <+> "}" + +instance Pretty Defn where + pretty Axiom = "Axiom" + pretty (DataOrRecSig n) = "DataOrRecSig" <+> pretty n + pretty GeneralizableVar{} = "GeneralizableVar" + pretty (AbstractDefn def) = "AbstractDefn" parens (pretty def) + pretty Function{..} = + "Function {" vcat + [ "funClauses =" vcat (map pretty funClauses) + , "funCompiled =" pshow funCompiled + , "funSplitTree =" pshow funSplitTree + , "funTreeless =" pshow funTreeless + , "funInv =" pshow funInv + , "funMutual =" pshow funMutual + , "funAbstr =" pshow funAbstr + , "funDelayed =" pshow funDelayed + , "funProjection =" pshow funProjection + , "funFlags =" pshow funFlags + , "funTerminates =" pshow funTerminates + , "funWith =" pshow funWith ] "}" + pretty Datatype{..} = + "Datatype {" vcat + [ "dataPars =" pshow dataPars + , "dataIxs =" pshow dataIxs + , "dataClause =" pretty dataClause + , "dataCons =" pshow dataCons + , "dataSort =" pretty dataSort + , "dataMutual =" pshow dataMutual + , "dataAbstr =" pshow dataAbstr ] "}" + pretty Record{..} = + "Record {" vcat + [ "recPars =" pshow recPars + , "recClause =" pretty recClause + , "recConHead =" pshow recConHead + , "recNamedCon =" pshow recNamedCon + , "recFields =" pshow recFields + , "recTel =" pretty recTel + , "recMutual =" pshow recMutual + , "recEtaEquality' =" pshow recEtaEquality' + , "recInduction =" pshow recInduction + , "recAbstr =" pshow recAbstr ] "}" + pretty Constructor{..} = + "Constructor {" vcat + [ "conPars =" pshow conPars + , "conArity =" pshow conArity + , "conSrcCon =" pshow conSrcCon + , "conData =" pshow conData + , "conAbstr =" pshow conAbstr + , "conInd =" pshow conInd + , "conErased =" pshow conErased ] "}" + pretty Primitive{..} = + "Primitive {" vcat + [ "primAbstr =" pshow primAbstr + , "primName =" pshow primName + , "primClauses =" pshow primClauses + , "primCompiled =" pshow primCompiled ] "}" + + +-- | Is the record type recursive? +recRecursive :: Defn -> Bool +recRecursive (Record { recMutual = Just qs }) = not $ null qs +recRecursive _ = __IMPOSSIBLE__ + +recEtaEquality :: Defn -> HasEta +recEtaEquality = theEtaEquality . recEtaEquality' + +-- | A template for creating 'Function' definitions, with sensible defaults. +emptyFunction :: Defn +emptyFunction = Function + { funClauses = [] + , funCompiled = Nothing + , funSplitTree = Nothing + , funTreeless = Nothing + , funInv = NotInjective + , funMutual = Nothing + , funAbstr = ConcreteDef + , funDelayed = NotDelayed + , funProjection = Nothing + , funFlags = Set.empty + , funTerminates = Nothing + , funExtLam = Nothing + , funWith = Nothing + , funCovering = [] + } + +funFlag :: FunctionFlag -> Lens' Bool Defn +funFlag flag f def@Function{ funFlags = flags } = + f (Set.member flag flags) <&> + \ b -> def{ funFlags = (if b then Set.insert else Set.delete) flag flags } +funFlag _ f def = f False <&> const def + +funStatic, funInline, funMacro :: Lens' Bool Defn +funStatic = funFlag FunStatic +funInline = funFlag FunInline +funMacro = funFlag FunMacro + +isMacro :: Defn -> Bool +isMacro = (^. funMacro) + +-- | Checking whether we are dealing with a function yet to be defined. +isEmptyFunction :: Defn -> Bool +isEmptyFunction def = + case def of + Function { funClauses = [] } -> True + _ -> False + +isCopatternLHS :: [Clause] -> Bool +isCopatternLHS = List.any (List.any (isJust . A.isProjP) . namedClausePats) + +recCon :: Defn -> QName +recCon Record{ recConHead } = conName recConHead +recCon _ = __IMPOSSIBLE__ + +defIsRecord :: Defn -> Bool +defIsRecord Record{} = True +defIsRecord _ = False + +defIsDataOrRecord :: Defn -> Bool +defIsDataOrRecord Record{} = True +defIsDataOrRecord Datatype{} = True +defIsDataOrRecord _ = False + +defConstructors :: Defn -> [QName] +defConstructors Datatype{dataCons = cs} = cs +defConstructors Record{recConHead = c} = [conName c] +defConstructors _ = __IMPOSSIBLE__ + +newtype Fields = Fields [(C.Name, Type)] + deriving Null + +-- | Did we encounter a simplifying reduction? +-- In terms of CIC, that would be a iota-reduction. +-- In terms of Agda, this is a constructor or literal +-- pattern that matched. +-- Just beta-reduction (substitution) or delta-reduction +-- (unfolding of definitions) does not count as simplifying? + +data Simplification = YesSimplification | NoSimplification + deriving (Data, Eq, Show) + +instance Null Simplification where + empty = NoSimplification + null = (== NoSimplification) + +instance Semigroup Simplification where + YesSimplification <> _ = YesSimplification + NoSimplification <> s = s + +instance Monoid Simplification where + mempty = NoSimplification + mappend = (<>) + +data Reduced no yes + = NoReduction no + | YesReduction Simplification yes + deriving Functor + +redReturn :: a -> ReduceM (Reduced a' a) +redReturn = return . YesReduction YesSimplification + +-- | Conceptually: @redBind m f k = either (return . Left . f) k =<< m@ + +redBind :: ReduceM (Reduced a a') -> (a -> b) -> + (a' -> ReduceM (Reduced b b')) -> ReduceM (Reduced b b') +redBind ma f k = do + r <- ma + case r of + NoReduction x -> return $ NoReduction $ f x + YesReduction _ y -> k y + +-- | Three cases: 1. not reduced, 2. reduced, but blocked, 3. reduced, not blocked. +data IsReduced + = NotReduced + | Reduced (Blocked ()) + +data MaybeReduced a = MaybeRed + { isReduced :: IsReduced + , ignoreReduced :: a + } + deriving (Functor) + +instance IsProjElim e => IsProjElim (MaybeReduced e) where + isProjElim = isProjElim . ignoreReduced + +type MaybeReducedArgs = [MaybeReduced (Arg Term)] +type MaybeReducedElims = [MaybeReduced Elim] + +notReduced :: a -> MaybeReduced a +notReduced x = MaybeRed NotReduced x + +reduced :: Blocked (Arg Term) -> MaybeReduced (Arg Term) +reduced b = case b of + NotBlocked _ (Arg _ (MetaV x _)) -> MaybeRed (Reduced $ Blocked x ()) v + _ -> MaybeRed (Reduced $ () <$ b) v + where + v = ignoreBlocking b + +-- | Controlling 'reduce'. +data AllowedReduction + = ProjectionReductions -- ^ (Projection and) projection-like functions may be reduced. + | InlineReductions -- ^ Functions marked INLINE may be reduced. + | CopatternReductions -- ^ Copattern definitions may be reduced. + | FunctionReductions -- ^ Non-recursive functions and primitives may be reduced. + | RecursiveReductions -- ^ Even recursive functions may be reduced. + | LevelReductions -- ^ Reduce @'Level'@ terms. + | TypeLevelReductions -- ^ Allow @allReductions@ in types, even + -- if not allowed at term level (used + -- by confluence checker) + | UnconfirmedReductions -- ^ Functions whose termination has not (yet) been confirmed. + | NonTerminatingReductions -- ^ Functions that have failed termination checking. + deriving (Show, Eq, Ord, Enum, Bounded, Ix, Data) + +type AllowedReductions = SmallSet AllowedReduction + +-- | Not quite all reductions (skip non-terminating reductions) +allReductions :: AllowedReductions +allReductions = SmallSet.delete NonTerminatingReductions reallyAllReductions + +reallyAllReductions :: AllowedReductions +reallyAllReductions = SmallSet.total + + +-- | Primitives + +data PrimitiveImpl = PrimImpl Type PrimFun + +data PrimFun = PrimFun + { primFunName :: QName + , primFunArity :: Arity + , primFunImplementation :: [Arg Term] -> Int -> ReduceM (Reduced MaybeReducedArgs Term) + } + +primFun :: QName -> Arity -> ([Arg Term] -> ReduceM (Reduced MaybeReducedArgs Term)) -> PrimFun +primFun q ar imp = PrimFun q ar (\ args _ -> imp args) + +defClauses :: Definition -> [Clause] +defClauses Defn{theDef = Function{funClauses = cs}} = cs +defClauses Defn{theDef = Primitive{primClauses = cs}} = cs +defClauses Defn{theDef = Datatype{dataClause = Just c}} = [c] +defClauses Defn{theDef = Record{recClause = Just c}} = [c] +defClauses _ = [] + +defCompiled :: Definition -> Maybe CompiledClauses +defCompiled Defn{theDef = Function {funCompiled = mcc}} = mcc +defCompiled Defn{theDef = Primitive{primCompiled = mcc}} = mcc +defCompiled _ = Nothing + +defParameters :: Definition -> Maybe Nat +defParameters Defn{theDef = Datatype{dataPars = n}} = Just n +defParameters Defn{theDef = Record {recPars = n}} = Just n +defParameters _ = Nothing + +defInverse :: Definition -> FunctionInverse +defInverse Defn{theDef = Function { funInv = inv }} = inv +defInverse Defn{theDef = Primitive{ primInv = inv }} = inv +defInverse _ = NotInjective + +defCompilerPragmas :: BackendName -> Definition -> [CompilerPragma] +defCompilerPragmas b = reverse . fromMaybe [] . Map.lookup b . defCompiledRep + -- reversed because we add new pragmas to the front of the list + +-- | Are the clauses of this definition delayed? +defDelayed :: Definition -> Delayed +defDelayed Defn{theDef = Function{funDelayed = d}} = d +defDelayed _ = NotDelayed + +-- | Has the definition failed the termination checker? +defNonterminating :: Definition -> Bool +defNonterminating Defn{theDef = Function{funTerminates = Just False}} = True +defNonterminating _ = False + +-- | Has the definition not termination checked or did the check fail? +defTerminationUnconfirmed :: Definition -> Bool +defTerminationUnconfirmed Defn{theDef = Function{funTerminates = Just True}} = False +defTerminationUnconfirmed Defn{theDef = Function{funTerminates = _ }} = True +defTerminationUnconfirmed _ = False + +defAbstract :: Definition -> IsAbstract +defAbstract d = case theDef d of + Axiom{} -> ConcreteDef + DataOrRecSig{} -> ConcreteDef + GeneralizableVar{} -> ConcreteDef + AbstractDefn{} -> AbstractDef + Function{funAbstr = a} -> a + Datatype{dataAbstr = a} -> a + Record{recAbstr = a} -> a + Constructor{conAbstr = a} -> a + Primitive{primAbstr = a} -> a + +defForced :: Definition -> [IsForced] +defForced d = case theDef d of + Constructor{conForced = fs} -> fs + Axiom{} -> [] + DataOrRecSig{} -> [] + GeneralizableVar{} -> [] + AbstractDefn{} -> [] + Function{} -> [] + Datatype{} -> [] + Record{} -> [] + Primitive{} -> [] + +--------------------------------------------------------------------------- +-- ** Injectivity +--------------------------------------------------------------------------- + +type FunctionInverse = FunctionInverse' Clause +type InversionMap c = Map TermHead [c] + +data FunctionInverse' c + = NotInjective + | Inverse (InversionMap c) + deriving (Data, Show, Functor) + +data TermHead = SortHead + | PiHead + | ConsHead QName + | VarHead Nat + | UnknownHead + deriving (Data, Eq, Ord, Show) + +instance Pretty TermHead where + pretty = \ case + SortHead -> "SortHead" + PiHead -> "PiHead" + ConsHead q -> "ConsHead" <+> pretty q + VarHead i -> text ("VarHead " ++ show i) + UnknownHead -> "UnknownHead" + +--------------------------------------------------------------------------- +-- ** Mutual blocks +--------------------------------------------------------------------------- + +newtype MutualId = MutId Int32 + deriving (Data, Eq, Ord, Show, Num, Enum) + +--------------------------------------------------------------------------- +-- ** Statistics +--------------------------------------------------------------------------- + +type Statistics = Map String Integer + +--------------------------------------------------------------------------- +-- ** Trace +--------------------------------------------------------------------------- + +data Call + = CheckClause Type A.SpineClause + | CheckLHS A.SpineLHS + | CheckPattern A.Pattern Telescope Type + | CheckLetBinding A.LetBinding + | InferExpr A.Expr + | CheckExprCall Comparison A.Expr Type + | CheckDotPattern A.Expr Term + | CheckProjection Range QName Type + | IsTypeCall Comparison A.Expr Sort + | IsType_ A.Expr + | InferVar Name + | InferDef QName + | CheckArguments Range [NamedArg A.Expr] Type (Maybe Type) + | CheckMetaSolution Range MetaId Type Term + | CheckTargetType Range Type Type + | CheckDataDef Range QName [A.LamBinding] [A.Constructor] + | CheckRecDef Range QName [A.LamBinding] [A.Constructor] + | CheckConstructor QName Telescope Sort A.Constructor + | CheckConstructorFitsIn QName Type Sort + | CheckFunDefCall Range QName [A.Clause] + | CheckPragma Range A.Pragma + | CheckPrimitive Range QName A.Expr + | CheckIsEmpty Range Type + | CheckConfluence QName QName + | CheckWithFunctionType Type + | CheckSectionApplication Range ModuleName A.ModuleApplication + | CheckNamedWhere ModuleName + | ScopeCheckExpr C.Expr + | ScopeCheckDeclaration NiceDeclaration + | ScopeCheckLHS C.QName C.Pattern + | NoHighlighting + | ModuleContents -- ^ Interaction command: show module contents. + | SetRange Range -- ^ used by 'setCurrentRange' + deriving Data + +instance Pretty Call where + pretty CheckClause{} = "CheckClause" + pretty CheckLHS{} = "CheckLHS" + pretty CheckPattern{} = "CheckPattern" + pretty InferExpr{} = "InferExpr" + pretty CheckExprCall{} = "CheckExprCall" + pretty CheckLetBinding{} = "CheckLetBinding" + pretty CheckProjection{} = "CheckProjection" + pretty IsTypeCall{} = "IsTypeCall" + pretty IsType_{} = "IsType_" + pretty InferVar{} = "InferVar" + pretty InferDef{} = "InferDef" + pretty CheckArguments{} = "CheckArguments" + pretty CheckMetaSolution{} = "CheckMetaSolution" + pretty CheckTargetType{} = "CheckTargetType" + pretty CheckDataDef{} = "CheckDataDef" + pretty CheckRecDef{} = "CheckRecDef" + pretty CheckConstructor{} = "CheckConstructor" + pretty CheckConstructorFitsIn{} = "CheckConstructorFitsIn" + pretty CheckFunDefCall{} = "CheckFunDefCall" + pretty CheckPragma{} = "CheckPragma" + pretty CheckPrimitive{} = "CheckPrimitive" + pretty CheckWithFunctionType{} = "CheckWithFunctionType" + pretty CheckNamedWhere{} = "CheckNamedWhere" + pretty ScopeCheckExpr{} = "ScopeCheckExpr" + pretty ScopeCheckDeclaration{} = "ScopeCheckDeclaration" + pretty ScopeCheckLHS{} = "ScopeCheckLHS" + pretty CheckDotPattern{} = "CheckDotPattern" + pretty SetRange{} = "SetRange" + pretty CheckSectionApplication{} = "CheckSectionApplication" + pretty CheckIsEmpty{} = "CheckIsEmpty" + pretty CheckConfluence{} = "CheckConfluence" + pretty NoHighlighting{} = "NoHighlighting" + pretty ModuleContents{} = "ModuleContents" + +instance HasRange Call where + getRange (CheckClause _ c) = getRange c + getRange (CheckLHS lhs) = getRange lhs + getRange (CheckPattern p _ _) = getRange p + getRange (InferExpr e) = getRange e + getRange (CheckExprCall _ e _) = getRange e + getRange (CheckLetBinding b) = getRange b + getRange (CheckProjection r _ _) = r + getRange (IsTypeCall cmp e s) = getRange e + getRange (IsType_ e) = getRange e + getRange (InferVar x) = getRange x + getRange (InferDef f) = getRange f + getRange (CheckArguments r _ _ _) = r + getRange (CheckMetaSolution r _ _ _) = r + getRange (CheckTargetType r _ _) = r + getRange (CheckDataDef i _ _ _) = getRange i + getRange (CheckRecDef i _ _ _) = getRange i + getRange (CheckConstructor _ _ _ c) = getRange c + getRange (CheckConstructorFitsIn c _ _) = getRange c + getRange (CheckFunDefCall i _ _) = getRange i + getRange (CheckPragma r _) = r + getRange (CheckPrimitive i _ _) = getRange i + getRange CheckWithFunctionType{} = noRange + getRange (CheckNamedWhere m) = getRange m + getRange (ScopeCheckExpr e) = getRange e + getRange (ScopeCheckDeclaration d) = getRange d + getRange (ScopeCheckLHS _ p) = getRange p + getRange (CheckDotPattern e _) = getRange e + getRange (SetRange r) = r + getRange (CheckSectionApplication r _ _) = r + getRange (CheckIsEmpty r _) = r + getRange (CheckConfluence rule1 rule2) = max (getRange rule1) (getRange rule2) + getRange NoHighlighting = noRange + getRange ModuleContents = noRange + +--------------------------------------------------------------------------- +-- ** Instance table +--------------------------------------------------------------------------- + +-- | The instance table is a @Map@ associating to every name of +-- record/data type/postulate its list of instances +type InstanceTable = Map QName (Set QName) + +-- | When typechecking something of the following form: +-- +-- instance +-- x : _ +-- x = y +-- +-- it's not yet known where to add @x@, so we add it to a list of +-- unresolved instances and we'll deal with it later. +type TempInstanceTable = (InstanceTable , Set QName) + +--------------------------------------------------------------------------- +-- ** Builtin things +--------------------------------------------------------------------------- + +data BuiltinDescriptor + = BuiltinData (TCM Type) [String] + | BuiltinDataCons (TCM Type) + | BuiltinPrim String (Term -> TCM ()) + | BuiltinPostulate Relevance (TCM Type) + | BuiltinUnknown (Maybe (TCM Type)) (Term -> Type -> TCM ()) + -- ^ Builtin of any kind. + -- Type can be checked (@Just t@) or inferred (@Nothing@). + -- The second argument is the hook for the verification function. + +data BuiltinInfo = + BuiltinInfo { builtinName :: String + , builtinDesc :: BuiltinDescriptor } + +type BuiltinThings pf = Map String (Builtin pf) + +data Builtin pf + = Builtin Term + | Prim pf + deriving (Show, Functor, Foldable, Traversable) + +--------------------------------------------------------------------------- +-- * Highlighting levels +--------------------------------------------------------------------------- + +-- | How much highlighting should be sent to the user interface? + +data HighlightingLevel + = None + | NonInteractive + | Interactive + -- ^ This includes both non-interactive highlighting and + -- interactive highlighting of the expression that is currently + -- being type-checked. + deriving (Eq, Ord, Show, Read, Data) + +-- | How should highlighting be sent to the user interface? + +data HighlightingMethod + = Direct + -- ^ Via stdout. + | Indirect + -- ^ Both via files and via stdout. + deriving (Eq, Show, Read, Data) + +-- | @ifTopLevelAndHighlightingLevelIs l b m@ runs @m@ when we're +-- type-checking the top-level module and either the highlighting +-- level is /at least/ @l@ or @b@ is 'True'. + +ifTopLevelAndHighlightingLevelIsOr :: + MonadTCM tcm => HighlightingLevel -> Bool -> tcm () -> tcm () +ifTopLevelAndHighlightingLevelIsOr l b m = do + e <- askTC + when (envModuleNestingLevel e == 0 && + (envHighlightingLevel e >= l || b)) + m + +-- | @ifTopLevelAndHighlightingLevelIs l m@ runs @m@ when we're +-- type-checking the top-level module and the highlighting level is +-- /at least/ @l@. + +ifTopLevelAndHighlightingLevelIs :: + MonadTCM tcm => HighlightingLevel -> tcm () -> tcm () +ifTopLevelAndHighlightingLevelIs l = + ifTopLevelAndHighlightingLevelIsOr l False + +--------------------------------------------------------------------------- +-- * Type checking environment +--------------------------------------------------------------------------- + +data TCEnv = + TCEnv { envContext :: Context + , envLetBindings :: LetBindings + , envCurrentModule :: ModuleName + , envCurrentPath :: Maybe AbsolutePath + -- ^ The path to the file that is currently being + -- type-checked. 'Nothing' if we do not have a file + -- (like in interactive mode see @CommandLine@). + , envAnonymousModules :: [(ModuleName, Nat)] -- ^ anonymous modules and their number of free variables + , envImportPath :: [C.TopLevelModuleName] -- ^ to detect import cycles + , envMutualBlock :: Maybe MutualId -- ^ the current (if any) mutual block + , envTerminationCheck :: TerminationCheck () -- ^ are we inside the scope of a termination pragma + , envCoverageCheck :: CoverageCheck -- ^ are we inside the scope of a coverage pragma + , envMakeCase :: Bool -- ^ are we inside a make-case (if so, ignore forcing analysis in unifier) + , envSolvingConstraints :: Bool + -- ^ Are we currently in the process of solving active constraints? + , envCheckingWhere :: Bool + -- ^ Have we stepped into the where-declarations of a clause? + -- Everything under a @where@ will be checked with this flag on. + , envWorkingOnTypes :: Bool + -- ^ Are we working on types? Turned on by 'workOnTypes'. + , envAssignMetas :: Bool + -- ^ Are we allowed to assign metas? + , envActiveProblems :: Set ProblemId + , envAbstractMode :: AbstractMode + -- ^ When checking the typesignature of a public definition + -- or the body of a non-abstract definition this is true. + -- To prevent information about abstract things leaking + -- outside the module. + , envModality :: Modality + -- ^ 'Relevance' component: + -- Are we checking an irrelevant argument? (=@Irrelevant@) + -- Then top-level irrelevant declarations are enabled. + -- Other value: @Relevant@, then only relevant decls. are available. + -- + -- 'Quantity' component: + -- Are we checking a runtime-irrelevant thing? (='Quantity0') + -- Then runtime-irrelevant things are usable. + -- Other value: @Quantity1@, runtime relevant. + -- @Quantityω@ is not allowed here, see Bob Atkey, LiCS 2018. + , envDisplayFormsEnabled :: Bool + -- ^ Sometimes we want to disable display forms. + , envRange :: Range + , envHighlightingRange :: Range + -- ^ Interactive highlighting uses this range rather + -- than 'envRange'. + , envClause :: IPClause + -- ^ What is the current clause we are type-checking? + -- Will be recorded in interaction points in this clause. + , envCall :: Maybe (Closure Call) + -- ^ what we're doing at the moment + , envHighlightingLevel :: HighlightingLevel + -- ^ Set to 'None' when imported modules are + -- type-checked. + , envHighlightingMethod :: HighlightingMethod + , envModuleNestingLevel :: !Int + -- ^ This number indicates how far away from the + -- top-level module Agda has come when chasing + -- modules. The level of a given module is not + -- necessarily the same as the length, in the module + -- dependency graph, of the shortest path from the + -- top-level module; it depends on in which order + -- Agda chooses to chase dependencies. + , envExpandLast :: ExpandHidden + -- ^ When type-checking an alias f=e, we do not want + -- to insert hidden arguments in the end, because + -- these will become unsolved metas. + , envAppDef :: Maybe QName + -- ^ We are reducing an application of this function. + -- (For debugging of incomplete matches only.) + , envSimplification :: Simplification + -- ^ Did we encounter a simplification (proper match) + -- during the current reduction process? + , envAllowedReductions :: AllowedReductions + , envInjectivityDepth :: Int + -- ^ Injectivity can cause non-termination for unsolvable contraints + -- (#431, #3067). Keep a limit on the nesting depth of injectivity + -- uses. + , envCompareBlocked :: Bool + -- ^ When @True@, the conversion checker will consider + -- all term constructors as injective, including + -- blocked function applications and metas. Warning: + -- this should only be used when not assigning any + -- metas (e.g. when @envAssignMetas@ is @False@ or + -- when running @pureEqualTerms@) or else we get + -- non-unique meta solutions. + , envPrintDomainFreePi :: Bool + -- ^ When @True@, types will be omitted from printed pi types if they + -- can be inferred. + , envPrintMetasBare :: Bool + -- ^ When @True@, throw away meta numbers and meta elims. + -- This is used for reifying terms for feeding into the + -- user's source code, e.g., for the interaction tactics @solveAll@. + , envInsideDotPattern :: Bool + -- ^ Used by the scope checker to make sure that certain forms + -- of expressions are not used inside dot patterns: extended + -- lambdas and let-expressions. + , envUnquoteFlags :: UnquoteFlags + , envInstanceDepth :: !Int + -- ^ Until we get a termination checker for instance search (#1743) we + -- limit the search depth to ensure termination. + , envIsDebugPrinting :: Bool + , envPrintingPatternLambdas :: [QName] + -- ^ #3004: pattern lambdas with copatterns may refer to themselves. We + -- don't have a good story for what to do in this case, but at least + -- printing shouldn't loop. Here we keep track of which pattern lambdas + -- we are currently in the process of printing. + , envCallByNeed :: Bool + -- ^ Use call-by-need evaluation for reductions. + , envCurrentCheckpoint :: CheckpointId + -- ^ Checkpoints track the evolution of the context as we go + -- under binders or refine it by pattern matching. + , envCheckpoints :: Map CheckpointId Substitution + -- ^ Keeps the substitution from each previous checkpoint to + -- the current context. + , envGeneralizeMetas :: DoGeneralize + -- ^ Should new metas generalized over. + , envGeneralizedVars :: Map QName GeneralizedValue + -- ^ Values for used generalizable variables. + , envCheckOptionConsistency :: Bool + -- ^ Do we check that options in imported files are + -- consistent with each other? + , envActiveBackendName :: Maybe BackendName + -- ^ Is some backend active at the moment, and if yes, which? + -- NB: we only store the 'BackendName' here, otherwise + -- @instance Data TCEnv@ is not derivable. + -- The actual backend can be obtained from the name via 'stBackends'. + } + deriving Data + +initEnv :: TCEnv +initEnv = TCEnv { envContext = [] + , envLetBindings = Map.empty + , envCurrentModule = noModuleName + , envCurrentPath = Nothing + , envAnonymousModules = [] + , envImportPath = [] + , envMutualBlock = Nothing + , envTerminationCheck = TerminationCheck + , envCoverageCheck = YesCoverageCheck + , envMakeCase = False + , envSolvingConstraints = False + , envCheckingWhere = False + , envActiveProblems = Set.empty + , envWorkingOnTypes = False + , envAssignMetas = True + , envAbstractMode = ConcreteMode + -- Andreas, 2013-02-21: This was 'AbstractMode' until now. + -- However, top-level checks for mutual blocks, such as + -- constructor-headedness, should not be able to look into + -- abstract definitions unless abstract themselves. + -- (See also discussion on issue 796.) + -- The initial mode should be 'ConcreteMode', ensuring you + -- can only look into abstract things in an abstract + -- definition (which sets 'AbstractMode'). + , envModality = mempty + , envDisplayFormsEnabled = True + , envRange = noRange + , envHighlightingRange = noRange + , envClause = IPNoClause + , envCall = Nothing + , envHighlightingLevel = None + , envHighlightingMethod = Indirect + , envModuleNestingLevel = -1 + , envExpandLast = ExpandLast + , envAppDef = Nothing + , envSimplification = NoSimplification + , envAllowedReductions = allReductions + , envInjectivityDepth = 0 + , envCompareBlocked = False + , envPrintDomainFreePi = False + , envPrintMetasBare = False + , envInsideDotPattern = False + , envUnquoteFlags = defaultUnquoteFlags + , envInstanceDepth = 0 + , envIsDebugPrinting = False + , envPrintingPatternLambdas = [] + , envCallByNeed = True + , envCurrentCheckpoint = 0 + , envCheckpoints = Map.singleton 0 IdS + , envGeneralizeMetas = NoGeneralize + , envGeneralizedVars = Map.empty + , envCheckOptionConsistency = True + , envActiveBackendName = Nothing + } + +class LensTCEnv a where + lensTCEnv :: Lens' TCEnv a + +instance LensTCEnv TCEnv where + lensTCEnv = id + +instance LensModality TCEnv where + -- Cohesion shouldn't have an environment component. + getModality = setCohesion defaultCohesion . envModality + mapModality f e = e { envModality = setCohesion defaultCohesion $ f $ envModality e } + +instance LensRelevance TCEnv where +instance LensQuantity TCEnv where + +data UnquoteFlags = UnquoteFlags + { _unquoteNormalise :: Bool } + deriving Data + +defaultUnquoteFlags :: UnquoteFlags +defaultUnquoteFlags = UnquoteFlags + { _unquoteNormalise = False } + +unquoteNormalise :: Lens' Bool UnquoteFlags +unquoteNormalise f e = f (_unquoteNormalise e) <&> \ x -> e { _unquoteNormalise = x } + +eUnquoteNormalise :: Lens' Bool TCEnv +eUnquoteNormalise = eUnquoteFlags . unquoteNormalise + +-- * e-prefixed lenses +------------------------------------------------------------------------ + +eContext :: Lens' Context TCEnv +eContext f e = f (envContext e) <&> \ x -> e { envContext = x } + +eLetBindings :: Lens' LetBindings TCEnv +eLetBindings f e = f (envLetBindings e) <&> \ x -> e { envLetBindings = x } + +eCurrentModule :: Lens' ModuleName TCEnv +eCurrentModule f e = f (envCurrentModule e) <&> \ x -> e { envCurrentModule = x } + +eCurrentPath :: Lens' (Maybe AbsolutePath) TCEnv +eCurrentPath f e = f (envCurrentPath e) <&> \ x -> e { envCurrentPath = x } + +eAnonymousModules :: Lens' [(ModuleName, Nat)] TCEnv +eAnonymousModules f e = f (envAnonymousModules e) <&> \ x -> e { envAnonymousModules = x } + +eImportPath :: Lens' [C.TopLevelModuleName] TCEnv +eImportPath f e = f (envImportPath e) <&> \ x -> e { envImportPath = x } + +eMutualBlock :: Lens' (Maybe MutualId) TCEnv +eMutualBlock f e = f (envMutualBlock e) <&> \ x -> e { envMutualBlock = x } + +eTerminationCheck :: Lens' (TerminationCheck ()) TCEnv +eTerminationCheck f e = f (envTerminationCheck e) <&> \ x -> e { envTerminationCheck = x } + +eCoverageCheck :: Lens' CoverageCheck TCEnv +eCoverageCheck f e = f (envCoverageCheck e) <&> \ x -> e { envCoverageCheck = x } + +eMakeCase :: Lens' Bool TCEnv +eMakeCase f e = f (envMakeCase e) <&> \ x -> e { envMakeCase = x } + +eSolvingConstraints :: Lens' Bool TCEnv +eSolvingConstraints f e = f (envSolvingConstraints e) <&> \ x -> e { envSolvingConstraints = x } + +eCheckingWhere :: Lens' Bool TCEnv +eCheckingWhere f e = f (envCheckingWhere e) <&> \ x -> e { envCheckingWhere = x } + +eWorkingOnTypes :: Lens' Bool TCEnv +eWorkingOnTypes f e = f (envWorkingOnTypes e) <&> \ x -> e { envWorkingOnTypes = x } + +eAssignMetas :: Lens' Bool TCEnv +eAssignMetas f e = f (envAssignMetas e) <&> \ x -> e { envAssignMetas = x } + +eActiveProblems :: Lens' (Set ProblemId) TCEnv +eActiveProblems f e = f (envActiveProblems e) <&> \ x -> e { envActiveProblems = x } + +eAbstractMode :: Lens' AbstractMode TCEnv +eAbstractMode f e = f (envAbstractMode e) <&> \ x -> e { envAbstractMode = x } + +-- Andrea 23/02/2020: use get/setModality to enforce invariants of the +-- envModality field. +eModality :: Lens' Modality TCEnv +eModality f e = f (getModality e) <&> \ x -> setModality x e + +eRelevance :: Lens' Relevance TCEnv +eRelevance = eModality . lModRelevance + +eQuantity :: Lens' Quantity TCEnv +eQuantity = eModality . lModQuantity + +eDisplayFormsEnabled :: Lens' Bool TCEnv +eDisplayFormsEnabled f e = f (envDisplayFormsEnabled e) <&> \ x -> e { envDisplayFormsEnabled = x } + +eRange :: Lens' Range TCEnv +eRange f e = f (envRange e) <&> \ x -> e { envRange = x } + +eHighlightingRange :: Lens' Range TCEnv +eHighlightingRange f e = f (envHighlightingRange e) <&> \ x -> e { envHighlightingRange = x } + +eCall :: Lens' (Maybe (Closure Call)) TCEnv +eCall f e = f (envCall e) <&> \ x -> e { envCall = x } + +eHighlightingLevel :: Lens' HighlightingLevel TCEnv +eHighlightingLevel f e = f (envHighlightingLevel e) <&> \ x -> e { envHighlightingLevel = x } + +eHighlightingMethod :: Lens' HighlightingMethod TCEnv +eHighlightingMethod f e = f (envHighlightingMethod e) <&> \ x -> e { envHighlightingMethod = x } + +eModuleNestingLevel :: Lens' Int TCEnv +eModuleNestingLevel f e = f (envModuleNestingLevel e) <&> \ x -> e { envModuleNestingLevel = x } + +eExpandLast :: Lens' ExpandHidden TCEnv +eExpandLast f e = f (envExpandLast e) <&> \ x -> e { envExpandLast = x } + +eAppDef :: Lens' (Maybe QName) TCEnv +eAppDef f e = f (envAppDef e) <&> \ x -> e { envAppDef = x } + +eSimplification :: Lens' Simplification TCEnv +eSimplification f e = f (envSimplification e) <&> \ x -> e { envSimplification = x } + +eAllowedReductions :: Lens' AllowedReductions TCEnv +eAllowedReductions f e = f (envAllowedReductions e) <&> \ x -> e { envAllowedReductions = x } + +eInjectivityDepth :: Lens' Int TCEnv +eInjectivityDepth f e = f (envInjectivityDepth e) <&> \ x -> e { envInjectivityDepth = x } + +eCompareBlocked :: Lens' Bool TCEnv +eCompareBlocked f e = f (envCompareBlocked e) <&> \ x -> e { envCompareBlocked = x } + +ePrintDomainFreePi :: Lens' Bool TCEnv +ePrintDomainFreePi f e = f (envPrintDomainFreePi e) <&> \ x -> e { envPrintDomainFreePi = x } + +eInsideDotPattern :: Lens' Bool TCEnv +eInsideDotPattern f e = f (envInsideDotPattern e) <&> \ x -> e { envInsideDotPattern = x } + +eUnquoteFlags :: Lens' UnquoteFlags TCEnv +eUnquoteFlags f e = f (envUnquoteFlags e) <&> \ x -> e { envUnquoteFlags = x } + +eInstanceDepth :: Lens' Int TCEnv +eInstanceDepth f e = f (envInstanceDepth e) <&> \ x -> e { envInstanceDepth = x } + +eIsDebugPrinting :: Lens' Bool TCEnv +eIsDebugPrinting f e = f (envIsDebugPrinting e) <&> \ x -> e { envIsDebugPrinting = x } + +ePrintingPatternLambdas :: Lens' [QName] TCEnv +ePrintingPatternLambdas f e = f (envPrintingPatternLambdas e) <&> \ x -> e { envPrintingPatternLambdas = x } + +eCallByNeed :: Lens' Bool TCEnv +eCallByNeed f e = f (envCallByNeed e) <&> \ x -> e { envCallByNeed = x } + +eCurrentCheckpoint :: Lens' CheckpointId TCEnv +eCurrentCheckpoint f e = f (envCurrentCheckpoint e) <&> \ x -> e { envCurrentCheckpoint = x } + +eCheckpoints :: Lens' (Map CheckpointId Substitution) TCEnv +eCheckpoints f e = f (envCheckpoints e) <&> \ x -> e { envCheckpoints = x } + +eGeneralizeMetas :: Lens' DoGeneralize TCEnv +eGeneralizeMetas f e = f (envGeneralizeMetas e) <&> \ x -> e { envGeneralizeMetas = x } + +eGeneralizedVars :: Lens' (Map QName GeneralizedValue) TCEnv +eGeneralizedVars f e = f (envGeneralizedVars e) <&> \ x -> e { envGeneralizedVars = x } + +eActiveBackendName :: Lens' (Maybe BackendName) TCEnv +eActiveBackendName f e = f (envActiveBackendName e) <&> \ x -> e { envActiveBackendName = x } + +--------------------------------------------------------------------------- +-- ** Context +--------------------------------------------------------------------------- + +-- | The @Context@ is a stack of 'ContextEntry's. +type Context = [ContextEntry] +type ContextEntry = Dom (Name, Type) + +--------------------------------------------------------------------------- +-- ** Let bindings +--------------------------------------------------------------------------- + +type LetBindings = Map Name (Open (Term, Dom Type)) + +--------------------------------------------------------------------------- +-- ** Abstract mode +--------------------------------------------------------------------------- + +data AbstractMode + = AbstractMode -- ^ Abstract things in the current module can be accessed. + | ConcreteMode -- ^ No abstract things can be accessed. + | IgnoreAbstractMode -- ^ All abstract things can be accessed. + deriving (Data, Show, Eq) + +aDefToMode :: IsAbstract -> AbstractMode +aDefToMode AbstractDef = AbstractMode +aDefToMode ConcreteDef = ConcreteMode + +aModeToDef :: AbstractMode -> Maybe IsAbstract +aModeToDef AbstractMode = Just AbstractDef +aModeToDef ConcreteMode = Just ConcreteDef +aModeToDef _ = Nothing + +--------------------------------------------------------------------------- +-- ** Insertion of implicit arguments +--------------------------------------------------------------------------- + +data ExpandHidden + = ExpandLast -- ^ Add implicit arguments in the end until type is no longer hidden 'Pi'. + | DontExpandLast -- ^ Do not append implicit arguments. + | ReallyDontExpandLast -- ^ Makes 'doExpandLast' have no effect. Used to avoid implicit insertion of arguments to metavariables. + deriving (Eq, Data) + +isDontExpandLast :: ExpandHidden -> Bool +isDontExpandLast ExpandLast = False +isDontExpandLast DontExpandLast = True +isDontExpandLast ReallyDontExpandLast = True + +-- | A candidate solution for an instance meta is a term with its type. +-- It may be the case that the candidate is not fully applied yet or +-- of the wrong type, hence the need for the type. +data Candidate = Candidate { candidateTerm :: Term + , candidateType :: Type + , candidateOverlappable :: Bool + } + deriving (Show, Data) + +instance Free Candidate where + freeVars' (Candidate t u _) = freeVars' (t, u) + +--------------------------------------------------------------------------- +-- * Type checking warnings (aka non-fatal errors) +--------------------------------------------------------------------------- + +-- | A non-fatal error is an error which does not prevent us from +-- checking the document further and interacting with the user. + +data Warning + = NicifierIssue DeclarationWarning + | TerminationIssue [TerminationError] + | UnreachableClauses QName [Range] + -- ^ `UnreachableClauses f rs` means that the clauses in `f` whose ranges are rs + -- are unreachable + | CoverageIssue QName [(Telescope, [NamedArg DeBruijnPattern])] + -- ^ `CoverageIssue f pss` means that `pss` are not covered in `f` + | CoverageNoExactSplit QName [Clause] + | NotStrictlyPositive QName (Seq OccursWhere) + | UnsolvedMetaVariables [Range] -- ^ Do not use directly with 'warning' + | UnsolvedInteractionMetas [Range] -- ^ Do not use directly with 'warning' + | UnsolvedConstraints Constraints + -- ^ Do not use directly with 'warning' + | CantGeneralizeOverSorts [MetaId] + | AbsurdPatternRequiresNoRHS [NamedArg DeBruijnPattern] + | OldBuiltin String String + -- ^ In `OldBuiltin old new`, the BUILTIN old has been replaced by new + | EmptyRewritePragma + -- ^ If the user wrote just @{-\# REWRITE \#-}@. + | IllformedAsClause String + -- ^ If the user wrote something other than an unqualified name + -- in the @as@ clause of an @import@ statement. + -- The 'String' gives optionally extra explanation. + | ClashesViaRenaming NameOrModule [C.Name] + -- ^ If a `renaming' import directive introduces a name or module name clash + -- in the exported names of a module. + -- (See issue #4154.) + | UselessPublic + -- ^ If the user opens a module public before the module header. + -- (See issue #2377.) + | UselessInline QName + | WrongInstanceDeclaration + | InstanceWithExplicitArg QName + -- ^ An instance was declared with an implicit argument, which means it + -- will never actually be considered by instance search. + | InstanceNoOutputTypeName Doc + -- ^ The type of an instance argument doesn't end in a named or + -- variable type, so it will never be considered by instance search. + | InstanceArgWithExplicitArg Doc + -- ^ As InstanceWithExplicitArg, but for local bindings rather than + -- top-level instances. + | InversionDepthReached QName + -- ^ The --inversion-max-depth was reached. + -- Generic warnings for one-off things + | GenericWarning Doc + -- ^ Harmless generic warning (not an error) + | GenericNonFatalError Doc + -- ^ Generic error which doesn't abort proceedings (not a warning) + -- Safe flag errors + | SafeFlagPostulate C.Name + | SafeFlagPragma [String] -- ^ Unsafe OPTIONS. + | SafeFlagNonTerminating + | SafeFlagTerminating + | SafeFlagWithoutKFlagPrimEraseEquality + | WithoutKFlagPrimEraseEquality + | SafeFlagNoPositivityCheck + | SafeFlagPolarity + | SafeFlagNoUniverseCheck + | SafeFlagNoCoverageCheck + | SafeFlagInjective + | SafeFlagEta -- ^ ETA pragma is unsafe. + | ParseWarning ParseWarning + | LibraryWarning LibWarning + | DeprecationWarning String String String + -- ^ `DeprecationWarning old new version`: + -- `old` is deprecated, use `new` instead. This will be an error in Agda `version`. + | UserWarning String + -- ^ User-defined warning (e.g. to mention that a name is deprecated) + | FixityInRenamingModule (NonEmpty Range) + -- ^ Fixity of modules cannot be changed via renaming (since modules have no fixity). + | ModuleDoesntExport C.QName [C.ImportedName] + -- ^ Some imported names are not actually exported by the source module + | InfectiveImport String ModuleName + -- ^ Importing a file using an infective option into one which doesn't + | CoInfectiveImport String ModuleName + -- ^ Importing a file not using a coinfective option from one which does + | RewriteNonConfluent Term Term Term Doc + -- ^ Confluence checker found critical pair and equality checking + -- resulted in a type error + | RewriteMaybeNonConfluent Term Term [Doc] + -- ^ Confluence checker got stuck on computing overlap between two + -- rewrite rules + | PragmaCompileErased BackendName QName + -- ^ COMPILE directive for an erased symbol + | NotInScopeW [C.QName] + -- ^ Out of scope error we can recover from + deriving (Show , Data) + + +warningName :: Warning -> WarningName +warningName = \case + -- special cases + NicifierIssue dw -> declarationWarningName dw + ParseWarning pw -> parseWarningName pw + LibraryWarning lw -> libraryWarningName lw + -- typechecking errors + CantGeneralizeOverSorts{} -> CantGeneralizeOverSorts_ + AbsurdPatternRequiresNoRHS{} -> AbsurdPatternRequiresNoRHS_ + CoverageIssue{} -> CoverageIssue_ + CoverageNoExactSplit{} -> CoverageNoExactSplit_ + DeprecationWarning{} -> DeprecationWarning_ + EmptyRewritePragma -> EmptyRewritePragma_ + IllformedAsClause{} -> IllformedAsClause_ + WrongInstanceDeclaration{} -> WrongInstanceDeclaration_ + InstanceWithExplicitArg{} -> InstanceWithExplicitArg_ + InstanceNoOutputTypeName{} -> InstanceNoOutputTypeName_ + InstanceArgWithExplicitArg{} -> InstanceArgWithExplicitArg_ + FixityInRenamingModule{} -> FixityInRenamingModule_ + GenericNonFatalError{} -> GenericNonFatalError_ + GenericWarning{} -> GenericWarning_ + InversionDepthReached{} -> InversionDepthReached_ + ModuleDoesntExport{} -> ModuleDoesntExport_ + NotInScopeW{} -> NotInScope_ + NotStrictlyPositive{} -> NotStrictlyPositive_ + OldBuiltin{} -> OldBuiltin_ + SafeFlagNoPositivityCheck -> SafeFlagNoPositivityCheck_ + SafeFlagNonTerminating -> SafeFlagNonTerminating_ + SafeFlagNoUniverseCheck -> SafeFlagNoUniverseCheck_ + SafeFlagPolarity -> SafeFlagPolarity_ + SafeFlagPostulate{} -> SafeFlagPostulate_ + SafeFlagPragma{} -> SafeFlagPragma_ + SafeFlagEta -> SafeFlagEta_ + SafeFlagInjective -> SafeFlagInjective_ + SafeFlagNoCoverageCheck -> SafeFlagNoCoverageCheck_ + SafeFlagWithoutKFlagPrimEraseEquality -> SafeFlagWithoutKFlagPrimEraseEquality_ + WithoutKFlagPrimEraseEquality -> WithoutKFlagPrimEraseEquality_ + SafeFlagTerminating -> SafeFlagTerminating_ + TerminationIssue{} -> TerminationIssue_ + UnreachableClauses{} -> UnreachableClauses_ + UnsolvedInteractionMetas{} -> UnsolvedInteractionMetas_ + UnsolvedConstraints{} -> UnsolvedConstraints_ + UnsolvedMetaVariables{} -> UnsolvedMetaVariables_ + UselessInline{} -> UselessInline_ + UselessPublic{} -> UselessPublic_ + ClashesViaRenaming{} -> ClashesViaRenaming_ + UserWarning{} -> UserWarning_ + InfectiveImport{} -> InfectiveImport_ + CoInfectiveImport{} -> CoInfectiveImport_ + RewriteNonConfluent{} -> RewriteNonConfluent_ + RewriteMaybeNonConfluent{} -> RewriteMaybeNonConfluent_ + PragmaCompileErased{} -> PragmaCompileErased_ + +data TCWarning + = TCWarning + { tcWarningRange :: Range + -- ^ Range where the warning was raised + , tcWarning :: Warning + -- ^ The warning itself + , tcWarningPrintedWarning :: Doc + -- ^ The warning printed in the state and environment where it was raised + , tcWarningCached :: Bool + -- ^ Should the warning be affected by caching. + } + deriving Show + + +tcWarningOrigin :: TCWarning -> SrcFile +tcWarningOrigin = rangeFile . tcWarningRange + +instance HasRange TCWarning where + getRange = tcWarningRange + +-- used for merging lists of warnings +instance Eq TCWarning where + (==) = (==) `on` tcWarningPrintedWarning + +--------------------------------------------------------------------------- +-- * Type checking errors +--------------------------------------------------------------------------- + +-- | Information about a call. + +data CallInfo = CallInfo + { callInfoTarget :: QName + -- ^ Target function name. + , callInfoRange :: Range + -- ^ Range of the target function. + , callInfoCall :: Closure Term + -- ^ To be formatted representation of the call. + } deriving (Data, Show) + +-- no Eq, Ord instances: too expensive! (see issues 851, 852) + +-- | We only 'show' the name of the callee. +instance Pretty CallInfo where pretty = pretty . callInfoTarget +instance AllNames CallInfo where allNames = singleton . callInfoTarget + +-- UNUSED, but keep! +-- -- | Call pathes are sequences of 'CallInfo's starting from a 'callSource'. +-- data CallPath = CallPath +-- { callSource :: QName +-- -- ^ The originator of the first call. +-- , callInfos :: [CallInfo] +-- -- ^ The calls, in order from source to final target. +-- } +-- deriving (Show) + +-- -- | 'CallPath'es can be connected, but there is no empty callpath. +-- -- Thus, they form a semigroup, but we choose to abuse 'Monoid'. +-- instance Monoid CallPath where +-- mempty = __IMPOSSIBLE__ +-- mappend (CallPath src cs) (CallPath _ cs') = CallPath src $ cs ++ cs' + +-- | Information about a mutual block which did not pass the +-- termination checker. + +data TerminationError = TerminationError + { termErrFunctions :: [QName] + -- ^ The functions which failed to check. (May not include + -- automatically generated functions.) + , termErrCalls :: [CallInfo] + -- ^ The problematic call sites. + } deriving (Data, Show) + +-- | Error when splitting a pattern variable into possible constructor patterns. +data SplitError + = NotADatatype (Closure Type) -- ^ Neither data type nor record. + | IrrelevantDatatype (Closure Type) -- ^ Data type, but in irrelevant position. + | ErasedDatatype Bool (Closure Type) -- ^ Data type, but in erased position. + -- If the boolean is 'True', + -- then the reason for the + -- error is that the K rule + -- is turned off. + | CoinductiveDatatype (Closure Type) -- ^ Split on codata not allowed. + -- UNUSED, but keep! + -- -- | NoRecordConstructor Type -- ^ record type, but no constructor + | UnificationStuck + { cantSplitConName :: QName -- ^ Constructor. + , cantSplitTel :: Telescope -- ^ Context for indices. + , cantSplitConIdx :: Args -- ^ Inferred indices (from type of constructor). + , cantSplitGivenIdx :: Args -- ^ Expected indices (from checking pattern). + , cantSplitFailures :: [UnificationFailure] -- ^ Reason(s) why unification got stuck. + } + | CosplitCatchall + -- ^ Copattern split with a catchall + | CosplitNoTarget + -- ^ We do not know the target type of the clause. + | CosplitNoRecordType (Closure Type) + -- ^ Target type is not a record type. + | CannotCreateMissingClause QName (Telescope,[NamedArg DeBruijnPattern]) Doc (Closure (Abs Type)) + + | GenericSplitError String + deriving (Show) + +data NegativeUnification + = UnifyConflict Telescope Term Term + | UnifyCycle Telescope Int Term + deriving (Show) + +data UnificationFailure + = UnifyIndicesNotVars Telescope Type Term Term Args -- ^ Failed to apply injectivity to constructor of indexed datatype + | UnifyRecursiveEq Telescope Type Int Term -- ^ Can't solve equation because variable occurs in (type of) lhs + | UnifyReflexiveEq Telescope Type Term -- ^ Can't solve reflexive equation because --without-K is enabled + | UnifyUnusableModality Telescope Type Int Term Modality -- ^ Can't solve equation because solution modality is less "usable" + deriving (Show) + +data UnquoteError + = BadVisibility String (Arg I.Term) + | ConInsteadOfDef QName String String + | DefInsteadOfCon QName String String + | NonCanonical String I.Term + | BlockedOnMeta TCState MetaId + | UnquotePanic String + deriving (Show) + +data TypeError + = InternalError String + | NotImplemented String + | NotSupported String + | CompilationError String + | PropMustBeSingleton + | DataMustEndInSort Term +{- UNUSED + | DataTooManyParameters + -- ^ In @data D xs where@ the number of parameters @xs@ does not fit the + -- the parameters given in the forward declaraion @data D Gamma : T@. +-} + | ShouldEndInApplicationOfTheDatatype Type + -- ^ The target of a constructor isn't an application of its + -- datatype. The 'Type' records what it does target. + | ShouldBeAppliedToTheDatatypeParameters Term Term + -- ^ The target of a constructor isn't its datatype applied to + -- something that isn't the parameters. First term is the correct + -- target and the second term is the actual target. + | ShouldBeApplicationOf Type QName + -- ^ Expected a type to be an application of a particular datatype. + | ConstructorPatternInWrongDatatype QName QName -- ^ constructor, datatype + | CantResolveOverloadedConstructorsTargetingSameDatatype QName [QName] + -- ^ Datatype, constructors. + | DoesNotConstructAnElementOf QName Type -- ^ constructor, type + | WrongHidingInLHS + -- ^ The left hand side of a function definition has a hidden argument + -- where a non-hidden was expected. + | WrongHidingInLambda Type + -- ^ Expected a non-hidden function and found a hidden lambda. + | WrongHidingInApplication Type + -- ^ A function is applied to a hidden argument where a non-hidden was expected. + | WrongNamedArgument (NamedArg A.Expr) [NamedName] + -- ^ A function is applied to a hidden named argument it does not have. + -- The list contains names of possible hidden arguments at this point. + | WrongIrrelevanceInLambda + -- ^ Wrong user-given relevance annotation in lambda. + | WrongQuantityInLambda + -- ^ Wrong user-given quantity annotation in lambda. + | WrongCohesionInLambda + -- ^ Wrong user-given cohesion annotation in lambda. + | QuantityMismatch Quantity Quantity + -- ^ The given quantity does not correspond to the expected quantity. + | HidingMismatch Hiding Hiding + -- ^ The given hiding does not correspond to the expected hiding. + | RelevanceMismatch Relevance Relevance + -- ^ The given relevance does not correspond to the expected relevane. + | UninstantiatedDotPattern A.Expr + | ForcedConstructorNotInstantiated A.Pattern + | IlltypedPattern A.Pattern Type + | IllformedProjectionPattern A.Pattern + | CannotEliminateWithPattern (NamedArg A.Pattern) Type + | WrongNumberOfConstructorArguments QName Nat Nat + | ShouldBeEmpty Type [DeBruijnPattern] + | ShouldBeASort Type + -- ^ The given type should have been a sort. + | ShouldBePi Type + -- ^ The given type should have been a pi. + | ShouldBePath Type + | ShouldBeRecordType Type + | ShouldBeRecordPattern DeBruijnPattern + | NotAProjectionPattern (NamedArg A.Pattern) + | NotAProperTerm + | InvalidTypeSort Sort + -- ^ This sort is not a type expression. + | InvalidType Term + -- ^ This term is not a type expression. + | FunctionTypeInSizeUniv Term + -- ^ This term, a function type constructor, lives in + -- @SizeUniv@, which is not allowed. + | SplitOnIrrelevant (Dom Type) + | SplitOnUnusableCohesion (Dom Type) + -- UNUSED: -- | SplitOnErased (Dom Type) + | SplitOnNonVariable Term Type + | DefinitionIsIrrelevant QName + | DefinitionIsErased QName + | VariableIsIrrelevant Name + | VariableIsErased Name + | VariableIsOfUnusableCohesion Name Cohesion + | UnequalLevel Comparison Level Level + | UnequalTerms Comparison Term Term CompareAs + | UnequalTypes Comparison Type Type +-- | UnequalTelescopes Comparison Telescope Telescope -- UNUSED + | UnequalRelevance Comparison Term Term + -- ^ The two function types have different relevance. + | UnequalQuantity Comparison Term Term + -- ^ The two function types have different relevance. + | UnequalCohesion Comparison Term Term + -- ^ The two function types have different cohesion. + | UnequalHiding Term Term + -- ^ The two function types have different hiding. + | UnequalSorts Sort Sort + | UnequalBecauseOfUniverseConflict Comparison Term Term + | NotLeqSort Sort Sort + | MetaCannotDependOn MetaId Nat + -- ^ The arguments are the meta variable and the parameter that it wants to depend on. + | MetaOccursInItself MetaId + | MetaIrrelevantSolution MetaId Term + | MetaErasedSolution MetaId Term + | GenericError String + | GenericDocError Doc + | BuiltinMustBeConstructor String A.Expr + | NoSuchBuiltinName String + | DuplicateBuiltinBinding String Term Term + | NoBindingForBuiltin String + | NoSuchPrimitiveFunction String + | DuplicatePrimitiveBinding String QName QName + | ShadowedModule C.Name [A.ModuleName] + | BuiltinInParameterisedModule String + | IllegalLetInTelescope C.TypedBinding + | IllegalPatternInTelescope C.Binder + | NoRHSRequiresAbsurdPattern [NamedArg A.Pattern] + | TooManyFields QName [C.Name] [C.Name] + -- ^ Record type, fields not supplied by user, non-fields not supplied. + | DuplicateFields [C.Name] + | DuplicateConstructors [C.Name] + | WithOnFreeVariable A.Expr Term + | UnexpectedWithPatterns [A.Pattern] + | WithClausePatternMismatch A.Pattern (NamedArg DeBruijnPattern) + | FieldOutsideRecord + | ModuleArityMismatch A.ModuleName Telescope [NamedArg A.Expr] + | GeneralizeCyclicDependency + | GeneralizeUnsolvedMeta + -- Coverage errors +-- UNUSED: | IncompletePatternMatching Term [Elim] -- can only happen if coverage checking is switched off + | SplitError SplitError + | ImpossibleConstructor QName NegativeUnification + -- Positivity errors + | TooManyPolarities QName Int + -- Import errors + | LocalVsImportedModuleClash ModuleName + | SolvedButOpenHoles + -- ^ Some interaction points (holes) have not been filled by user. + -- There are not 'UnsolvedMetas' since unification solved them. + -- This is an error, since interaction points are never filled + -- without user interaction. + | CyclicModuleDependency [C.TopLevelModuleName] + | FileNotFound C.TopLevelModuleName [AbsolutePath] + | OverlappingProjects AbsolutePath C.TopLevelModuleName C.TopLevelModuleName + | AmbiguousTopLevelModuleName C.TopLevelModuleName [AbsolutePath] + | ModuleNameUnexpected C.TopLevelModuleName C.TopLevelModuleName + -- ^ Found module name, expected module name. + | ModuleNameDoesntMatchFileName C.TopLevelModuleName [AbsolutePath] + | ClashingFileNamesFor ModuleName [AbsolutePath] + | ModuleDefinedInOtherFile C.TopLevelModuleName AbsolutePath AbsolutePath + -- ^ Module name, file from which it was loaded, file which + -- the include path says contains the module. + -- Scope errors + | BothWithAndRHS + | AbstractConstructorNotInScope A.QName + | NotInScope [C.QName] + | NoSuchModule C.QName + | AmbiguousName C.QName (NonEmpty A.QName) + | AmbiguousModule C.QName (NonEmpty A.ModuleName) + | ClashingDefinition C.QName A.QName + | ClashingModule A.ModuleName A.ModuleName + | ClashingImport C.Name A.QName + | ClashingModuleImport C.Name A.ModuleName + | PatternShadowsConstructor C.Name A.QName + | DuplicateImports C.QName [C.ImportedName] + | InvalidPattern C.Pattern + | RepeatedVariablesInPattern [C.Name] + | GeneralizeNotSupportedHere A.QName + | MultipleFixityDecls [(C.Name, [Fixity'])] + | MultiplePolarityPragmas [C.Name] + -- Concrete to Abstract errors + | NotAModuleExpr C.Expr + -- ^ The expr was used in the right hand side of an implicit module + -- definition, but it wasn't of the form @m Delta@. + | NotAnExpression C.Expr + | NotAValidLetBinding NiceDeclaration + | NotValidBeforeField NiceDeclaration + | NothingAppliedToHiddenArg C.Expr + | NothingAppliedToInstanceArg C.Expr + -- Pattern synonym errors + | BadArgumentsToPatternSynonym A.AmbiguousQName + | TooFewArgumentsToPatternSynonym A.AmbiguousQName + | CannotResolveAmbiguousPatternSynonym (NonEmpty (A.QName, A.PatternSynDefn)) + | UnusedVariableInPatternSynonym + -- Operator errors + | NoParseForApplication [C.Expr] + | AmbiguousParseForApplication [C.Expr] [C.Expr] + | NoParseForLHS LHSOrPatSyn C.Pattern + | AmbiguousParseForLHS LHSOrPatSyn C.Pattern [C.Pattern] + | OperatorInformation [NotationSection] TypeError +{- UNUSED + | NoParseForPatternSynonym C.Pattern + | AmbiguousParseForPatternSynonym C.Pattern [C.Pattern] +-} + -- Usage errors + -- Instance search errors + | InstanceNoCandidate Type [(Term, TCErr)] + -- Reflection errors + | UnquoteFailed UnquoteError + | DeBruijnIndexOutOfScope Nat Telescope [Name] + -- Language option errors + | NeedOptionCopatterns + | NeedOptionRewriting + | NeedOptionProp + -- Failure associated to warnings + | NonFatalErrors [TCWarning] + -- Instance search errors + | InstanceSearchDepthExhausted Term Type Int + | TriedToCopyConstrainedPrim QName + deriving Show + +-- | Distinguish error message when parsing lhs or pattern synonym, resp. +data LHSOrPatSyn = IsLHS | IsPatSyn deriving (Eq, Show) + +-- | Type-checking errors. + +data TCErr + = TypeError + { tcErrState :: TCState + -- ^ The state in which the error was raised. + , tcErrClosErr :: Closure TypeError + -- ^ The environment in which the error as raised plus the error. + } + | Exception Range Doc + | IOException TCState Range E.IOException + -- ^ The first argument is the state in which the error was + -- raised. + | PatternErr + -- ^ The exception which is usually caught. + -- Raised for pattern violations during unification ('assignV') + -- but also in other situations where we want to backtrack. + +instance Error TCErr where + strMsg = Exception noRange . text . strMsg + +instance Show TCErr where + show (TypeError _ e) = show (envRange $ clEnv e) ++ ": " ++ show (clValue e) + show (Exception r d) = show r ++ ": " ++ render d + show (IOException _ r e) = show r ++ ": " ++ show e + show PatternErr{} = "Pattern violation (you shouldn't see this)" + +instance HasRange TCErr where + getRange (TypeError _ cl) = envRange $ clEnv cl + getRange (Exception r _) = r + getRange (IOException s r _) = r + getRange PatternErr{} = noRange + +instance E.Exception TCErr + +----------------------------------------------------------------------------- +-- * Accessing options +----------------------------------------------------------------------------- + +class (Functor m, Applicative m, Monad m) => HasOptions m where + -- | Returns the pragma options which are currently in effect. + pragmaOptions :: m PragmaOptions + -- | Returns the command line options which are currently in effect. + commandLineOptions :: m CommandLineOptions + + default pragmaOptions :: (HasOptions n, MonadTrans t, m ~ t n) => m PragmaOptions + pragmaOptions = lift pragmaOptions + + default commandLineOptions :: (HasOptions n, MonadTrans t, m ~ t n) => m CommandLineOptions + commandLineOptions = lift commandLineOptions + +instance MonadIO m => HasOptions (TCMT m) where + pragmaOptions = useTC stPragmaOptions + + commandLineOptions = do + p <- useTC stPragmaOptions + cl <- stPersistentOptions . stPersistentState <$> getTC + return $ cl { optPragmaOptions = p } + +-- HasOptions lifts through monad transformers +-- (see default signatures in the HasOptions class). + +instance HasOptions m => HasOptions (ChangeT m) +instance HasOptions m => HasOptions (ExceptT e m) +instance HasOptions m => HasOptions (IdentityT m) +instance HasOptions m => HasOptions (ListT m) +instance HasOptions m => HasOptions (MaybeT m) +instance HasOptions m => HasOptions (ReaderT r m) +instance HasOptions m => HasOptions (StateT s m) +instance (HasOptions m, Monoid w) => HasOptions (WriterT w m) + +-- Ternary options are annoying to deal with so we provide auxiliary +-- definitions using @collapseDefault@. + +sizedTypesOption :: HasOptions m => m Bool +sizedTypesOption = collapseDefault . optSizedTypes <$> pragmaOptions + +guardednessOption :: HasOptions m => m Bool +guardednessOption = collapseDefault . optGuardedness <$> pragmaOptions + +withoutKOption :: HasOptions m => m Bool +withoutKOption = collapseDefault . optWithoutK <$> pragmaOptions + +-- | Gets the include directories. +-- +-- Precondition: 'optAbsoluteIncludePaths' must be nonempty (i.e. +-- 'setCommandLineOptions' must have run). + +getIncludeDirs :: HasOptions m => m [AbsolutePath] +getIncludeDirs = do + incs <- optAbsoluteIncludePaths <$> commandLineOptions + case incs of + [] -> __IMPOSSIBLE__ + _ -> return incs + +enableCaching :: HasOptions m => m Bool +enableCaching = optCaching <$> pragmaOptions +----------------------------------------------------------------------------- +-- * The reduce monad +----------------------------------------------------------------------------- + +-- | Environment of the reduce monad. +data ReduceEnv = ReduceEnv + { redEnv :: TCEnv -- ^ Read only access to environment. + , redSt :: TCState -- ^ Read only access to state (signature, metas...). + } + +mapRedEnv :: (TCEnv -> TCEnv) -> ReduceEnv -> ReduceEnv +mapRedEnv f s = s { redEnv = f (redEnv s) } + +mapRedSt :: (TCState -> TCState) -> ReduceEnv -> ReduceEnv +mapRedSt f s = s { redSt = f (redSt s) } + +mapRedEnvSt :: (TCEnv -> TCEnv) -> (TCState -> TCState) -> ReduceEnv + -> ReduceEnv +mapRedEnvSt f g (ReduceEnv e s) = ReduceEnv (f e) (g s) + +-- Lenses +reduceEnv :: Lens' TCEnv ReduceEnv +reduceEnv f s = f (redEnv s) <&> \ e -> s { redEnv = e } + +reduceSt :: Lens' TCState ReduceEnv +reduceSt f s = f (redSt s) <&> \ e -> s { redSt = e } + +newtype ReduceM a = ReduceM { unReduceM :: ReduceEnv -> a } +-- deriving (Functor, Applicative, Monad) + +onReduceEnv :: (ReduceEnv -> ReduceEnv) -> ReduceM a -> ReduceM a +onReduceEnv f (ReduceM m) = ReduceM (m . f) + +fmapReduce :: (a -> b) -> ReduceM a -> ReduceM b +fmapReduce f (ReduceM m) = ReduceM $ \ e -> f $! m e +{-# INLINE fmapReduce #-} + +apReduce :: ReduceM (a -> b) -> ReduceM a -> ReduceM b +apReduce (ReduceM f) (ReduceM x) = ReduceM $ \ e -> f e $! x e +{-# INLINE apReduce #-} + +bindReduce :: ReduceM a -> (a -> ReduceM b) -> ReduceM b +bindReduce (ReduceM m) f = ReduceM $ \ e -> unReduceM (f $! m e) e +{-# INLINE bindReduce #-} + +instance Functor ReduceM where + fmap = fmapReduce + +instance Applicative ReduceM where + pure x = ReduceM (const x) + (<*>) = apReduce + +instance Monad ReduceM where + return = pure + (>>=) = bindReduce + (>>) = (*>) +#if __GLASGOW_HASKELL__ < 808 + fail = Fail.fail +#endif + +instance Fail.MonadFail ReduceM where + fail = error + +instance ReadTCState ReduceM where + getTCState = ReduceM redSt + locallyTCState l f = onReduceEnv $ mapRedSt $ over l f + +runReduceM :: ReduceM a -> TCM a +runReduceM m = do + e <- askTC + s <- getTC + return $! unReduceM m (ReduceEnv e s) + +runReduceF :: (a -> ReduceM b) -> TCM (a -> b) +runReduceF f = do + e <- askTC + s <- getTC + return $ \x -> unReduceM (f x) (ReduceEnv e s) + +instance MonadTCEnv ReduceM where + askTC = ReduceM redEnv + localTC = onReduceEnv . mapRedEnv + +-- Andrea comments (https://github.com/agda/agda/issues/1829#issuecomment-522312084): +-- +-- useR forces the result of projecting the lens, +-- this usually prevents retaining the whole structure when we only need a field. +-- +-- This fixes (or contributes to the fix of) the space leak issue #1829 (caching). +useR :: (ReadTCState m) => Lens' a TCState -> m a +useR l = do + !x <- (^.l) <$> getTCState + return x + +askR :: ReduceM ReduceEnv +askR = ReduceM ask + +localR :: (ReduceEnv -> ReduceEnv) -> ReduceM a -> ReduceM a +localR f = ReduceM . local f . unReduceM + +instance HasOptions ReduceM where + pragmaOptions = useR stPragmaOptions + commandLineOptions = do + p <- useR stPragmaOptions + cl <- stPersistentOptions . stPersistentState <$> getTCState + return $ cl{ optPragmaOptions = p } + +class ( Applicative m + , MonadTCEnv m + , ReadTCState m + , HasOptions m + ) => MonadReduce m where + liftReduce :: ReduceM a -> m a + +instance MonadReduce m => MonadReduce (MaybeT m) where + liftReduce = lift . liftReduce + +instance MonadReduce m => MonadReduce (ListT m) where + liftReduce = lift . liftReduce + +instance MonadReduce m => MonadReduce (ExceptT err m) where + liftReduce = lift . liftReduce + +instance MonadReduce m => MonadReduce (ReaderT r m) where + liftReduce = lift . liftReduce + +instance (Monoid w, MonadReduce m) => MonadReduce (WriterT w m) where + liftReduce = lift . liftReduce + +instance MonadReduce m => MonadReduce (StateT w m) where + liftReduce = lift . liftReduce + +instance MonadReduce ReduceM where + liftReduce = id + +--------------------------------------------------------------------------- +-- * Monad with read-only 'TCEnv' +--------------------------------------------------------------------------- + +-- | @MonadTCEnv@ made into its own dedicated service class. +-- This allows us to use 'MonadReader' for 'ReaderT' extensions of @TCM@. +class Monad m => MonadTCEnv m where + askTC :: m TCEnv + localTC :: (TCEnv -> TCEnv) -> m a -> m a + +instance MonadTCEnv m => MonadTCEnv (MaybeT m) where + askTC = lift askTC + localTC = mapMaybeT . localTC + +instance MonadTCEnv m => MonadTCEnv (ListT m) where + askTC = lift askTC + localTC = mapListT . localTC + +instance MonadTCEnv m => MonadTCEnv (ExceptT err m) where + askTC = lift askTC + localTC = mapExceptT . localTC + +instance MonadTCEnv m => MonadTCEnv (ReaderT r m) where + askTC = lift askTC + localTC = mapReaderT . localTC + +instance (Monoid w, MonadTCEnv m) => MonadTCEnv (WriterT w m) where + askTC = lift askTC + localTC = mapWriterT . localTC + +instance MonadTCEnv m => MonadTCEnv (StateT s m) where + askTC = lift askTC + localTC = mapStateT . localTC + +instance MonadTCEnv m => MonadTCEnv (ChangeT m) where + askTC = lift askTC + localTC = mapChangeT . localTC + +instance MonadTCEnv m => MonadTCEnv (IdentityT m) where + askTC = lift askTC + localTC = mapIdentityT . localTC + +asksTC :: MonadTCEnv m => (TCEnv -> a) -> m a +asksTC f = f <$> askTC + +viewTC :: MonadTCEnv m => Lens' a TCEnv -> m a +viewTC l = asksTC (^. l) + +-- | Modify the lens-indicated part of the @TCEnv@ in a subcomputation. +locallyTC :: MonadTCEnv m => Lens' a TCEnv -> (a -> a) -> m b -> m b +locallyTC l = localTC . over l + +--------------------------------------------------------------------------- +-- * Monad with mutable 'TCState' +--------------------------------------------------------------------------- + +-- | @MonadTCState@ made into its own dedicated service class. +-- This allows us to use 'MonadState' for 'StateT' extensions of @TCM@. +class Monad m => MonadTCState m where + getTC :: m TCState + putTC :: TCState -> m () + modifyTC :: (TCState -> TCState) -> m () + + {-# MINIMAL getTC, (putTC | modifyTC) #-} + putTC = modifyTC . const + modifyTC f = putTC . f =<< getTC + +instance MonadTCState m => MonadTCState (MaybeT m) where + getTC = lift getTC + putTC = lift . putTC + modifyTC = lift . modifyTC + +instance MonadTCState m => MonadTCState (ListT m) where + getTC = lift getTC + putTC = lift . putTC + modifyTC = lift . modifyTC + +instance MonadTCState m => MonadTCState (ExceptT err m) where + getTC = lift getTC + putTC = lift . putTC + modifyTC = lift . modifyTC + +instance MonadTCState m => MonadTCState (ReaderT r m) where + getTC = lift getTC + putTC = lift . putTC + modifyTC = lift . modifyTC + +instance (Monoid w, MonadTCState m) => MonadTCState (WriterT w m) where + getTC = lift getTC + putTC = lift . putTC + modifyTC = lift . modifyTC + +instance MonadTCState m => MonadTCState (StateT s m) where + getTC = lift getTC + putTC = lift . putTC + modifyTC = lift . modifyTC + +instance MonadTCState m => MonadTCState (ChangeT m) where + getTC = lift getTC + putTC = lift . putTC + modifyTC = lift . modifyTC + +instance MonadTCState m => MonadTCState (IdentityT m) where + getTC = lift getTC + putTC = lift . putTC + modifyTC = lift . modifyTC + +-- ** @TCState@ accessors (no lenses) + +getsTC :: ReadTCState m => (TCState -> a) -> m a +getsTC f = f <$> getTCState + +-- | A variant of 'modifyTC' in which the computation is strict in the +-- new state. +modifyTC' :: MonadTCState m => (TCState -> TCState) -> m () +modifyTC' f = do + s' <- getTC + putTC $! f s' + +-- SEE TC.Monad.State +-- -- | Restore the 'TCState' after computation. +-- localTCState :: MonadTCState m => m a -> m a +-- localTCState = bracket_ getTC putTC + +-- ** @TCState@ accessors via lenses + +useTC :: ReadTCState m => Lens' a TCState -> m a +useTC l = do + !x <- getsTC (^. l) + return x + +infix 4 `setTCLens` + +-- | Overwrite the part of the 'TCState' focused on by the lens. +setTCLens :: MonadTCState m => Lens' a TCState -> a -> m () +setTCLens l = modifyTC . set l + +-- | Modify the part of the 'TCState' focused on by the lens. +modifyTCLens :: MonadTCState m => Lens' a TCState -> (a -> a) -> m () +modifyTCLens l = modifyTC . over l + +-- | Modify a part of the state monadically. +modifyTCLensM :: MonadTCState m => Lens' a TCState -> (a -> m a) -> m () +modifyTCLensM l f = putTC =<< l f =<< getTC + +-- | Modify the part of the 'TCState' focused on by the lens, and return some result. +stateTCLens :: MonadTCState m => Lens' a TCState -> (a -> (r , a)) -> m r +stateTCLens l f = stateTCLensM l $ return . f + +-- | Modify a part of the state monadically, and return some result. +stateTCLensM :: MonadTCState m => Lens' a TCState -> (a -> m (r , a)) -> m r +stateTCLensM l f = do + s <- getTC + (result , x) <- f $ s ^. l + putTC $ set l x s + return result + +--------------------------------------------------------------------------- +-- * Type checking monad transformer +--------------------------------------------------------------------------- + +-- | The type checking monad transformer. +-- Adds readonly 'TCEnv' and mutable 'TCState'. +newtype TCMT m a = TCM { unTCM :: IORef TCState -> TCEnv -> m a } + +-- | Type checking monad. +type TCM = TCMT IO + +{-# SPECIALIZE INLINE mapTCMT :: (forall a. IO a -> IO a) -> TCM a -> TCM a #-} +mapTCMT :: (forall a. m a -> n a) -> TCMT m a -> TCMT n a +mapTCMT f (TCM m) = TCM $ \ s e -> f (m s e) + +pureTCM :: MonadIO m => (TCState -> TCEnv -> a) -> TCMT m a +pureTCM f = TCM $ \ r e -> do + s <- liftIO $ readIORef r + return (f s e) + +-- One goal of the definitions and pragmas below is to inline the +-- monad operations as much as possible. This doesn't seem to have a +-- large effect on the performance of the normal executable, but (at +-- least on one machine/configuration) it has a massive effect on the +-- performance of the profiling executable [1], and reduces the time +-- attributed to bind from over 90% to about 25%. +-- +-- [1] When compiled with -auto-all and run with -p: roughly 750% +-- faster for one example. + +returnTCMT :: MonadIO m => a -> TCMT m a +returnTCMT = \x -> TCM $ \_ _ -> return x +{-# INLINE returnTCMT #-} + +bindTCMT :: MonadIO m => TCMT m a -> (a -> TCMT m b) -> TCMT m b +bindTCMT = \(TCM m) k -> TCM $ \r e -> m r e >>= \x -> unTCM (k x) r e +{-# INLINE bindTCMT #-} + +thenTCMT :: MonadIO m => TCMT m a -> TCMT m b -> TCMT m b +thenTCMT = \(TCM m1) (TCM m2) -> TCM $ \r e -> m1 r e >> m2 r e +{-# INLINE thenTCMT #-} + +instance MonadIO m => Functor (TCMT m) where + fmap = fmapTCMT + +fmapTCMT :: MonadIO m => (a -> b) -> TCMT m a -> TCMT m b +fmapTCMT = \f (TCM m) -> TCM $ \r e -> liftM f (m r e) +{-# INLINE fmapTCMT #-} + +instance MonadIO m => Applicative (TCMT m) where + pure = returnTCMT + (<*>) = apTCMT + +apTCMT :: MonadIO m => TCMT m (a -> b) -> TCMT m a -> TCMT m b +apTCMT = \(TCM mf) (TCM m) -> TCM $ \r e -> ap (mf r e) (m r e) +{-# INLINE apTCMT #-} + +instance MonadTrans TCMT where + lift m = TCM $ \_ _ -> m + +-- We want a special monad implementation of fail. +instance MonadIO m => Monad (TCMT m) where + return = pure + (>>=) = bindTCMT + (>>) = (*>) +#if __GLASGOW_HASKELL__ < 808 + fail = Fail.fail +#endif + +instance MonadIO m => Fail.MonadFail (TCMT m) where + fail = internalError + +instance MonadIO m => MonadIO (TCMT m) where + liftIO m = TCM $ \ s env -> do + liftIO $ wrap s (envRange env) $ do + x <- m + x `seq` return x + where + wrap s r m = E.catch m $ \ err -> do + s <- readIORef s + E.throwIO $ IOException s r err + +instance MonadIO m => MonadTCEnv (TCMT m) where + askTC = TCM $ \ _ e -> return e + localTC f (TCM m) = TCM $ \ s e -> m s (f e) + +instance MonadIO m => MonadTCState (TCMT m) where + getTC = TCM $ \ r _e -> liftIO (readIORef r) + putTC s = TCM $ \ r _e -> liftIO (writeIORef r s) + +instance MonadIO m => ReadTCState (TCMT m) where + getTCState = getTC + locallyTCState l f = bracket_ (useTC l <* modifyTCLens l f) (setTCLens l) + +instance MonadError TCErr TCM where + throwError = liftIO . E.throwIO + catchError m h = TCM $ \ r e -> do -- now we are in the IO monad + oldState <- readIORef r + unTCM m r e `E.catch` \err -> do + -- Reset the state, but do not forget changes to the persistent + -- component. Not for pattern violations. + case err of + PatternErr -> return () + _ -> + liftIO $ do + newState <- readIORef r + writeIORef r $ oldState { stPersistentState = stPersistentState newState } + unTCM (h err) r e + +-- | Like 'catchError', but resets the state completely before running the handler. +-- This means it also loses changes to the 'stPersistentState'. +-- +-- The intended use is to catch internal errors during debug printing. +-- In debug printing, we are not expecting state changes. +instance CatchImpossible TCM where + catchImpossibleJust f m h = TCM $ \ r e -> do + -- save the state + s <- readIORef r + catchImpossibleJust f (unTCM m r e) $ \ err -> do + writeIORef r s + unTCM (h err) r e + +instance MonadIO m => MonadReduce (TCMT m) where + liftReduce = liftTCM . runReduceM + +instance (IsString a, MonadIO m) => IsString (TCMT m a) where + fromString s = return (fromString s) + +-- | Strict (non-shortcut) semigroup. +-- +-- Note that there might be a lazy alternative, e.g., +-- for TCM All we might want 'Agda.Utils.Monad.and2M' as concatenation, +-- to shortcut conjunction in case we already have 'False'. +-- +instance {-# OVERLAPPABLE #-} (MonadIO m, Semigroup a) => Semigroup (TCMT m a) where + (<>) = liftA2 (<>) + +-- | Strict (non-shortcut) monoid. +instance {-# OVERLAPPABLE #-} (MonadIO m, Semigroup a, Monoid a) => Monoid (TCMT m a) where + mempty = pure mempty + mappend = (<>) + mconcat = mconcat <.> sequence + +-- | Interaction monad. + +type IM = TCMT (Haskeline.InputT IO) + +runIM :: IM a -> TCM a +runIM = mapTCMT (Haskeline.runInputT Haskeline.defaultSettings) + +instance MonadError TCErr IM where + throwError = liftIO . E.throwIO + catchError m h = liftTCM $ runIM m `catchError` (runIM . h) + +-- | Preserve the state of the failing computation. +catchError_ :: TCM a -> (TCErr -> TCM a) -> TCM a +catchError_ m h = TCM $ \r e -> + unTCM m r e + `E.catch` \err -> unTCM (h err) r e + +-- | Execute a finalizer even when an exception is thrown. +-- Does not catch any errors. +-- In case both the regular computation and the finalizer +-- throw an exception, the one of the finalizer is propagated. +finally_ :: TCM a -> TCM b -> TCM a +finally_ m f = do + x <- m `catchError_` \ err -> f >> throwError err + _ <- f + return x + +-- | Embedding a TCM computation. + +class ( Applicative tcm, MonadIO tcm + , MonadTCEnv tcm + , MonadTCState tcm + , HasOptions tcm + ) => MonadTCM tcm where + liftTCM :: TCM a -> tcm a + + default liftTCM :: (MonadTCM m, MonadTrans t, tcm ~ t m) => TCM a -> tcm a + liftTCM = lift . liftTCM + +{-# RULES "liftTCM/id" liftTCM = id #-} +instance MonadIO m => MonadTCM (TCMT m) where + liftTCM = mapTCMT liftIO + +instance MonadTCM tcm => MonadTCM (ChangeT tcm) +instance MonadTCM tcm => MonadTCM (ExceptT err tcm) +instance MonadTCM tcm => MonadTCM (IdentityT tcm) +instance MonadTCM tcm => MonadTCM (ListT tcm) +instance MonadTCM tcm => MonadTCM (MaybeT tcm) +instance MonadTCM tcm => MonadTCM (ReaderT r tcm) +instance MonadTCM tcm => MonadTCM (StateT s tcm) +instance (Monoid w, MonadTCM tcm) => MonadTCM (WriterT w tcm) + +-- | We store benchmark statistics in an IORef. +-- This enables benchmarking pure computation, see +-- "Agda.Benchmarking". +instance MonadBench Phase TCM where + getBenchmark = liftIO $ getBenchmark + putBenchmark = liftIO . putBenchmark + finally = finally_ + +instance Null (TCM Doc) where + empty = return empty + null = __IMPOSSIBLE__ + +patternViolation :: MonadError TCErr m => m a +patternViolation = throwError PatternErr + +internalError :: MonadTCM tcm => String -> tcm a +internalError s = liftTCM $ typeError $ InternalError s + +genericError :: (MonadTCEnv m, ReadTCState m, MonadError TCErr m) + => String -> m a +genericError = typeError . GenericError + +{-# SPECIALIZE genericDocError :: Doc -> TCM a #-} +genericDocError :: (MonadTCEnv m, ReadTCState m, MonadError TCErr m) + => Doc -> m a +genericDocError = typeError . GenericDocError + +{-# SPECIALIZE typeError :: TypeError -> TCM a #-} +typeError :: (MonadTCEnv m, ReadTCState m, MonadError TCErr m) + => TypeError -> m a +typeError err = throwError =<< typeError_ err + +{-# SPECIALIZE typeError_ :: TypeError -> TCM TCErr #-} +typeError_ :: (MonadTCEnv m, ReadTCState m) => TypeError -> m TCErr +typeError_ err = TypeError <$> getTCState <*> buildClosure err + +-- | Running the type checking monad (most general form). +{-# SPECIALIZE runTCM :: TCEnv -> TCState -> TCM a -> IO (a, TCState) #-} +runTCM :: MonadIO m => TCEnv -> TCState -> TCMT m a -> m (a, TCState) +runTCM e s m = do + r <- liftIO $ newIORef s + a <- unTCM m r e + s <- liftIO $ readIORef r + return (a, s) + +-- | Running the type checking monad on toplevel (with initial state). +runTCMTop :: TCM a -> IO (Either TCErr a) +runTCMTop m = (Right <$> runTCMTop' m) `E.catch` (return . Left) + +runTCMTop' :: MonadIO m => TCMT m a -> m a +runTCMTop' m = do + r <- liftIO $ newIORef initState + unTCM m r initEnv + +-- | 'runSafeTCM' runs a safe 'TCM' action (a 'TCM' action which cannot fail) +-- in the initial environment. + +runSafeTCM :: TCM a -> TCState -> IO (a, TCState) +runSafeTCM m st = runTCM initEnv st m `E.catch` (\ (e :: TCErr) -> __IMPOSSIBLE__) +-- runSafeTCM m st = either__IMPOSSIBLE__ return <$> do +-- -- Errors must be impossible. +-- runTCM $ do +-- putTC st +-- a <- m +-- st <- getTC +-- return (a, st) + +-- | Runs the given computation in a separate thread, with /a copy/ of +-- the current state and environment. +-- +-- Note that Agda sometimes uses actual, mutable state. If the +-- computation given to @forkTCM@ tries to /modify/ this state, then +-- bad things can happen, because accesses are not mutually exclusive. +-- The @forkTCM@ function has been added mainly to allow the thread to +-- /read/ (a snapshot of) the current state in a convenient way. +-- +-- Note also that exceptions which are raised in the thread are not +-- propagated to the parent, so the thread should not do anything +-- important. + +forkTCM :: TCM a -> TCM () +forkTCM m = do + s <- getTC + e <- askTC + liftIO $ void $ C.forkIO $ void $ runTCM e s m + +--------------------------------------------------------------------------- +-- * Names for generated definitions +--------------------------------------------------------------------------- + +-- | Base name for patterns in telescopes +patternInTeleName :: String +patternInTeleName = ".patternInTele" + +-- | Base name for extended lambda patterns +extendedLambdaName :: String +extendedLambdaName = ".extendedlambda" + +-- | Check whether we have an definition from an extended lambda. +isExtendedLambdaName :: A.QName -> Bool +isExtendedLambdaName = (extendedLambdaName `List.isPrefixOf`) . prettyShow . nameConcrete . qnameName + +-- | Name of absurdLambda definitions. +absurdLambdaName :: String +absurdLambdaName = ".absurdlambda" + +-- | Check whether we have an definition from an absurd lambda. +isAbsurdLambdaName :: QName -> Bool +isAbsurdLambdaName = (absurdLambdaName ==) . prettyShow . qnameName + +-- | Base name for generalized variable projections +generalizedFieldName :: String +generalizedFieldName = ".generalizedField-" + +-- | Check whether we have a generalized variable field +getGeneralizedFieldName :: A.QName -> Maybe String +getGeneralizedFieldName q + | List.isPrefixOf generalizedFieldName strName = Just (drop (length generalizedFieldName) strName) + | otherwise = Nothing + where strName = prettyShow $ nameConcrete $ qnameName q + +--------------------------------------------------------------------------- +-- * KillRange instances +--------------------------------------------------------------------------- + +instance KillRange Signature where + killRange (Sig secs defs rews) = killRange2 Sig secs defs rews + +instance KillRange Sections where + killRange = fmap killRange + +instance KillRange Definitions where + killRange = fmap killRange + +instance KillRange RewriteRuleMap where + killRange = fmap killRange + +instance KillRange Section where + killRange (Section tel) = killRange1 Section tel + +instance KillRange Definition where + killRange (Defn ai name t pols occs gens gpars displ mut compiled inst copy ma nc inj copat blk def) = + killRange18 Defn ai name t pols occs gens gpars displ mut compiled inst copy ma nc inj copat blk def + -- TODO clarify: Keep the range in the defName field? + +instance KillRange NumGeneralizableArgs where + killRange = id + +instance KillRange NLPat where + killRange (PVar x y) = killRange2 PVar x y + killRange (PDef x y) = killRange2 PDef x y + killRange (PLam x y) = killRange2 PLam x y + killRange (PPi x y) = killRange2 PPi x y + killRange (PSort x) = killRange1 PSort x + killRange (PBoundVar x y) = killRange2 PBoundVar x y + killRange (PTerm x) = killRange1 PTerm x + +instance KillRange NLPType where + killRange (NLPType s a) = killRange2 NLPType s a + +instance KillRange NLPSort where + killRange (PType l) = killRange1 PType l + killRange (PProp l) = killRange1 PProp l + killRange PInf = PInf + killRange PSizeUniv = PSizeUniv + +instance KillRange RewriteRule where + killRange (RewriteRule q gamma f es rhs t) = + killRange6 RewriteRule q gamma f es rhs t + +instance KillRange CompiledRepresentation where + killRange = id + + +instance KillRange EtaEquality where + killRange = id + +instance KillRange System where + killRange (System tel sys) = System (killRange tel) (killRange sys) + +instance KillRange ExtLamInfo where + killRange (ExtLamInfo m sys) = killRange2 ExtLamInfo m sys + +instance KillRange FunctionFlag where + killRange = id + +instance KillRange CompKit where + killRange = id + +instance KillRange Defn where + killRange def = + case def of + Axiom -> Axiom + DataOrRecSig n -> DataOrRecSig n + GeneralizableVar -> GeneralizableVar + AbstractDefn{} -> __IMPOSSIBLE__ -- only returned by 'getConstInfo'! + Function cls comp ct tt covering inv mut isAbs delayed proj flags term extlam with -> + killRange14 Function cls comp ct tt covering inv mut isAbs delayed proj flags term extlam with + Datatype a b c d e f g h -> killRange7 Datatype a b c d e f g h + Record a b c d e f g h i j k -> killRange11 Record a b c d e f g h i j k + Constructor a b c d e f g h i j-> killRange10 Constructor a b c d e f g h i j Primitive a b c d e -> killRange5 Primitive a b c d e instance KillRange MutualId where diff --git a/src/full/Agda/TypeChecking/Monad/Base.hs-boot b/src/full/Agda/TypeChecking/Monad/Base.hs-boot --- a/src/full/Agda/TypeChecking/Monad/Base.hs-boot +++ b/src/full/Agda/TypeChecking/Monad/Base.hs-boot @@ -5,10 +5,24 @@ import Data.IORef (IORef) import Data.Map (Map) +import Agda.Syntax.Common (Nat) import Agda.Syntax.Concrete.Name (TopLevelModuleName) import Agda.Utils.FileName (AbsolutePath) +data Warning + +data TCErr +data TCWarning +data NamedMeta data HighlightingMethod +instance Show HighlightingMethod +instance Read HighlightingMethod + +data HighlightingLevel +instance Show HighlightingLevel +instance Read HighlightingLevel + + data TCEnv data TCState newtype TCMT m a = TCM { unTCM :: IORef TCState -> TCEnv -> m a } @@ -21,3 +35,9 @@ type TCM = TCMT IO type ModuleToSource = Map TopLevelModuleName AbsolutePath + +type BackendName = String + +data Comparison +newtype ProblemId = ProblemId Nat +data Polarity diff --git a/src/full/Agda/TypeChecking/Monad/Benchmark.hs b/src/full/Agda/TypeChecking/Monad/Benchmark.hs --- a/src/full/Agda/TypeChecking/Monad/Benchmark.hs +++ b/src/full/Agda/TypeChecking/Monad/Benchmark.hs @@ -16,7 +16,6 @@ import Agda.TypeChecking.Monad.Base import Agda.TypeChecking.Monad.Debug -import{-# SOURCE #-} Agda.TypeChecking.Monad.Options import qualified Agda.Utils.Benchmark as B @@ -64,7 +63,7 @@ _ -> B.BenchmarkOff -- | Prints the accumulated benchmark results. Does nothing if --- profiling is not activated at level 7. +-- profiling is not activated at level 2. print :: MonadTCM tcm => tcm () print = liftTCM $ whenM (B.isBenchmarkOn [] <$> benchmarking) $ do b <- B.getBenchmark @@ -73,7 +72,12 @@ -- thus, as Fredrik Forsberg suggest, I restore the original -- line for release 2.5.3 until a fix is found. -- reportSLn "" 0 $ prettyShow b - reportSLn benchmarkKey benchmarkLevel $ prettyShow b + -- Ulf, 2020-03-04: Using benchmarkLevel here means that it only prints if internal benchmarking + -- is turned on, effectively making module/definition benchmarking impossible (since internal + -- takes precedence). It needs to be > 1 to avoid triggering #2602 though. Also use + -- displayDebugMessage instead of reportSLn to avoid requiring -v profile:2 in addition to the + -- specific profile levels. + displayDebugMessage benchmarkKey 2 $ prettyShow b -- -- | Bill a computation to a specific account. -- {-# SPECIALIZE billTo :: Account -> TCM a -> TCM a #-} diff --git a/src/full/Agda/TypeChecking/Monad/Builtin.hs b/src/full/Agda/TypeChecking/Monad/Builtin.hs --- a/src/full/Agda/TypeChecking/Monad/Builtin.hs +++ b/src/full/Agda/TypeChecking/Monad/Builtin.hs @@ -1,16 +1,15 @@ -{-# LANGUAGE CPP #-} module Agda.TypeChecking.Monad.Builtin ( module Agda.TypeChecking.Monad.Builtin , module Agda.Syntax.Builtin -- The names are defined here. ) where -#if __GLASGOW_HASKELL__ >= 800 import qualified Control.Monad.Fail as Fail -#endif +import Control.Monad.Reader import Control.Monad.State import Control.Monad.Trans.Maybe +import Control.Monad.Writer import qualified Data.Map as Map import Data.Function ( on ) @@ -25,21 +24,16 @@ import Agda.TypeChecking.Substitute import Agda.Utils.Except -import Agda.Utils.Lens +import Agda.Utils.ListT import Agda.Utils.Monad import Agda.Utils.Maybe import Agda.Utils.Tuple -#include "undefined.h" import Agda.Utils.Impossible class ( Functor m , Applicative m -#if __GLASGOW_HASKELL__ < 800 - , Monad m -#else , Fail.MonadFail m -#endif ) => HasBuiltins m where getBuiltinThing :: String -> m (Maybe (Builtin PrimFun)) @@ -49,10 +43,25 @@ instance HasBuiltins m => HasBuiltins (ExceptT e m) where getBuiltinThing b = lift $ getBuiltinThing b +instance HasBuiltins m => HasBuiltins (ListT m) where + getBuiltinThing b = lift $ getBuiltinThing b + +instance HasBuiltins m => HasBuiltins (ReaderT e m) where + getBuiltinThing b = lift $ getBuiltinThing b + instance HasBuiltins m => HasBuiltins (StateT s m) where getBuiltinThing b = lift $ getBuiltinThing b -litType :: Literal -> TCM Type +instance (HasBuiltins m, Monoid w) => HasBuiltins (WriterT w m) where + getBuiltinThing b = lift $ getBuiltinThing b + +-- If Agda is changed so that the type of a literal can belong to an +-- inductive family (with at least one index), then the implementation +-- of split' in Agda.TypeChecking.Coverage should be changed. + +litType + :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) + => Literal -> m Type litType l = case l of LitNat _ n -> do _ <- primZero @@ -90,7 +99,8 @@ Just (Prim x) -> typeError $ (DuplicatePrimitiveBinding b `on` primFunName) x pf Nothing -> stLocalBuiltins `modifyTCLens` Map.insert b (Prim pf) -getBuiltin :: String -> TCM Term +getBuiltin :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) + => String -> m Term getBuiltin x = fromMaybeM (typeError $ NoBindingForBuiltin x) $ getBuiltin' x @@ -107,11 +117,13 @@ getPrim (Prim pf) = return pf getPrim _ = Nothing -getPrimitive :: String -> TCM PrimFun +getPrimitive :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) + => String -> m PrimFun getPrimitive x = fromMaybeM (typeError $ NoSuchPrimitiveFunction x) $ getPrimitive' x -getPrimitiveTerm :: String -> TCM Term +getPrimitiveTerm :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) + => String -> m Term getPrimitiveTerm x = (`Def` []) <$> primFunName <$> getPrimitive x getPrimitiveTerm' :: HasBuiltins m => String -> m (Maybe Term) @@ -133,7 +145,8 @@ -- | Rewrite a literal to constructor form if possible. -constructorForm :: Term -> TCM Term +constructorForm :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) + => Term -> m Term constructorForm v = constructorForm' primZero primSuc v constructorForm' :: Applicative m => m Term -> m Term -> Term -> m Term @@ -159,8 +172,10 @@ primSub, primSubIn, primSubOut, primTrans, primHComp, primId, primConId, primIdElim, - primEquiv, primEquivFun, primEquivProof, primPathToEquiv, + primEquiv, primEquivFun, primEquivProof, + primTranspProof, primGlue, prim_glue, prim_unglue, + prim_glueU, prim_unglueU, primFaceForall, primNatPlus, primNatMinus, primNatTimes, primNatDivSucAux, primNatModSucAux, primNatEquality, primNatLess, @@ -203,182 +218,184 @@ primAgdaTCMWithNormalisation, primAgdaTCMDebugPrint, primAgdaTCMNoConstraints, primAgdaTCMRunSpeculative - :: TCM Term + :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) => m Term -primInteger = getBuiltin builtinInteger -primIntegerPos = getBuiltin builtinIntegerPos -primIntegerNegSuc = getBuiltin builtinIntegerNegSuc -primFloat = getBuiltin builtinFloat -primChar = getBuiltin builtinChar -primString = getBuiltin builtinString -primBool = getBuiltin builtinBool -primSigma = getBuiltin builtinSigma -primUnit = getBuiltin builtinUnit -primUnitUnit = getBuiltin builtinUnitUnit -primTrue = getBuiltin builtinTrue -primFalse = getBuiltin builtinFalse -primList = getBuiltin builtinList -primNil = getBuiltin builtinNil -primCons = getBuiltin builtinCons -primIO = getBuiltin builtinIO -primId = getBuiltin builtinId -primConId = getBuiltin builtinConId -primIdElim = getPrimitiveTerm builtinIdElim -primPath = getBuiltin builtinPath -primPathP = getBuiltin builtinPathP -primInterval = getBuiltin builtinInterval -primIZero = getBuiltin builtinIZero -primIOne = getBuiltin builtinIOne -primIMin = getPrimitiveTerm builtinIMin -primIMax = getPrimitiveTerm builtinIMax -primINeg = getPrimitiveTerm builtinINeg -primPartial = getPrimitiveTerm "primPartial" -primPartialP = getPrimitiveTerm "primPartialP" -primIsOne = getBuiltin builtinIsOne -primItIsOne = getBuiltin builtinItIsOne -primTrans = getPrimitiveTerm builtinTrans -primHComp = getPrimitiveTerm builtinHComp -primEquiv = getBuiltin builtinEquiv -primEquivFun = getBuiltin builtinEquivFun -primEquivProof = getBuiltin builtinEquivProof -primPathToEquiv = getBuiltin builtinPathToEquiv -primGlue = getPrimitiveTerm builtinGlue -prim_glue = getPrimitiveTerm builtin_glue -prim_unglue = getPrimitiveTerm builtin_unglue -primFaceForall = getPrimitiveTerm builtinFaceForall -primIsOne1 = getBuiltin builtinIsOne1 -primIsOne2 = getBuiltin builtinIsOne2 -primIsOneEmpty = getBuiltin builtinIsOneEmpty -primSub = getBuiltin builtinSub -primSubIn = getBuiltin builtinSubIn -primSubOut = getPrimitiveTerm builtinSubOut -primNat = getBuiltin builtinNat -primSuc = getBuiltin builtinSuc -primZero = getBuiltin builtinZero -primNatPlus = getBuiltin builtinNatPlus -primNatMinus = getBuiltin builtinNatMinus -primNatTimes = getBuiltin builtinNatTimes -primNatDivSucAux = getBuiltin builtinNatDivSucAux -primNatModSucAux = getBuiltin builtinNatModSucAux -primNatEquality = getBuiltin builtinNatEquals -primNatLess = getBuiltin builtinNatLess -primWord64 = getBuiltin builtinWord64 -primSizeUniv = getBuiltin builtinSizeUniv -primSize = getBuiltin builtinSize -primSizeLt = getBuiltin builtinSizeLt -primSizeSuc = getBuiltin builtinSizeSuc -primSizeInf = getBuiltin builtinSizeInf -primSizeMax = getBuiltin builtinSizeMax -primInf = getBuiltin builtinInf -primSharp = getBuiltin builtinSharp -primFlat = getBuiltin builtinFlat -primEquality = getBuiltin builtinEquality -primRefl = getBuiltin builtinRefl -primRewrite = getBuiltin builtinRewrite -primLevel = getBuiltin builtinLevel -primLevelZero = getBuiltin builtinLevelZero -primLevelSuc = getBuiltin builtinLevelSuc -primLevelMax = getBuiltin builtinLevelMax -primSetOmega = getBuiltin builtinSetOmega -primFromNat = getBuiltin builtinFromNat -primFromNeg = getBuiltin builtinFromNeg -primFromString = getBuiltin builtinFromString -primQName = getBuiltin builtinQName -primArg = getBuiltin builtinArg -primArgArg = getBuiltin builtinArgArg -primAbs = getBuiltin builtinAbs -primAbsAbs = getBuiltin builtinAbsAbs -primAgdaSort = getBuiltin builtinAgdaSort -primHiding = getBuiltin builtinHiding -primHidden = getBuiltin builtinHidden -primInstance = getBuiltin builtinInstance -primVisible = getBuiltin builtinVisible -primRelevance = getBuiltin builtinRelevance -primRelevant = getBuiltin builtinRelevant -primIrrelevant = getBuiltin builtinIrrelevant -primAssoc = getBuiltin builtinAssoc -primAssocLeft = getBuiltin builtinAssocLeft -primAssocRight = getBuiltin builtinAssocRight -primAssocNon = getBuiltin builtinAssocNon -primPrecedence = getBuiltin builtinPrecedence -primPrecRelated = getBuiltin builtinPrecRelated -primPrecUnrelated = getBuiltin builtinPrecUnrelated -primFixity = getBuiltin builtinFixity -primFixityFixity = getBuiltin builtinFixityFixity -primArgInfo = getBuiltin builtinArgInfo -primArgArgInfo = getBuiltin builtinArgArgInfo -primAgdaSortSet = getBuiltin builtinAgdaSortSet -primAgdaSortLit = getBuiltin builtinAgdaSortLit -primAgdaSortUnsupported = getBuiltin builtinAgdaSortUnsupported -primAgdaTerm = getBuiltin builtinAgdaTerm -primAgdaTermVar = getBuiltin builtinAgdaTermVar -primAgdaTermLam = getBuiltin builtinAgdaTermLam -primAgdaTermExtLam = getBuiltin builtinAgdaTermExtLam -primAgdaTermDef = getBuiltin builtinAgdaTermDef -primAgdaTermCon = getBuiltin builtinAgdaTermCon -primAgdaTermPi = getBuiltin builtinAgdaTermPi -primAgdaTermSort = getBuiltin builtinAgdaTermSort -primAgdaTermLit = getBuiltin builtinAgdaTermLit -primAgdaTermUnsupported = getBuiltin builtinAgdaTermUnsupported -primAgdaTermMeta = getBuiltin builtinAgdaTermMeta -primAgdaErrorPart = getBuiltin builtinAgdaErrorPart -primAgdaErrorPartString = getBuiltin builtinAgdaErrorPartString -primAgdaErrorPartTerm = getBuiltin builtinAgdaErrorPartTerm -primAgdaErrorPartName = getBuiltin builtinAgdaErrorPartName -primAgdaLiteral = getBuiltin builtinAgdaLiteral -primAgdaLitNat = getBuiltin builtinAgdaLitNat -primAgdaLitWord64 = getBuiltin builtinAgdaLitWord64 -primAgdaLitFloat = getBuiltin builtinAgdaLitFloat -primAgdaLitChar = getBuiltin builtinAgdaLitChar -primAgdaLitString = getBuiltin builtinAgdaLitString -primAgdaLitQName = getBuiltin builtinAgdaLitQName -primAgdaLitMeta = getBuiltin builtinAgdaLitMeta -primAgdaPattern = getBuiltin builtinAgdaPattern -primAgdaPatCon = getBuiltin builtinAgdaPatCon -primAgdaPatVar = getBuiltin builtinAgdaPatVar -primAgdaPatDot = getBuiltin builtinAgdaPatDot -primAgdaPatLit = getBuiltin builtinAgdaPatLit -primAgdaPatProj = getBuiltin builtinAgdaPatProj -primAgdaPatAbsurd = getBuiltin builtinAgdaPatAbsurd -primAgdaClause = getBuiltin builtinAgdaClause -primAgdaClauseClause = getBuiltin builtinAgdaClauseClause -primAgdaClauseAbsurd = getBuiltin builtinAgdaClauseAbsurd -primAgdaDefinitionFunDef = getBuiltin builtinAgdaDefinitionFunDef -primAgdaDefinitionDataDef = getBuiltin builtinAgdaDefinitionDataDef -primAgdaDefinitionRecordDef = getBuiltin builtinAgdaDefinitionRecordDef -primAgdaDefinitionDataConstructor = getBuiltin builtinAgdaDefinitionDataConstructor -primAgdaDefinitionPostulate = getBuiltin builtinAgdaDefinitionPostulate -primAgdaDefinitionPrimitive = getBuiltin builtinAgdaDefinitionPrimitive -primAgdaDefinition = getBuiltin builtinAgdaDefinition -primAgdaMeta = getBuiltin builtinAgdaMeta -primAgdaTCM = getBuiltin builtinAgdaTCM -primAgdaTCMReturn = getBuiltin builtinAgdaTCMReturn -primAgdaTCMBind = getBuiltin builtinAgdaTCMBind -primAgdaTCMUnify = getBuiltin builtinAgdaTCMUnify -primAgdaTCMTypeError = getBuiltin builtinAgdaTCMTypeError -primAgdaTCMInferType = getBuiltin builtinAgdaTCMInferType -primAgdaTCMCheckType = getBuiltin builtinAgdaTCMCheckType -primAgdaTCMNormalise = getBuiltin builtinAgdaTCMNormalise -primAgdaTCMReduce = getBuiltin builtinAgdaTCMReduce -primAgdaTCMCatchError = getBuiltin builtinAgdaTCMCatchError -primAgdaTCMGetContext = getBuiltin builtinAgdaTCMGetContext -primAgdaTCMExtendContext = getBuiltin builtinAgdaTCMExtendContext -primAgdaTCMInContext = getBuiltin builtinAgdaTCMInContext -primAgdaTCMFreshName = getBuiltin builtinAgdaTCMFreshName -primAgdaTCMDeclareDef = getBuiltin builtinAgdaTCMDeclareDef -primAgdaTCMDeclarePostulate = getBuiltin builtinAgdaTCMDeclarePostulate -primAgdaTCMDefineFun = getBuiltin builtinAgdaTCMDefineFun -primAgdaTCMGetType = getBuiltin builtinAgdaTCMGetType -primAgdaTCMGetDefinition = getBuiltin builtinAgdaTCMGetDefinition -primAgdaTCMQuoteTerm = getBuiltin builtinAgdaTCMQuoteTerm -primAgdaTCMUnquoteTerm = getBuiltin builtinAgdaTCMUnquoteTerm -primAgdaTCMBlockOnMeta = getBuiltin builtinAgdaTCMBlockOnMeta -primAgdaTCMCommit = getBuiltin builtinAgdaTCMCommit -primAgdaTCMIsMacro = getBuiltin builtinAgdaTCMIsMacro -primAgdaTCMWithNormalisation = getBuiltin builtinAgdaTCMWithNormalisation -primAgdaTCMDebugPrint = getBuiltin builtinAgdaTCMDebugPrint -primAgdaTCMNoConstraints = getBuiltin builtinAgdaTCMNoConstraints -primAgdaTCMRunSpeculative = getBuiltin builtinAgdaTCMRunSpeculative +primInteger = getBuiltin builtinInteger +primIntegerPos = getBuiltin builtinIntegerPos +primIntegerNegSuc = getBuiltin builtinIntegerNegSuc +primFloat = getBuiltin builtinFloat +primChar = getBuiltin builtinChar +primString = getBuiltin builtinString +primBool = getBuiltin builtinBool +primSigma = getBuiltin builtinSigma +primUnit = getBuiltin builtinUnit +primUnitUnit = getBuiltin builtinUnitUnit +primTrue = getBuiltin builtinTrue +primFalse = getBuiltin builtinFalse +primList = getBuiltin builtinList +primNil = getBuiltin builtinNil +primCons = getBuiltin builtinCons +primIO = getBuiltin builtinIO +primId = getBuiltin builtinId +primConId = getBuiltin builtinConId +primIdElim = getPrimitiveTerm builtinIdElim +primPath = getBuiltin builtinPath +primPathP = getBuiltin builtinPathP +primInterval = getBuiltin builtinInterval +primIZero = getBuiltin builtinIZero +primIOne = getBuiltin builtinIOne +primIMin = getPrimitiveTerm builtinIMin +primIMax = getPrimitiveTerm builtinIMax +primINeg = getPrimitiveTerm builtinINeg +primPartial = getPrimitiveTerm "primPartial" +primPartialP = getPrimitiveTerm "primPartialP" +primIsOne = getBuiltin builtinIsOne +primItIsOne = getBuiltin builtinItIsOne +primTrans = getPrimitiveTerm builtinTrans +primHComp = getPrimitiveTerm builtinHComp +primEquiv = getBuiltin builtinEquiv +primEquivFun = getBuiltin builtinEquivFun +primEquivProof = getBuiltin builtinEquivProof +primTranspProof = getBuiltin builtinTranspProof +prim_glueU = getPrimitiveTerm builtin_glueU +prim_unglueU = getPrimitiveTerm builtin_unglueU +primGlue = getPrimitiveTerm builtinGlue +prim_glue = getPrimitiveTerm builtin_glue +prim_unglue = getPrimitiveTerm builtin_unglue +primFaceForall = getPrimitiveTerm builtinFaceForall +primIsOne1 = getBuiltin builtinIsOne1 +primIsOne2 = getBuiltin builtinIsOne2 +primIsOneEmpty = getBuiltin builtinIsOneEmpty +primSub = getBuiltin builtinSub +primSubIn = getBuiltin builtinSubIn +primSubOut = getPrimitiveTerm builtinSubOut +primNat = getBuiltin builtinNat +primSuc = getBuiltin builtinSuc +primZero = getBuiltin builtinZero +primNatPlus = getBuiltin builtinNatPlus +primNatMinus = getBuiltin builtinNatMinus +primNatTimes = getBuiltin builtinNatTimes +primNatDivSucAux = getBuiltin builtinNatDivSucAux +primNatModSucAux = getBuiltin builtinNatModSucAux +primNatEquality = getBuiltin builtinNatEquals +primNatLess = getBuiltin builtinNatLess +primWord64 = getBuiltin builtinWord64 +primSizeUniv = getBuiltin builtinSizeUniv +primSize = getBuiltin builtinSize +primSizeLt = getBuiltin builtinSizeLt +primSizeSuc = getBuiltin builtinSizeSuc +primSizeInf = getBuiltin builtinSizeInf +primSizeMax = getBuiltin builtinSizeMax +primInf = getBuiltin builtinInf +primSharp = getBuiltin builtinSharp +primFlat = getBuiltin builtinFlat +primEquality = getBuiltin builtinEquality +primRefl = getBuiltin builtinRefl +primRewrite = getBuiltin builtinRewrite +primLevel = getBuiltin builtinLevel +primLevelZero = getBuiltin builtinLevelZero +primLevelSuc = getBuiltin builtinLevelSuc +primLevelMax = getBuiltin builtinLevelMax +primSetOmega = getBuiltin builtinSetOmega +primFromNat = getBuiltin builtinFromNat +primFromNeg = getBuiltin builtinFromNeg +primFromString = getBuiltin builtinFromString +primQName = getBuiltin builtinQName +primArg = getBuiltin builtinArg +primArgArg = getBuiltin builtinArgArg +primAbs = getBuiltin builtinAbs +primAbsAbs = getBuiltin builtinAbsAbs +primAgdaSort = getBuiltin builtinAgdaSort +primHiding = getBuiltin builtinHiding +primHidden = getBuiltin builtinHidden +primInstance = getBuiltin builtinInstance +primVisible = getBuiltin builtinVisible +primRelevance = getBuiltin builtinRelevance +primRelevant = getBuiltin builtinRelevant +primIrrelevant = getBuiltin builtinIrrelevant +primAssoc = getBuiltin builtinAssoc +primAssocLeft = getBuiltin builtinAssocLeft +primAssocRight = getBuiltin builtinAssocRight +primAssocNon = getBuiltin builtinAssocNon +primPrecedence = getBuiltin builtinPrecedence +primPrecRelated = getBuiltin builtinPrecRelated +primPrecUnrelated = getBuiltin builtinPrecUnrelated +primFixity = getBuiltin builtinFixity +primFixityFixity = getBuiltin builtinFixityFixity +primArgInfo = getBuiltin builtinArgInfo +primArgArgInfo = getBuiltin builtinArgArgInfo +primAgdaSortSet = getBuiltin builtinAgdaSortSet +primAgdaSortLit = getBuiltin builtinAgdaSortLit +primAgdaSortUnsupported = getBuiltin builtinAgdaSortUnsupported +primAgdaTerm = getBuiltin builtinAgdaTerm +primAgdaTermVar = getBuiltin builtinAgdaTermVar +primAgdaTermLam = getBuiltin builtinAgdaTermLam +primAgdaTermExtLam = getBuiltin builtinAgdaTermExtLam +primAgdaTermDef = getBuiltin builtinAgdaTermDef +primAgdaTermCon = getBuiltin builtinAgdaTermCon +primAgdaTermPi = getBuiltin builtinAgdaTermPi +primAgdaTermSort = getBuiltin builtinAgdaTermSort +primAgdaTermLit = getBuiltin builtinAgdaTermLit +primAgdaTermUnsupported = getBuiltin builtinAgdaTermUnsupported +primAgdaTermMeta = getBuiltin builtinAgdaTermMeta +primAgdaErrorPart = getBuiltin builtinAgdaErrorPart +primAgdaErrorPartString = getBuiltin builtinAgdaErrorPartString +primAgdaErrorPartTerm = getBuiltin builtinAgdaErrorPartTerm +primAgdaErrorPartName = getBuiltin builtinAgdaErrorPartName +primAgdaLiteral = getBuiltin builtinAgdaLiteral +primAgdaLitNat = getBuiltin builtinAgdaLitNat +primAgdaLitWord64 = getBuiltin builtinAgdaLitWord64 +primAgdaLitFloat = getBuiltin builtinAgdaLitFloat +primAgdaLitChar = getBuiltin builtinAgdaLitChar +primAgdaLitString = getBuiltin builtinAgdaLitString +primAgdaLitQName = getBuiltin builtinAgdaLitQName +primAgdaLitMeta = getBuiltin builtinAgdaLitMeta +primAgdaPattern = getBuiltin builtinAgdaPattern +primAgdaPatCon = getBuiltin builtinAgdaPatCon +primAgdaPatVar = getBuiltin builtinAgdaPatVar +primAgdaPatDot = getBuiltin builtinAgdaPatDot +primAgdaPatLit = getBuiltin builtinAgdaPatLit +primAgdaPatProj = getBuiltin builtinAgdaPatProj +primAgdaPatAbsurd = getBuiltin builtinAgdaPatAbsurd +primAgdaClause = getBuiltin builtinAgdaClause +primAgdaClauseClause = getBuiltin builtinAgdaClauseClause +primAgdaClauseAbsurd = getBuiltin builtinAgdaClauseAbsurd +primAgdaDefinitionFunDef = getBuiltin builtinAgdaDefinitionFunDef +primAgdaDefinitionDataDef = getBuiltin builtinAgdaDefinitionDataDef +primAgdaDefinitionRecordDef = getBuiltin builtinAgdaDefinitionRecordDef +primAgdaDefinitionDataConstructor = getBuiltin builtinAgdaDefinitionDataConstructor +primAgdaDefinitionPostulate = getBuiltin builtinAgdaDefinitionPostulate +primAgdaDefinitionPrimitive = getBuiltin builtinAgdaDefinitionPrimitive +primAgdaDefinition = getBuiltin builtinAgdaDefinition +primAgdaMeta = getBuiltin builtinAgdaMeta +primAgdaTCM = getBuiltin builtinAgdaTCM +primAgdaTCMReturn = getBuiltin builtinAgdaTCMReturn +primAgdaTCMBind = getBuiltin builtinAgdaTCMBind +primAgdaTCMUnify = getBuiltin builtinAgdaTCMUnify +primAgdaTCMTypeError = getBuiltin builtinAgdaTCMTypeError +primAgdaTCMInferType = getBuiltin builtinAgdaTCMInferType +primAgdaTCMCheckType = getBuiltin builtinAgdaTCMCheckType +primAgdaTCMNormalise = getBuiltin builtinAgdaTCMNormalise +primAgdaTCMReduce = getBuiltin builtinAgdaTCMReduce +primAgdaTCMCatchError = getBuiltin builtinAgdaTCMCatchError +primAgdaTCMGetContext = getBuiltin builtinAgdaTCMGetContext +primAgdaTCMExtendContext = getBuiltin builtinAgdaTCMExtendContext +primAgdaTCMInContext = getBuiltin builtinAgdaTCMInContext +primAgdaTCMFreshName = getBuiltin builtinAgdaTCMFreshName +primAgdaTCMDeclareDef = getBuiltin builtinAgdaTCMDeclareDef +primAgdaTCMDeclarePostulate = getBuiltin builtinAgdaTCMDeclarePostulate +primAgdaTCMDefineFun = getBuiltin builtinAgdaTCMDefineFun +primAgdaTCMGetType = getBuiltin builtinAgdaTCMGetType +primAgdaTCMGetDefinition = getBuiltin builtinAgdaTCMGetDefinition +primAgdaTCMQuoteTerm = getBuiltin builtinAgdaTCMQuoteTerm +primAgdaTCMUnquoteTerm = getBuiltin builtinAgdaTCMUnquoteTerm +primAgdaTCMBlockOnMeta = getBuiltin builtinAgdaTCMBlockOnMeta +primAgdaTCMCommit = getBuiltin builtinAgdaTCMCommit +primAgdaTCMIsMacro = getBuiltin builtinAgdaTCMIsMacro +primAgdaTCMWithNormalisation = getBuiltin builtinAgdaTCMWithNormalisation +primAgdaTCMDebugPrint = getBuiltin builtinAgdaTCMDebugPrint +primAgdaTCMNoConstraints = getBuiltin builtinAgdaTCMNoConstraints +primAgdaTCMRunSpeculative = getBuiltin builtinAgdaTCMRunSpeculative -- | The coinductive primitives. @@ -583,6 +600,7 @@ , builtinHComp , builtinTrans , builtin_glue + , builtin_glueU ] getNameOfConstrained :: HasBuiltins m => String -> m (Maybe QName) diff --git a/src/full/Agda/TypeChecking/Monad/Builtin.hs-boot b/src/full/Agda/TypeChecking/Monad/Builtin.hs-boot new file mode 100644 --- /dev/null +++ b/src/full/Agda/TypeChecking/Monad/Builtin.hs-boot @@ -0,0 +1,21 @@ + +module Agda.TypeChecking.Monad.Builtin where + +import Control.Monad.Reader +import Control.Monad.State + +import qualified Control.Monad.Fail as Fail +import Control.Monad.IO.Class (MonadIO) + +import Agda.TypeChecking.Monad.Base (TCMT, Builtin, PrimFun) + +class ( Functor m + , Applicative m + , Fail.MonadFail m + ) => HasBuiltins m where + getBuiltinThing :: String -> m (Maybe (Builtin PrimFun)) + +instance HasBuiltins m => HasBuiltins (ReaderT e m) +instance HasBuiltins m => HasBuiltins (StateT s m) + +instance MonadIO m => HasBuiltins (TCMT m) diff --git a/src/full/Agda/TypeChecking/Monad/Caching.hs b/src/full/Agda/TypeChecking/Monad/Caching.hs --- a/src/full/Agda/TypeChecking/Monad/Caching.hs +++ b/src/full/Agda/TypeChecking/Monad/Caching.hs @@ -1,5 +1,4 @@ {-# LANGUAGE BangPatterns #-} -{-# LANGUAGE CPP #-} module Agda.TypeChecking.Monad.Caching ( -- * Log reading/writing operations @@ -12,13 +11,13 @@ , activateLoadedFileCache , cachingStarts , areWeCaching - , withoutCache + , localCache, withoutCache -- * Restoring the 'PostScopeState' , restorePostScopeState ) where -import Control.Monad.State + import qualified Data.Map as Map import Agda.Syntax.Common @@ -27,33 +26,35 @@ import Agda.TypeChecking.Monad.Base import Agda.TypeChecking.Monad.Debug -import {-# SOURCE #-} Agda.TypeChecking.Monad.Options import Agda.Utils.Lens import Agda.Utils.Monad +import Agda.Utils.Null (empty) -#include "undefined.h" import Agda.Utils.Impossible -- | To be called before any write or restore calls. -cachingStarts :: TCM () +{-# SPECIALIZE cachingStarts :: TCM () #-} +cachingStarts :: (MonadTCState m, ReadTCState m) => m () cachingStarts = do NameId _ m <- useTC stFreshNameId stFreshNameId `setTCLens` NameId 1 m stAreWeCaching `setTCLens` True -areWeCaching :: TCM Bool -areWeCaching = useTC stAreWeCaching +areWeCaching :: (ReadTCState m) => m Bool +areWeCaching = useR stAreWeCaching -- | Writes a 'TypeCheckAction' to the current log, using the current -- 'PostScopeState' -writeToCurrentLog :: TypeCheckAction -> TCM () +{-# SPECIALIZE writeToCurrentLog :: TypeCheckAction -> TCM () #-} +writeToCurrentLog :: (MonadDebug m, MonadTCState m, ReadTCState m) => TypeCheckAction -> m () writeToCurrentLog !d = do reportSLn "cache" 10 $ "cachePostScopeState" !l <- getsTC stPostScopeState modifyCache $ fmap $ \lfc -> lfc{ lfcCurrent = (d, l) : lfcCurrent lfc} -restorePostScopeState :: PostScopeState -> TCM () +{-# SPECIALIZE restorePostScopeState :: PostScopeState -> TCM () #-} +restorePostScopeState :: (MonadDebug m, MonadTCState m) => PostScopeState -> m () restorePostScopeState pss = do reportSLn "cache" 10 $ "restorePostScopeState" modifyTC $ \s -> @@ -71,36 +72,40 @@ mergeWarnings loading current = [ w | w <- current, not $ tcWarningCached w ] ++ [ w | w <- loading, tcWarningCached w ] +{-# SPECIALIZE modifyCache :: (Maybe LoadedFileCache -> Maybe LoadedFileCache) -> TCM () #-} modifyCache - :: (Maybe LoadedFileCache -> Maybe LoadedFileCache) - -> TCM () -modifyCache f = do - modifyTC $ \s -> let !p = stPersistentState s in s - { stPersistentState = - p { stLoadedFileCache = f (stLoadedFileCache p)} - } + :: MonadTCState m + => (Maybe LoadedFileCache -> Maybe LoadedFileCache) + -> m () +modifyCache = modifyTCLens stLoadedFileCache -getCache :: TCM (Maybe LoadedFileCache) -getCache = do - getsTC (stLoadedFileCache . stPersistentState) +{-# SPECIALIZE getCache :: TCM (Maybe LoadedFileCache) #-} +getCache :: ReadTCState m => m (Maybe LoadedFileCache) +getCache = useTC stLoadedFileCache -putCache :: Maybe LoadedFileCache -> TCM () -putCache cs = modifyCache $ const cs +{-# SPECIALIZE putCache :: Maybe LoadedFileCache -> TCM () #-} +putCache :: MonadTCState m => Maybe LoadedFileCache -> m () +putCache = setTCLens stLoadedFileCache +-- | Runs the action and restores the current cache at the end of it. +{-# SPECIALIZE localCache :: TCM a -> TCM a #-} +localCache :: (MonadTCState m, ReadTCState m) => m a -> m a +localCache = bracket_ getCache putCache + -- | Runs the action without cache and restores the current cache at -- the end of it. -withoutCache :: TCM a -> TCM a -withoutCache m = - bracket_ getCache putCache $ do - modifyCache (const Nothing) +{-# SPECIALIZE withoutCache :: TCM a -> TCM a #-} +withoutCache :: (MonadTCState m, ReadTCState m) => m a -> m a +withoutCache m = localCache $ do + putCache empty m -- | Reads the next entry in the cached type check log, if present. -readFromCachedLog :: TCM (Maybe (TypeCheckAction, PostScopeState)) +{-# SPECIALIZE readFromCachedLog :: TCM (Maybe (TypeCheckAction, PostScopeState)) #-} +readFromCachedLog :: (MonadDebug m, MonadTCState m, ReadTCState m) => m (Maybe (TypeCheckAction, PostScopeState)) readFromCachedLog = do reportSLn "cache" 10 $ "getCachedTypeCheckAction" - mbCache <- getCache - case mbCache of + getCache >>= \case Just lfc | (entry : entries) <- lfcCached lfc -> do putCache $ Just lfc{lfcCached = entries} return (Just entry) @@ -108,7 +113,8 @@ return Nothing -- | Empties the "to read" CachedState. To be used when it gets invalid. -cleanCachedLog :: TCM () +{-# SPECIALIZE cleanCachedLog :: TCM () #-} +cleanCachedLog :: (MonadDebug m, MonadTCState m) => m () cleanCachedLog = do reportSLn "cache" 10 $ "cleanCachedLog" modifyCache $ fmap $ \lfc -> lfc{lfcCached = []} @@ -117,7 +123,8 @@ -- current log. Crashes is 'stLoadedFileCache' is already active with a -- dirty log. Should be called when we start typechecking the current -- file. -activateLoadedFileCache :: TCM () +{-# SPECIALIZE activateLoadedFileCache :: TCM () #-} +activateLoadedFileCache :: (HasOptions m, MonadDebug m, MonadTCState m) => m () activateLoadedFileCache = do reportSLn "cache" 10 $ "activateLoadedFileCache" @@ -130,7 +137,8 @@ -- | Caches the current type check log. Discardes the old cache. Does -- nothing if caching is inactive. -cacheCurrentLog :: TCM () +{-# SPECIALIZE cacheCurrentLog :: TCM () #-} +cacheCurrentLog :: (MonadDebug m, MonadTCState m) => m () cacheCurrentLog = do reportSLn "cache" 10 $ "cacheCurrentTypeCheckLog" modifyCache $ fmap $ \lfc -> diff --git a/src/full/Agda/TypeChecking/Monad/Closure.hs b/src/full/Agda/TypeChecking/Monad/Closure.hs --- a/src/full/Agda/TypeChecking/Monad/Closure.hs +++ b/src/full/Agda/TypeChecking/Monad/Closure.hs @@ -5,19 +5,20 @@ import Agda.TypeChecking.Monad.Base import Agda.TypeChecking.Monad.Env import Agda.TypeChecking.Monad.State -import Agda.TypeChecking.Monad.Context + import Agda.Utils.Lens -enterClosure :: Closure a -> (a -> TCM b) -> TCM b -enterClosure (Closure sig env scope cps x) k = do +enterClosure :: (MonadTCEnv m, ReadTCState m, LensClosure a c) + => c -> (a -> m b) -> m b +enterClosure c k | Closure _sig env scope cps x <- c ^. lensClosure = do isDbg <- viewTC eIsDebugPrinting withScope_ scope $ locallyTCState stModuleCheckpoints (const cps) $ withEnv env{ envIsDebugPrinting = isDbg } $ k x -withClosure :: Closure a -> (a -> TCM b) -> TCM (Closure b) +withClosure :: (MonadTCEnv m, ReadTCState m) => Closure a -> (a -> m b) -> m (Closure b) withClosure cl k = enterClosure cl $ k >=> buildClosure -mapClosure :: (a -> TCM b) -> Closure a -> TCM (Closure b) -mapClosure k cl = enterClosure cl $ k >=> buildClosure +mapClosure :: (MonadTCEnv m, ReadTCState m) => (a -> m b) -> Closure a -> m (Closure b) +mapClosure = flip withClosure diff --git a/src/full/Agda/TypeChecking/Monad/Constraints.hs b/src/full/Agda/TypeChecking/Monad/Constraints.hs --- a/src/full/Agda/TypeChecking/Monad/Constraints.hs +++ b/src/full/Agda/TypeChecking/Monad/Constraints.hs @@ -1,11 +1,10 @@ -{-# LANGUAGE CPP #-} module Agda.TypeChecking.Monad.Constraints where import Control.Arrow ((&&&)) -import Control.Monad.State -import Control.Monad.Reader + + import qualified Data.Foldable as Fold import qualified Data.List as List import Data.Set (Set) @@ -14,33 +13,16 @@ import Agda.TypeChecking.Monad.Base import Agda.TypeChecking.Monad.Closure import Agda.TypeChecking.Monad.Debug -import Agda.TypeChecking.Monad.Options import Agda.Utils.Lens -import Agda.Utils.List import Agda.Utils.Monad import Agda.Utils.Except -#include "undefined.h" -import Agda.Utils.Impossible --- | Add all constraints belonging to the given problem to the current problem(s). -stealConstraints :: ProblemId -> TCM () -stealConstraints pid = do - current <- asksTC envActiveProblems - reportSLn "tc.constr.steal" 50 $ "problem " ++ show (Set.toList current) ++ " is stealing problem " ++ show pid ++ "'s constraints!" - -- Add current to any constraint in pid. - let rename pc@(PConstr pids c) | Set.member pid pids = PConstr (Set.union current pids) c - | otherwise = pc - -- We should never steal from an active problem. - whenM (Set.member pid <$> asksTC envActiveProblems) __IMPOSSIBLE__ - modifyAwakeConstraints $ List.map rename - modifySleepingConstraints $ List.map rename - -solvingProblem :: ProblemId -> TCM a -> TCM a +solvingProblem :: MonadConstraint m => ProblemId -> m a -> m a solvingProblem pid = solvingProblems (Set.singleton pid) -solvingProblems :: Set ProblemId -> TCM a -> TCM a +solvingProblems :: MonadConstraint m => Set ProblemId -> m a -> m a solvingProblems pids m = verboseBracket "tc.constr.solve" 50 ("working on problems " ++ show (Set.toList pids)) $ do x <- localTC (\e -> e { envActiveProblems = pids `Set.union` envActiveProblems e }) m Fold.forM_ pids $ \ pid -> do @@ -54,43 +36,43 @@ blockedOn pid (Guarded _ pid') = pid == pid' blockedOn _ _ = False -isProblemSolved :: ProblemId -> TCM Bool +isProblemSolved :: (MonadTCEnv m, ReadTCState m) => ProblemId -> m Bool isProblemSolved pid = and2M (not . Set.member pid <$> asksTC envActiveProblems) (all (not . Set.member pid . constraintProblems) <$> getAllConstraints) -getConstraintsForProblem :: ProblemId -> TCM Constraints +getConstraintsForProblem :: ReadTCState m => ProblemId -> m Constraints getConstraintsForProblem pid = List.filter (Set.member pid . constraintProblems) <$> getAllConstraints -- | Get the awake constraints -getAwakeConstraints :: TCM Constraints -getAwakeConstraints = useTC stAwakeConstraints - -wakeConstraints :: (ProblemConstraint-> TCM Bool) -> TCM () -wakeConstraints wake = do - c <- useTC stSleepingConstraints - (wakeup, sleepin) <- partitionM wake c - reportSLn "tc.constr.wake" 50 $ - "waking up " ++ show (List.map (Set.toList . constraintProblems) wakeup) ++ "\n" ++ - " still sleeping: " ++ show (List.map (Set.toList . constraintProblems) sleepin) - modifySleepingConstraints $ const sleepin - modifyAwakeConstraints (++ wakeup) +getAwakeConstraints :: ReadTCState m => m Constraints +getAwakeConstraints = useR stAwakeConstraints -- danger... -dropConstraints :: (ProblemConstraint -> Bool) -> TCM () +dropConstraints :: MonadConstraint m => (ProblemConstraint -> Bool) -> m () dropConstraints crit = do let filt = List.filter $ not . crit modifySleepingConstraints filt modifyAwakeConstraints filt -putConstraintsToSleep :: (ProblemConstraint -> Bool) -> TCM () +-- | Takes out all constraints matching given filter. +-- Danger! The taken constraints need to be solved or put back at some point. +takeConstraints :: MonadConstraint m => (ProblemConstraint -> Bool) -> m Constraints +takeConstraints f = do + (takeAwake , keepAwake ) <- List.partition f <$> useTC stAwakeConstraints + (takeAsleep, keepAsleep) <- List.partition f <$> useTC stSleepingConstraints + modifyAwakeConstraints $ const keepAwake + modifySleepingConstraints $ const keepAsleep + return $ takeAwake ++ takeAsleep + +putConstraintsToSleep :: MonadConstraint m => (ProblemConstraint -> Bool) -> m () putConstraintsToSleep sleepy = do - awakeOnes <- useTC stAwakeConstraints + awakeOnes <- useR stAwakeConstraints let (gotoSleep, stayAwake) = List.partition sleepy awakeOnes modifySleepingConstraints $ (++ gotoSleep) modifyAwakeConstraints $ const stayAwake -putAllConstraintsToSleep :: TCM () +putAllConstraintsToSleep :: MonadConstraint m => m () putAllConstraintsToSleep = putConstraintsToSleep (const True) data ConstraintStatus = AwakeConstraint | SleepingConstraint @@ -110,10 +92,12 @@ stSleepingConstraints `modifyTCLens` (holdAsleep ++) catchError (m <* restore) (\ err -> restore *> throwError err) -takeAwakeConstraint :: TCM (Maybe ProblemConstraint) +takeAwakeConstraint :: MonadConstraint m => m (Maybe ProblemConstraint) takeAwakeConstraint = takeAwakeConstraint' (const True) -takeAwakeConstraint' :: (ProblemConstraint -> Bool) -> TCM (Maybe ProblemConstraint) +takeAwakeConstraint' + :: MonadConstraint m + => (ProblemConstraint -> Bool) -> m (Maybe ProblemConstraint) takeAwakeConstraint' p = do cs <- getAwakeConstraints case break p cs of @@ -122,10 +106,12 @@ modifyAwakeConstraints $ const (cs0 ++ cs) return $ Just c -getAllConstraints :: TCM Constraints -getAllConstraints = getsTC $ \s -> s^.stAwakeConstraints ++ s^.stSleepingConstraints +getAllConstraints :: ReadTCState m => m Constraints +getAllConstraints = do + s <- getTCState + return $ s^.stAwakeConstraints ++ s^.stSleepingConstraints -withConstraint :: (Constraint -> TCM a) -> ProblemConstraint -> TCM a +withConstraint :: MonadConstraint m => (Constraint -> m a) -> ProblemConstraint -> m a withConstraint f (PConstr pids c) = do -- We should preserve the problem stack and the isSolvingConstraint flag (pids', isSolving) <- asksTC $ envActiveProblems &&& envSolvingConstraints @@ -133,15 +119,51 @@ localTC (\e -> e { envActiveProblems = pids', envSolvingConstraints = isSolving }) $ solvingProblems pids (f c) -buildProblemConstraint :: Set ProblemId -> Constraint -> TCM ProblemConstraint +buildProblemConstraint + :: (MonadTCEnv m, ReadTCState m) + => Set ProblemId -> Constraint -> m ProblemConstraint buildProblemConstraint pids c = PConstr pids <$> buildClosure c -buildProblemConstraint_ :: Constraint -> TCM ProblemConstraint +buildProblemConstraint_ + :: (MonadTCEnv m, ReadTCState m) + => Constraint -> m ProblemConstraint buildProblemConstraint_ = buildProblemConstraint Set.empty buildConstraint :: Constraint -> TCM ProblemConstraint buildConstraint c = flip buildProblemConstraint c =<< asksTC envActiveProblems +-- | Monad service class containing methods for adding and solving +-- constraints +class ( MonadTCEnv m + , ReadTCState m + , MonadError TCErr m + , HasOptions m + , MonadDebug m + ) => MonadConstraint m where + -- | Unconditionally add the constraint. + addConstraint :: Constraint -> m () + + -- | Add constraint as awake constraint. + addAwakeConstraint :: Constraint -> m () + + -- | `catchPatternErr handle m` runs m, handling pattern violations + -- with `handle` (doesn't roll back the state) + catchPatternErr :: m a -> m a -> m a + + solveConstraint :: Constraint -> m () + + -- | Solve awake constraints matching the predicate. If the second argument is + -- True solve constraints even if already 'isSolvingConstraints'. + solveSomeAwakeConstraints :: (ProblemConstraint -> Bool) -> Bool -> m () + + wakeConstraints :: (ProblemConstraint-> m Bool) -> m () + + stealConstraints :: ProblemId -> m () + + modifyAwakeConstraints :: (Constraints -> Constraints) -> m () + + modifySleepingConstraints :: (Constraints -> Constraints) -> m () + -- | Add new a constraint addConstraint' :: Constraint -> TCM () addConstraint' = addConstraintTo stSleepingConstraints @@ -157,34 +179,35 @@ where build | isBlocking c = buildConstraint c | otherwise = buildProblemConstraint_ c - isBlocking SortCmp{} = False - isBlocking LevelCmp{} = False - isBlocking ValueCmp{} = True - isBlocking ValueCmpOnFace{} = True - isBlocking ElimCmp{} = True - isBlocking TypeCmp{} = True - isBlocking TelCmp{} = True - isBlocking (Guarded c _) = isBlocking c - isBlocking UnBlock{} = True - isBlocking FindInstance{} = False - isBlocking IsEmpty{} = True - isBlocking CheckSizeLtSat{} = True - isBlocking CheckFunDef{} = True - isBlocking HasBiggerSort{} = False - isBlocking HasPTSRule{} = False - isBlocking UnquoteTactic{} = True - --- | Add already awake constraints -addAwakeConstraints :: Constraints -> TCM () -addAwakeConstraints cs = modifyAwakeConstraints (cs ++) + isBlocking = \case + SortCmp{} -> False + LevelCmp{} -> False + ValueCmp{} -> True + ValueCmpOnFace{} -> True + ElimCmp{} -> True + TelCmp{} -> True + Guarded c _ -> isBlocking c + UnBlock{} -> True + FindInstance{} -> False + IsEmpty{} -> True + CheckSizeLtSat{} -> True + CheckFunDef{} -> True + HasBiggerSort{} -> False + HasPTSRule{} -> False + UnquoteTactic{} -> True + CheckMetaInst{} -> True -- | Start solving constraints -nowSolvingConstraints :: TCM a -> TCM a +nowSolvingConstraints :: MonadTCEnv m => m a -> m a nowSolvingConstraints = localTC $ \e -> e { envSolvingConstraints = True } -isSolvingConstraints :: TCM Bool +isSolvingConstraints :: MonadTCEnv m => m Bool isSolvingConstraints = asksTC envSolvingConstraints +-- | Add constraint if the action raises a pattern violation +catchConstraint :: MonadConstraint m => Constraint -> m () -> m () +catchConstraint c = catchPatternErr $ addConstraint c + --------------------------------------------------------------------------- -- * Lenses --------------------------------------------------------------------------- @@ -194,9 +217,3 @@ mapSleepingConstraints :: (Constraints -> Constraints) -> TCState -> TCState mapSleepingConstraints = over stSleepingConstraints - -modifyAwakeConstraints :: (Constraints -> Constraints) -> TCM () -modifyAwakeConstraints = modifyTC . mapAwakeConstraints - -modifySleepingConstraints :: (Constraints -> Constraints) -> TCM () -modifySleepingConstraints = modifyTC . mapSleepingConstraints diff --git a/src/full/Agda/TypeChecking/Monad/Context.hs b/src/full/Agda/TypeChecking/Monad/Context.hs --- a/src/full/Agda/TypeChecking/Monad/Context.hs +++ b/src/full/Agda/TypeChecking/Monad/Context.hs @@ -1,81 +1,94 @@ -{-# LANGUAGE CPP #-} module Agda.TypeChecking.Monad.Context where import Control.Monad.Reader import Control.Monad.State +import Control.Monad.Trans.Maybe +import Control.Monad.Writer +import Control.Monad.Fail (MonadFail) import qualified Data.List as List -import Data.Map (Map) import qualified Data.Map as Map -import Data.Monoid import Agda.Syntax.Abstract.Name import Agda.Syntax.Common -import Agda.Syntax.Concrete.Name (LensInScope(..)) +import Agda.Syntax.Concrete.Name (NameInScope(..), LensInScope(..), nameRoot, nameToRawName) import Agda.Syntax.Internal +import Agda.Syntax.Position +import Agda.Syntax.Scope.Base import Agda.Syntax.Scope.Monad (getLocalVars, setLocalVars) +import Agda.TypeChecking.Free import Agda.TypeChecking.Monad.Base import Agda.TypeChecking.Monad.Debug import Agda.TypeChecking.Substitute import Agda.TypeChecking.Monad.Open -import Agda.TypeChecking.Monad.Options +import Agda.TypeChecking.Monad.State -import Agda.Utils.Except ( MonadError(catchError) ) +import Agda.Utils.Empty +import Agda.Utils.Except +import Agda.Utils.Function import Agda.Utils.Functor import Agda.Utils.Lens import Agda.Utils.List ((!!!), downFrom) +import Agda.Utils.ListT import Agda.Utils.Maybe -import Agda.Utils.Monad import Agda.Utils.Pretty import Agda.Utils.Size import Agda.Utils.Impossible -#include "undefined.h" -- * Modifying the context --- | Modify a 'Context' in a computation. -{-# SPECIALIZE modifyContext :: (Context -> Context) -> TCM a -> TCM a #-} -modifyContext :: MonadTCM tcm => (Context -> Context) -> tcm a -> tcm a -modifyContext f = localTC $ \e -> e { envContext = f $ envContext e } +-- | Modify a 'Context' in a computation. Warning: does not update +-- the checkpoints. Use @updateContext@ instead. +{-# SPECIALIZE unsafeModifyContext :: (Context -> Context) -> TCM a -> TCM a #-} +unsafeModifyContext :: MonadTCEnv tcm => (Context -> Context) -> tcm a -> tcm a +unsafeModifyContext f = localTC $ \e -> e { envContext = f $ envContext e } +-- | Modify the 'Dom' part of context entries. +modifyContextInfo :: MonadTCEnv tcm => (forall e. Dom e -> Dom e) -> tcm a -> tcm a +modifyContextInfo f = unsafeModifyContext $ map f + -- | Change to top (=empty) context. Resets the checkpoints. {-# SPECIALIZE inTopContext :: TCM a -> TCM a #-} -safeInTopContext :: MonadTCM tcm => tcm a -> tcm a -safeInTopContext cont = do - locals <- liftTCM $ getLocalVars - liftTCM $ setLocalVars [] - a <- modifyContext (const []) +inTopContext :: (MonadTCEnv tcm, ReadTCState tcm) => tcm a -> tcm a +inTopContext cont = + unsafeModifyContext (const []) $ locallyTC eCurrentCheckpoint (const 0) - $ locallyTC eCheckpoints (const $ Map.singleton 0 IdS) cont - liftTCM $ setLocalVars locals - return a + $ locallyTC eCheckpoints (const $ Map.singleton 0 IdS) + $ locallyTCState stModuleCheckpoints (const Map.empty) + $ locallyScope scopeLocals (const []) + $ locallyTC eLetBindings (const Map.empty) + $ cont -- | Change to top (=empty) context, but don't update the checkpoints. Totally -- not safe! -{-# SPECIALIZE inTopContext :: TCM a -> TCM a #-} -inTopContext :: MonadTCM tcm => tcm a -> tcm a -inTopContext cont = do - locals <- liftTCM $ getLocalVars - liftTCM $ setLocalVars [] - a <- modifyContext (const []) cont - liftTCM $ setLocalVars locals - return a +{-# SPECIALIZE unsafeInTopContext :: TCM a -> TCM a #-} +unsafeInTopContext :: (MonadTCEnv m, ReadTCState m) => m a -> m a +unsafeInTopContext cont = + locallyScope scopeLocals (const []) $ + unsafeModifyContext (const []) cont -- | Delete the last @n@ bindings from the context. -- --- Doesn't update checkpoints! Use `updateContext rho (drop n)` instead, --- for an appropriate substitution `rho`. -{-# SPECIALIZE escapeContext :: Int -> TCM a -> TCM a #-} -escapeContext :: MonadTCM tcm => Int -> tcm a -> tcm a -escapeContext n = modifyContext $ drop n +-- Doesn't update checkpoints! Use `escapeContext` or `updateContext +-- rho (drop n)` instead, for an appropriate substitution `rho`. +{-# SPECIALIZE unsafeEscapeContext :: Int -> TCM a -> TCM a #-} +unsafeEscapeContext :: MonadTCM tcm => Int -> tcm a -> tcm a +unsafeEscapeContext n = unsafeModifyContext $ drop n +-- | Delete the last @n@ bindings from the context. Any occurrences of +-- these variables are replaced with the given @err@. +escapeContext :: MonadAddContext m => Empty -> Int -> m a -> m a +escapeContext err n = updateContext (strengthenS err n) $ drop n + -- * Manipulating checkpoints -- -- | Add a new checkpoint. Do not use directly! -checkpoint :: (MonadDebug tcm, MonadTCM tcm) => Substitution -> tcm a -> tcm a +checkpoint + :: (MonadDebug tcm, MonadTCM tcm, MonadFresh CheckpointId tcm, ReadTCState tcm) + => Substitution -> tcm a -> tcm a checkpoint sub k = do unlessDebugPrinting $ reportSLn "tc.cxt.checkpoint" 105 $ "New checkpoint {" old <- viewTC eCurrentCheckpoint @@ -109,11 +122,6 @@ unlessDebugPrinting $ reportSLn "tc.cxt.checkpoint" 105 "}" return x --- | Update the context. Requires a substitution from the old context to the --- new. -updateContext :: (MonadDebug tcm, MonadTCM tcm) => Substitution -> (Context -> Context) -> tcm a -> tcm a -updateContext sub f = modifyContext f . checkpoint sub - -- | Get the substitution from the context at a given checkpoint to the current context. checkpointSubstitution :: MonadTCEnv tcm => CheckpointId -> tcm Substitution checkpointSubstitution = maybe __IMPOSSIBLE__ return <=< checkpointSubstitution' @@ -125,45 +133,127 @@ -- | Get substitution @Γ ⊢ ρ : Γm@ where @Γ@ is the current context -- and @Γm@ is the module parameter telescope of module @m@. -- --- In case the we don't have a checkpoint for @m@ we return the identity --- substitution. --- This is ok for instance if we are outside module @m@ (in which case we --- have to supply all module parameters to any symbol defined within @m@ we --- want to refer). -getModuleParameterSub :: (MonadTCEnv m, ReadTCState m) => ModuleName -> m Substitution +-- Returns @Nothing@ in case the we don't have a checkpoint for @m@. +getModuleParameterSub :: (MonadTCEnv m, ReadTCState m) => ModuleName -> m (Maybe Substitution) getModuleParameterSub m = do mcp <- (^. stModuleCheckpoints . key m) <$> getTCState - maybe (return IdS) checkpointSubstitution mcp + traverse checkpointSubstitution mcp -- * Adding to the context --- | @addCtx x arg cont@ add a variable to the context. --- --- Chooses an unused 'Name'. --- --- Warning: Does not update module parameter substitution! {-# SPECIALIZE addCtx :: Name -> Dom Type -> TCM a -> TCM a #-} -addCtx :: (MonadDebug tcm, MonadTCM tcm) => Name -> Dom Type -> tcm a -> tcm a -addCtx x a ret = do +class MonadTCEnv m => MonadAddContext m where + -- | @addCtx x arg cont@ add a variable to the context. + -- + -- Chooses an unused 'Name'. + -- + -- Warning: Does not update module parameter substitution! + addCtx :: Name -> Dom Type -> m a -> m a + + -- | Add a let bound variable to the context + addLetBinding' :: Name -> Term -> Dom Type -> m a -> m a + + -- | Update the context. + -- Requires a substitution that transports things living in the old context + -- to the new. + updateContext :: Substitution -> (Context -> Context) -> m a -> m a + + withFreshName :: Range -> ArgName -> (Name -> m a) -> m a + +-- | Default implementation of addCtx in terms of updateContext +defaultAddCtx :: MonadAddContext m => Name -> Dom Type -> m a -> m a +defaultAddCtx x a ret = do q <- viewTC eQuantity let ce = (x,) <$> inverseApplyQuantity q a - when (not $ isNoName x) $ do - registerForShadowing x - ys <- getContextNames - forM_ ys $ \y -> - when (not (isNoName y) && sameRoot x y) $ tellShadowing x y updateContext (raiseS 1) (ce :) ret - -- let-bindings keep track of own their context - where - -- add x to the map of possibly shadowed names - registerForShadowing x = modifyTCLens stShadowingNames $ Map.insert x [] +withFreshName_ :: (MonadAddContext m) => ArgName -> (Name -> m a) -> m a +withFreshName_ = withFreshName noRange - -- register the fact that x possibly shadows the name y - tellShadowing x y = modifyTCLens stShadowingNames $ Map.adjust (x:) y +instance MonadAddContext m => MonadAddContext (MaybeT m) where + addCtx x a = MaybeT . addCtx x a . runMaybeT + addLetBinding' x u a = MaybeT . addLetBinding' x u a . runMaybeT + updateContext sub f = MaybeT . updateContext sub f . runMaybeT + withFreshName r x = MaybeT . withFreshName r x . (runMaybeT .) -addRecordNameContext :: (MonadDebug m, MonadTCM m) => Dom Type -> m b -> m b +instance MonadAddContext m => MonadAddContext (ExceptT e m) where + addCtx x a = mkExceptT . addCtx x a . runExceptT + addLetBinding' x u a = mkExceptT . addLetBinding' x u a . runExceptT + updateContext sub f = mkExceptT . updateContext sub f . runExceptT + withFreshName r x = mkExceptT . withFreshName r x . (runExceptT .) + +instance MonadAddContext m => MonadAddContext (ReaderT r m) where + addCtx x a = ReaderT . (addCtx x a .) . runReaderT + addLetBinding' x u a = ReaderT . (addLetBinding' x u a .) . runReaderT + updateContext sub f = ReaderT . (updateContext sub f .) . runReaderT + withFreshName r x ret = ReaderT $ \env -> withFreshName r x $ \n -> runReaderT (ret n) env + +instance (Monoid w, MonadAddContext m) => MonadAddContext (WriterT w m) where + addCtx x a = WriterT . addCtx x a . runWriterT + addLetBinding' x u a = WriterT . addLetBinding' x u a . runWriterT + updateContext sub f = WriterT . updateContext sub f . runWriterT + withFreshName r x = WriterT . withFreshName r x . (runWriterT .) + +instance MonadAddContext m => MonadAddContext (StateT r m) where + addCtx x a = StateT . (addCtx x a .) . runStateT + addLetBinding' x u a = StateT . (addLetBinding' x u a .) . runStateT + updateContext sub f = StateT . (updateContext sub f .) . runStateT + withFreshName r x ret = StateT $ \s -> withFreshName r x $ \n -> runStateT (ret n) s + +instance MonadAddContext m => MonadAddContext (ListT m) where + addCtx x a = liftListT $ addCtx x a + addLetBinding' x u a = liftListT $ addLetBinding' x u a + updateContext sub f = liftListT $ updateContext sub f + withFreshName r x ret = ListT $ withFreshName r x $ \n -> runListT (ret n) + +-- | Run the given TCM action, and register the given variable as +-- being shadowed by all the names with the same root that are added +-- to the context during this TCM action. +withShadowingNameTCM :: Name -> TCM b -> TCM b +withShadowingNameTCM x f = do + reportSDoc "tc.cxt.shadowing" 80 $ pure $ "registered" <+> pretty x <+> "for shadowing" + when (isInScope x == InScope) $ tellUsedName x + (result , useds) <- listenUsedNames f + reportSDoc "tc.cxt.shadowing" 90 $ pure $ "all used names: " <+> text (show useds) + tellShadowing x useds + return result + + where + listenUsedNames f = do + origUsedNames <- useTC stUsedNames + setTCLens stUsedNames Map.empty + result <- f + newUsedNames <- useTC stUsedNames + setTCLens stUsedNames $ Map.unionWith (++) origUsedNames newUsedNames + return (result , newUsedNames) + + tellUsedName x = do + let concreteX = nameConcrete x + rawX = nameToRawName concreteX + rootX = nameRoot concreteX + modifyTCLens (stUsedNames . key rootX) $ Just . (rawX:) . concat + + tellShadowing x useds = case Map.lookup (nameRoot $ nameConcrete x) useds of + Just shadows -> do + reportSDoc "tc.cxt.shadowing" 80 $ pure $ "names shadowing" <+> pretty x <+> ": " <+> prettyList_ (map pretty shadows) + modifyTCLens stShadowingNames $ Map.insertWith (++) x shadows + Nothing -> return () + +instance MonadAddContext TCM where + addCtx x a ret = applyUnless (isNoName x) (withShadowingNameTCM x) $ + defaultAddCtx x a ret + + addLetBinding' x u a ret = applyUnless (isNoName x) (withShadowingNameTCM x) $ + defaultAddLetBinding' x u a ret + + updateContext sub f = unsafeModifyContext f . checkpoint sub + + withFreshName r x m = freshName r x >>= m + +addRecordNameContext + :: (MonadAddContext m, MonadFresh NameId m) + => Dom Type -> m b -> m b addRecordNameContext dom ret = do x <- setNotInScope <$> freshRecordName addCtx x dom ret @@ -171,7 +261,7 @@ -- | Various specializations of @addCtx@. {-# SPECIALIZE addContext :: b -> TCM a -> TCM a #-} class AddContext b where - addContext :: (MonadTCM tcm, MonadDebug tcm) => b -> tcm a -> tcm a + addContext :: (MonadAddContext m) => b -> m a -> m a contextSize :: b -> Nat -- | Wrapper to tell 'addContext' not to mark names as @@ -218,15 +308,13 @@ contextSize (xs, _) = length xs instance AddContext (String, Dom Type) where - addContext (s, dom) ret = do - x <- setNotInScope <$> freshName_ s - addCtx x dom ret + addContext (s, dom) ret = + withFreshName noRange s $ \x -> addCtx (setNotInScope x) dom ret contextSize _ = 1 instance AddContext (KeepNames String, Dom Type) where - addContext (KeepNames s, dom) ret = do - x <- freshName_ s - addCtx x dom ret + addContext (KeepNames s, dom) ret = + withFreshName noRange s $ \ x -> addCtx x dom ret contextSize _ = 1 instance AddContext (Dom Type) where @@ -255,30 +343,37 @@ -- | Go under an abstraction. Do not extend context in case of 'NoAbs'. {-# SPECIALIZE underAbstraction :: Subst t a => Dom Type -> Abs a -> (a -> TCM b) -> TCM b #-} -underAbstraction :: (Subst t a, MonadTCM tcm, MonadDebug tcm) => Dom Type -> Abs a -> (a -> tcm b) -> tcm b +underAbstraction :: (Subst t a, MonadAddContext m) => Dom Type -> Abs a -> (a -> m b) -> m b underAbstraction = underAbstraction' id -underAbstraction' :: (Subst t a, MonadTCM tcm, MonadDebug tcm, AddContext (name, Dom Type)) => - (String -> name) -> Dom Type -> Abs a -> (a -> tcm b) -> tcm b +underAbstraction' :: (Subst t a, MonadAddContext m, AddContext (name, Dom Type)) => + (String -> name) -> Dom Type -> Abs a -> (a -> m b) -> m b underAbstraction' _ _ (NoAbs _ v) k = k v underAbstraction' wrap t a k = underAbstractionAbs' wrap t a k -- | Go under an abstraction, treating 'NoAbs' as 'Abs'. -underAbstractionAbs :: (Subst t a, MonadTCM tcm, MonadDebug tcm) => Dom Type -> Abs a -> (a -> tcm b) -> tcm b +underAbstractionAbs :: (Subst t a, MonadAddContext m) => Dom Type -> Abs a -> (a -> m b) -> m b underAbstractionAbs = underAbstractionAbs' id underAbstractionAbs' - :: (Subst t a, MonadTCM tcm, MonadDebug tcm, AddContext (name, Dom Type)) - => (String -> name) -> Dom Type -> Abs a -> (a -> tcm b) -> tcm b + :: (Subst t a, MonadAddContext m, AddContext (name, Dom Type)) + => (String -> name) -> Dom Type -> Abs a -> (a -> m b) -> m b underAbstractionAbs' wrap t a k = addContext (wrap $ realName $ absName a, t) $ k $ absBody a where realName s = if isNoName s then "x" else argNameToString s -- | Go under an abstract without worrying about the type to add to the context. {-# SPECIALIZE underAbstraction_ :: Subst t a => Abs a -> (a -> TCM b) -> TCM b #-} -underAbstraction_ :: (Subst t a, MonadTCM tcm, MonadDebug tcm) => Abs a -> (a -> tcm b) -> tcm b +underAbstraction_ :: (Subst t a, MonadAddContext m) => Abs a -> (a -> m b) -> m b underAbstraction_ = underAbstraction __DUMMY_DOM__ +-- | Map a monadic function on the thing under the abstraction, adding +-- the abstracted variable to the context. +mapAbstraction + :: (Subst t a, Subst t' b, Free b, MonadAddContext m) + => Dom Type -> (a -> m b) -> Abs a -> m (Abs b) +mapAbstraction dom f x = (x $>) <$> underAbstraction dom x f + getLetBindings :: MonadTCM tcm => tcm [(Name,(Term,Dom Type))] getLetBindings = do bs <- asksTC envLetBindings @@ -286,14 +381,14 @@ -- | Add a let bound variable {-# SPECIALIZE addLetBinding' :: Name -> Term -> Dom Type -> TCM a -> TCM a #-} -addLetBinding' :: MonadTCM tcm => Name -> Term -> Dom Type -> tcm a -> tcm a -addLetBinding' x v t ret = do - vt <- liftTCM $ makeOpen (v, t) +defaultAddLetBinding' :: MonadTCEnv m => Name -> Term -> Dom Type -> m a -> m a +defaultAddLetBinding' x v t ret = do + vt <- makeOpen (v, t) flip localTC ret $ \e -> e { envLetBindings = Map.insert x vt $ envLetBindings e } -- | Add a let bound variable {-# SPECIALIZE addLetBinding :: ArgInfo -> Name -> Term -> Type -> TCM a -> TCM a #-} -addLetBinding :: MonadTCM tcm => ArgInfo -> Name -> Term -> Type -> tcm a -> tcm a +addLetBinding :: MonadAddContext m => ArgInfo -> Name -> Term -> Type -> m a -> m a addLetBinding info x v t0 ret = addLetBinding' x v (defaultArgDom info t0) ret @@ -332,37 +427,48 @@ -- | get type of bound variable (i.e. deBruijn index) -- +{-# SPECIALIZE lookupBV' :: Nat -> TCM (Maybe (Dom (Name, Type))) #-} +lookupBV' :: MonadTCEnv m => Nat -> m (Maybe (Dom (Name, Type))) +lookupBV' n = do + ctx <- getContext + return $ raise (n + 1) <$> ctx !!! n + {-# SPECIALIZE lookupBV :: Nat -> TCM (Dom (Name, Type)) #-} -lookupBV :: MonadTCEnv m => Nat -> m (Dom (Name, Type)) +lookupBV :: (MonadFail m, MonadTCEnv m) => Nat -> m (Dom (Name, Type)) lookupBV n = do - ctx <- getContext - let failure = fail $ "de Bruijn index out of scope: " ++ show n ++ - " in context " ++ prettyShow (map (fst . unDom) ctx) - maybe failure (return . fmap (raise $ n + 1)) $ ctx !!! n + let failure = do + ctx <- getContext + fail $ "de Bruijn index out of scope: " ++ show n ++ + " in context " ++ prettyShow (map (fst . unDom) ctx) + maybeM failure return $ lookupBV' n -{-# SPECIALIZE typeOfBV' :: Nat -> TCM (Dom Type) #-} -typeOfBV' :: (Applicative m, MonadTCEnv m) => Nat -> m (Dom Type) -typeOfBV' n = fmap snd <$> lookupBV n +{-# SPECIALIZE domOfBV :: Nat -> TCM (Dom Type) #-} +domOfBV :: (Applicative m, MonadFail m, MonadTCEnv m) => Nat -> m (Dom Type) +domOfBV n = fmap snd <$> lookupBV n {-# SPECIALIZE typeOfBV :: Nat -> TCM Type #-} -typeOfBV :: (Applicative m, MonadTCEnv m) => Nat -> m Type -typeOfBV i = unDom <$> typeOfBV' i +typeOfBV :: (Applicative m, MonadFail m, MonadTCEnv m) => Nat -> m Type +typeOfBV i = unDom <$> domOfBV i +{-# SPECIALIZE nameOfBV' :: Nat -> TCM (Maybe Name) #-} +nameOfBV' :: (Applicative m, MonadFail m, MonadTCEnv m) => Nat -> m (Maybe Name) +nameOfBV' n = fmap (fst . unDom) <$> lookupBV' n + {-# SPECIALIZE nameOfBV :: Nat -> TCM Name #-} -nameOfBV :: (Applicative m, MonadTCEnv m) => Nat -> m Name +nameOfBV :: (Applicative m, MonadFail m, MonadTCEnv m) => Nat -> m Name nameOfBV n = fst . unDom <$> lookupBV n -- | Get the term corresponding to a named variable. If it is a lambda bound -- variable the deBruijn index is returned and if it is a let bound variable -- its definition is returned. {-# SPECIALIZE getVarInfo :: Name -> TCM (Term, Dom Type) #-} -getVarInfo :: MonadTCEnv m => Name -> m (Term, Dom Type) +getVarInfo :: (MonadFail m, MonadTCEnv m) => Name -> m (Term, Dom Type) getVarInfo x = do ctx <- getContext def <- asksTC envLetBindings case List.findIndex ((==x) . fst . unDom) ctx of Just n -> do - t <- typeOfBV' n + t <- domOfBV n return (var n, t) _ -> case Map.lookup x def of diff --git a/src/full/Agda/TypeChecking/Monad/Context.hs-boot b/src/full/Agda/TypeChecking/Monad/Context.hs-boot --- a/src/full/Agda/TypeChecking/Monad/Context.hs-boot +++ b/src/full/Agda/TypeChecking/Monad/Context.hs-boot @@ -1,10 +1,23 @@ -{-# LANGUAGE FlexibleContexts #-} module Agda.TypeChecking.Monad.Context where import Control.Monad.Reader +import Control.Monad.State +import Agda.Syntax.Common import Agda.Syntax.Internal +import Agda.Syntax.Position import Agda.TypeChecking.Monad.Base checkpointSubstitution :: MonadTCEnv tcm => CheckpointId -> tcm Substitution + +class MonadTCEnv m => MonadAddContext m where + addCtx :: Name -> Dom Type -> m a -> m a + addLetBinding' :: Name -> Term -> Dom Type -> m a -> m a + updateContext :: Substitution -> (Context -> Context) -> m a -> m a + withFreshName :: Range -> ArgName -> (Name -> m a) -> m a + +instance MonadAddContext m => MonadAddContext (ReaderT r m) where +instance MonadAddContext m => MonadAddContext (StateT r m) where + +instance MonadAddContext TCM diff --git a/src/full/Agda/TypeChecking/Monad/Debug.hs b/src/full/Agda/TypeChecking/Monad/Debug.hs --- a/src/full/Agda/TypeChecking/Monad/Debug.hs +++ b/src/full/Agda/TypeChecking/Monad/Debug.hs @@ -1,23 +1,27 @@ -{-# LANGUAGE CPP #-} -module Agda.TypeChecking.Monad.Debug where +module Agda.TypeChecking.Monad.Debug + ( module Agda.TypeChecking.Monad.Debug + , Verbosity, VerboseKey, VerboseLevel + ) where -import Control.Monad.IO.Class (MonadIO, liftIO) +import GHC.Stack (HasCallStack, freezeCallStack, callStack) + +import qualified Control.Exception as E +import qualified Control.DeepSeq as DeepSeq (force) import Control.Monad.Reader import Control.Monad.State import Control.Monad.Trans.Maybe +import Control.Monad.Trans.Identity import Control.Monad.Writer import Data.Maybe -import Data.Monoid ( Monoid, mempty, mappend ) -import Data.Semigroup ( Semigroup, (<>), Any(..) ) -import Data.Traversable +import Data.Monoid ( Monoid) import {-# SOURCE #-} Agda.TypeChecking.Errors import Agda.TypeChecking.Monad.Base -import {-# SOURCE #-} Agda.TypeChecking.Monad.Options -import Agda.Interaction.Response +import Agda.Interaction.Options +import {-# SOURCE #-} Agda.Interaction.Response (Response(..)) import Agda.Utils.Except import Agda.Utils.Lens @@ -26,96 +30,293 @@ import Agda.Utils.Maybe import Agda.Utils.Monad import Agda.Utils.Pretty +import Agda.Utils.Update +import qualified Agda.Utils.Trie as Trie -#include "undefined.h" import Agda.Utils.Impossible class (Functor m, Applicative m, Monad m) => MonadDebug m where - displayDebugMessage :: Int -> String -> m () - displayDebugMessage n s = traceDebugMessage n s $ return () + displayDebugMessage :: VerboseKey -> VerboseLevel -> String -> m () + displayDebugMessage k n s = traceDebugMessage k n s $ return () - traceDebugMessage :: Int -> String -> m a -> m a - traceDebugMessage n s cont = displayDebugMessage n s >> cont + traceDebugMessage :: VerboseKey -> VerboseLevel -> String -> m a -> m a + traceDebugMessage k n s cont = displayDebugMessage k n s >> cont - formatDebugMessage :: VerboseKey -> Int -> TCM Doc -> m String + formatDebugMessage :: VerboseKey -> VerboseLevel -> TCM Doc -> m String -instance (MonadIO m) => MonadDebug (TCMT m) where + getVerbosity :: m Verbosity - displayDebugMessage n s = liftTCM $ do + default getVerbosity :: HasOptions m => m Verbosity + getVerbosity = optVerbose <$> pragmaOptions + + isDebugPrinting :: m Bool + + default isDebugPrinting :: MonadTCEnv m => m Bool + isDebugPrinting = asksTC envIsDebugPrinting + + nowDebugPrinting :: m a -> m a + + default nowDebugPrinting :: MonadTCEnv m => m a -> m a + nowDebugPrinting = locallyTC eIsDebugPrinting $ const True + + -- | Print brackets around debug messages issued by a computation. + verboseBracket :: VerboseKey -> VerboseLevel -> String -> m a -> m a + +-- | During printing, catch internal errors of kind 'Impossible' and print them. +catchAndPrintImpossible + :: (CatchImpossible m, Monad m) + => VerboseKey -> VerboseLevel -> m String -> m String +catchAndPrintImpossible k n m = catchImpossibleJust catchMe m $ \ imposs -> do + return $ render $ vcat + [ text $ "Debug printing " ++ k ++ ":" ++ show n ++ " failed due to exception:" + , vcat $ map (nest 2 . text) $ lines $ show imposs + ] + where + -- | Exception filter: Catch only the 'Impossible' exception during debug printing. + catchMe :: Impossible -> Maybe Impossible + catchMe = filterMaybe $ \case + Impossible{} -> True + Unreachable{} -> False + ImpMissingDefinitions{} -> False + +instance MonadDebug TCM where + + displayDebugMessage k n s = do + -- Andreas, 2019-08-20, issue #4016: + -- Force any lazy 'Impossible' exceptions to the surface and handle them. + s <- liftIO . catchAndPrintImpossible k n . E.evaluate . DeepSeq.force $ s cb <- getsTC $ stInteractionOutputCallback . stPersistentState cb (Resp_RunningInfo n s) - formatDebugMessage k n d = liftTCM $ - show <$> d `catchError` \ err -> - (\ s -> (sep $ map text - [ "Printing debug message" - , k ++ ":" ++show n - , "failed due to error:" ]) $$ - (nest 2 $ text s)) <$> prettyError err + formatDebugMessage k n d = catchAndPrintImpossible k n $ do + render <$> d `catchError` \ err -> do + prettyError err <&> \ s -> vcat + [ sep $ map text + [ "Printing debug message" + , k ++ ":" ++ show n + , "failed due to error:" + ] + , nest 2 $ text s + ] + verboseBracket k n s = applyWhenVerboseS k n $ \ m -> do + openVerboseBracket k n s + m `finally` closeVerboseBracket k n + instance MonadDebug m => MonadDebug (ExceptT e m) where - displayDebugMessage n s = lift $ displayDebugMessage n s + displayDebugMessage k n s = lift $ displayDebugMessage k n s formatDebugMessage k n d = lift $ formatDebugMessage k n d + getVerbosity = lift getVerbosity + isDebugPrinting = lift isDebugPrinting + nowDebugPrinting = mapExceptT nowDebugPrinting + verboseBracket k n s = mapExceptT (verboseBracket k n s) instance MonadDebug m => MonadDebug (ListT m) where - displayDebugMessage n s = lift $ displayDebugMessage n s + displayDebugMessage k n s = lift $ displayDebugMessage k n s formatDebugMessage k n d = lift $ formatDebugMessage k n d + getVerbosity = lift getVerbosity + isDebugPrinting = lift isDebugPrinting + nowDebugPrinting = liftListT nowDebugPrinting + verboseBracket k n s = liftListT $ verboseBracket k n s instance MonadDebug m => MonadDebug (MaybeT m) where - displayDebugMessage n s = lift $ displayDebugMessage n s + displayDebugMessage k n s = lift $ displayDebugMessage k n s formatDebugMessage k n d = lift $ formatDebugMessage k n d + getVerbosity = lift getVerbosity + isDebugPrinting = lift isDebugPrinting + nowDebugPrinting = mapMaybeT nowDebugPrinting + verboseBracket k n s = MaybeT . verboseBracket k n s . runMaybeT instance MonadDebug m => MonadDebug (ReaderT r m) where - displayDebugMessage n s = lift $ displayDebugMessage n s + displayDebugMessage k n s = lift $ displayDebugMessage k n s formatDebugMessage k n d = lift $ formatDebugMessage k n d + getVerbosity = lift getVerbosity + isDebugPrinting = lift isDebugPrinting + nowDebugPrinting = mapReaderT nowDebugPrinting + verboseBracket k n s = mapReaderT $ verboseBracket k n s instance MonadDebug m => MonadDebug (StateT s m) where - displayDebugMessage n s = lift $ displayDebugMessage n s + displayDebugMessage k n s = lift $ displayDebugMessage k n s formatDebugMessage k n d = lift $ formatDebugMessage k n d + getVerbosity = lift getVerbosity + isDebugPrinting = lift isDebugPrinting + nowDebugPrinting = mapStateT nowDebugPrinting + verboseBracket k n s = mapStateT $ verboseBracket k n s instance (MonadDebug m, Monoid w) => MonadDebug (WriterT w m) where - displayDebugMessage n s = lift $ displayDebugMessage n s + displayDebugMessage k n s = lift $ displayDebugMessage k n s formatDebugMessage k n d = lift $ formatDebugMessage k n d + getVerbosity = lift getVerbosity + isDebugPrinting = lift isDebugPrinting + nowDebugPrinting = mapWriterT nowDebugPrinting + verboseBracket k n s = mapWriterT $ verboseBracket k n s --- | Conditionally print debug string. -{-# SPECIALIZE reportS :: VerboseKey -> Int -> String -> TCM () #-} -reportS :: (HasOptions m, MonadDebug m, MonadTCEnv m) - => VerboseKey -> Int -> String -> m () -reportS k n s = verboseS k n $ displayDebugMessage n s +instance MonadDebug m => MonadDebug (ChangeT m) where + displayDebugMessage k n s = lift $ displayDebugMessage k n s + formatDebugMessage k n d = lift $ formatDebugMessage k n d + getVerbosity = lift $ getVerbosity + isDebugPrinting = lift $ isDebugPrinting + nowDebugPrinting = mapChangeT $ nowDebugPrinting + verboseBracket k n s = mapChangeT $ verboseBracket k n s +instance MonadDebug m => MonadDebug (IdentityT m) where + displayDebugMessage k n s = lift $ displayDebugMessage k n s + formatDebugMessage k n d = lift $ formatDebugMessage k n d + getVerbosity = lift $ getVerbosity + isDebugPrinting = lift $ isDebugPrinting + nowDebugPrinting = mapIdentityT $ nowDebugPrinting + verboseBracket k n s = mapIdentityT $ verboseBracket k n s + +-- | Debug print some lines if the verbosity level for the given +-- 'VerboseKey' is at least 'VerboseLevel'. +-- +-- Note: In the presence of @OverloadedStrings@, just +-- @@ +-- reportS key level "Literate string" +-- @@ +-- gives an @Ambiguous type variable@ error in @GHC@. +-- Use the legacy functions 'reportSLn' and 'reportSDoc' instead then. +-- +class ReportS a where + reportS :: MonadDebug m => VerboseKey -> VerboseLevel -> a -> m () + +instance ReportS (TCM Doc) where reportS = reportSDoc +instance ReportS String where reportS = reportSLn + +instance ReportS [TCM Doc] where reportS k n = reportSDoc k n . fmap vcat . sequence +instance ReportS [String] where reportS k n = reportSLn k n . unlines +instance ReportS [Doc] where reportS k n = reportSLn k n . render . vcat +instance ReportS Doc where reportS k n = reportSLn k n . render + -- | Conditionally println debug string. -{-# SPECIALIZE reportSLn :: VerboseKey -> Int -> String -> TCM () #-} -reportSLn :: (HasOptions m, MonadDebug m, MonadTCEnv m) - => VerboseKey -> Int -> String -> m () -reportSLn k n s = verboseS k n $ - displayDebugMessage n (s ++ "\n") +{-# SPECIALIZE reportSLn :: VerboseKey -> VerboseLevel -> String -> TCM () #-} +reportSLn :: MonadDebug m => VerboseKey -> VerboseLevel -> String -> m () +reportSLn k n s = verboseS k n $ displayDebugMessage k n $ s ++ "\n" +__IMPOSSIBLE_VERBOSE__ :: (HasCallStack, MonadDebug m) => String -> m a +__IMPOSSIBLE_VERBOSE__ s = do { reportSLn "impossible" 10 s ; throwImpossible err } + where + -- Create the "Impossible" error using *our* caller as the call site. + err = withFileAndLine' (freezeCallStack callStack) Impossible + -- | Conditionally render debug 'Doc' and print it. -{-# SPECIALIZE reportSDoc :: VerboseKey -> Int -> TCM Doc -> TCM () #-} -reportSDoc :: (HasOptions m, MonadDebug m, MonadTCEnv m) - => VerboseKey -> Int -> TCM Doc -> m () +{-# SPECIALIZE reportSDoc :: VerboseKey -> VerboseLevel -> TCM Doc -> TCM () #-} +reportSDoc :: MonadDebug m => VerboseKey -> VerboseLevel -> TCM Doc -> m () reportSDoc k n d = verboseS k n $ do - displayDebugMessage n . (++ "\n") =<< formatDebugMessage k n (locallyTC eIsDebugPrinting (const True) d) + displayDebugMessage k n . (++ "\n") =<< formatDebugMessage k n (locallyTC eIsDebugPrinting (const True) d) -unlessDebugPrinting :: MonadTCM m => m () -> m () -unlessDebugPrinting = unlessM (asksTC envIsDebugPrinting) +-- | Debug print the result of a computation. +reportResult :: MonadDebug m => VerboseKey -> VerboseLevel -> (a -> TCM Doc) -> m a -> m a +reportResult k n debug action = do + x <- action + x <$ reportSDoc k n (debug x) -traceSLn :: (HasOptions m, MonadDebug m) - => VerboseKey -> Int -> String -> m a -> m a -traceSLn k n s cont = ifNotM (hasVerbosity k n) cont $ {- else -} do - traceDebugMessage n (s ++ "\n") cont +unlessDebugPrinting :: MonadDebug m => m () -> m () +unlessDebugPrinting = unlessM isDebugPrinting +-- | Debug print some lines if the verbosity level for the given +-- 'VerboseKey' is at least 'VerboseLevel'. +-- +-- Note: In the presence of @OverloadedStrings@, just +-- @@ +-- traceS key level "Literate string" +-- @@ +-- gives an @Ambiguous type variable@ error in @GHC@. +-- Use the legacy functions 'traceSLn' and 'traceSDoc' instead then. +-- +class TraceS a where + traceS :: MonadDebug m => VerboseKey -> VerboseLevel -> a -> m c -> m c + +instance TraceS (TCM Doc) where traceS = traceSDoc +instance TraceS String where traceS = traceSLn + +instance TraceS [TCM Doc] where traceS k n = traceSDoc k n . fmap vcat . sequence +instance TraceS [String] where traceS k n = traceSLn k n . unlines +instance TraceS [Doc] where traceS k n = traceSLn k n . render . vcat +instance TraceS Doc where traceS k n = traceSLn k n . render + +traceSLn :: MonadDebug m => VerboseKey -> VerboseLevel -> String -> m a -> m a +traceSLn k n s = applyWhenVerboseS k n $ traceDebugMessage k n $ s ++ "\n" + -- | Conditionally render debug 'Doc', print it, and then continue. -traceSDoc :: (HasOptions m, MonadDebug m) - => VerboseKey -> Int -> TCM Doc -> m a -> m a -traceSDoc k n d cont = ifNotM (hasVerbosity k n) cont $ {- else -} do +traceSDoc :: MonadDebug m => VerboseKey -> VerboseLevel -> TCM Doc -> m a -> m a +traceSDoc k n d = applyWhenVerboseS k n $ \cont -> do s <- formatDebugMessage k n $ locallyTC eIsDebugPrinting (const True) d - traceDebugMessage n (s ++ "\n") cont + traceDebugMessage k n (s ++ "\n") cont --- | Print brackets around debug messages issued by a computation. -{-# SPECIALIZE verboseBracket :: VerboseKey -> Int -> String -> TCM a -> TCM a #-} -verboseBracket :: (HasOptions m, MonadDebug m, MonadError err m) - => VerboseKey -> Int -> String -> m a -> m a -verboseBracket k n s m = ifNotM (hasVerbosity k n) m $ {- else -} do - displayDebugMessage n $ "{ " ++ s ++ "\n" - m `finally` displayDebugMessage n "}\n" +openVerboseBracket :: MonadDebug m => VerboseKey -> VerboseLevel -> String -> m () +openVerboseBracket k n s = displayDebugMessage k n $ "{ " ++ s ++ "\n" + +closeVerboseBracket :: MonadDebug m => VerboseKey -> VerboseLevel -> m () +closeVerboseBracket k n = displayDebugMessage k n "}\n" + + +------------------------------------------------------------------------ +-- Verbosity + +-- Invariant (which we may or may not currently break): Debug +-- printouts use one of the following functions: +-- +-- reportS +-- reportSLn +-- reportSDoc + +parseVerboseKey :: VerboseKey -> [String] +parseVerboseKey = wordsBy (`elem` (".:" :: String)) + +-- | Check whether a certain verbosity level is activated. +-- +-- Precondition: The level must be non-negative. +{-# SPECIALIZE hasVerbosity :: VerboseKey -> VerboseLevel -> TCM Bool #-} +hasVerbosity :: MonadDebug m => VerboseKey -> VerboseLevel -> m Bool +hasVerbosity k n | n < 0 = __IMPOSSIBLE__ + | otherwise = do + t <- getVerbosity + let ks = parseVerboseKey k + m = last $ 0 : Trie.lookupPath ks t + return (n <= m) + +-- | Check whether a certain verbosity level is activated (exact match). + +{-# SPECIALIZE hasExactVerbosity :: VerboseKey -> VerboseLevel -> TCM Bool #-} +hasExactVerbosity :: MonadDebug m => VerboseKey -> VerboseLevel -> m Bool +hasExactVerbosity k n = + (Just n ==) . Trie.lookup (parseVerboseKey k) <$> getVerbosity + +-- | Run a computation if a certain verbosity level is activated (exact match). + +{-# SPECIALIZE whenExactVerbosity :: VerboseKey -> VerboseLevel -> TCM () -> TCM () #-} +whenExactVerbosity :: MonadDebug m => VerboseKey -> VerboseLevel -> m () -> m () +whenExactVerbosity k n = whenM $ hasExactVerbosity k n + +__CRASH_WHEN__ :: (HasCallStack, MonadTCM m, MonadDebug m) => VerboseKey -> VerboseLevel -> m () +__CRASH_WHEN__ k n = whenExactVerbosity k n (throwImpossible err) + where + -- Create the "Unreachable" error using *our* caller as the call site. + err = withFileAndLine' (freezeCallStack callStack) Unreachable + +-- | Run a computation if a certain verbosity level is activated. +-- +-- Precondition: The level must be non-negative. +{-# SPECIALIZE verboseS :: VerboseKey -> VerboseLevel -> TCM () -> TCM () #-} +-- {-# SPECIALIZE verboseS :: MonadIO m => VerboseKey -> VerboseLevel -> TCMT m () -> TCMT m () #-} -- RULE left-hand side too complicated to desugar +-- {-# SPECIALIZE verboseS :: MonadTCM tcm => VerboseKey -> VerboseLevel -> tcm () -> tcm () #-} +verboseS :: MonadDebug m => VerboseKey -> VerboseLevel -> m () -> m () +verboseS k n action = whenM (hasVerbosity k n) $ nowDebugPrinting action + +-- | Apply a function if a certain verbosity level is activated. +-- +-- Precondition: The level must be non-negative. +applyWhenVerboseS :: MonadDebug m => VerboseKey -> VerboseLevel -> (m a -> m a) -> m a -> m a +applyWhenVerboseS k n f a = ifM (hasVerbosity k n) (f a) a + +-- | Verbosity lens. +verbosity :: VerboseKey -> Lens' VerboseLevel TCState +verbosity k = stPragmaOptions . verbOpt . Trie.valueAt (parseVerboseKey k) . defaultTo 0 + where + verbOpt :: Lens' Verbosity PragmaOptions + verbOpt f opts = f (optVerbose opts) <&> \ v -> opts { optVerbose = v } + -- Andreas, 2019-08-20: this lens should go into Interaction.Option.Lenses! + + defaultTo :: Eq a => a -> Lens' a (Maybe a) + defaultTo x f m = filterMaybe (== x) <$> f (fromMaybe x m) diff --git a/src/full/Agda/TypeChecking/Monad/Debug.hs-boot b/src/full/Agda/TypeChecking/Monad/Debug.hs-boot deleted file mode 100644 --- a/src/full/Agda/TypeChecking/Monad/Debug.hs-boot +++ /dev/null @@ -1,28 +0,0 @@ -module Agda.TypeChecking.Monad.Debug where - -import Control.Monad.IO.Class (MonadIO) -import Control.Monad.Reader - -import Agda.TypeChecking.Monad.Base -import {-# SOURCE #-} Agda.TypeChecking.Monad.Options - -import Agda.Utils.Pretty - -class (Functor m, Applicative m, Monad m) => MonadDebug m where - displayDebugMessage :: Int -> String -> m () - displayDebugMessage n s = traceDebugMessage n s $ return () - - traceDebugMessage :: Int -> String -> m a -> m a - traceDebugMessage n s cont = displayDebugMessage n s >> cont - - formatDebugMessage :: VerboseKey -> Int -> TCM Doc -> m String - -instance (MonadIO m) => MonadDebug (TCMT m) - -reportS :: (HasOptions m, MonadDebug m, MonadTCEnv m) - => VerboseKey -> Int -> String -> m () -reportSLn :: (HasOptions m, MonadDebug m, MonadTCEnv m) - => VerboseKey -> Int -> String -> m () -reportSDoc :: (HasOptions m, MonadDebug m, MonadTCEnv m) - => VerboseKey -> Int -> TCM Doc -> m () - diff --git a/src/full/Agda/TypeChecking/Monad/Env.hs b/src/full/Agda/TypeChecking/Monad/Env.hs --- a/src/full/Agda/TypeChecking/Monad/Env.hs +++ b/src/full/Agda/TypeChecking/Monad/Env.hs @@ -1,20 +1,21 @@ -{-# LANGUAGE CPP #-} module Agda.TypeChecking.Monad.Env where -import Control.Monad.Reader + import qualified Data.List as List -import qualified Data.Map as Map + import Data.Maybe (fromMaybe) -import Data.Monoid + import Agda.Syntax.Common import Agda.Syntax.Abstract.Name import Agda.TypeChecking.Monad.Base import Agda.Utils.FileName +import Agda.Utils.Function +import Agda.Utils.SmallSet +import qualified Agda.Utils.SmallSet as SmallSet -#include "undefined.h" import Agda.Utils.Impossible -- | Get the name of the current module, if any. @@ -24,7 +25,7 @@ currentModule = asksTC envCurrentModule -- | Set the name of the current module. -withCurrentModule :: ModuleName -> TCM a -> TCM a +withCurrentModule :: (MonadTCEnv m) => ModuleName -> m a -> m a withCurrentModule m = localTC $ \ e -> e { envCurrentModule = m } @@ -46,7 +47,7 @@ localTC $ \ e -> e { envAnonymousModules = (m, n) : envAnonymousModules e } -- | Set the current environment to the given -withEnv :: TCEnv -> TCM a -> TCM a +withEnv :: MonadTCEnv m => TCEnv -> m a -> m a withEnv env = localTC $ \ env0 -> env -- Keep persistent settings { envPrintMetasBare = envPrintMetasBare env0 @@ -72,11 +73,17 @@ -- | Restore setting for 'ExpandLast' to default. doExpandLast :: TCM a -> TCM a -doExpandLast = localTC $ \ e -> e { envExpandLast = ExpandLast } +doExpandLast = localTC $ \ e -> e { envExpandLast = setExpand (envExpandLast e) } + where + setExpand ReallyDontExpandLast = ReallyDontExpandLast + setExpand _ = ExpandLast dontExpandLast :: TCM a -> TCM a dontExpandLast = localTC $ \ e -> e { envExpandLast = DontExpandLast } +reallyDontExpandLast :: TCM a -> TCM a +reallyDontExpandLast = localTC $ \ e -> e { envExpandLast = ReallyDontExpandLast } + -- | If the reduced did a proper match (constructor or literal pattern), -- then record this as simplification step. {-# SPECIALIZE performedSimplification :: TCM a -> TCM a #-} @@ -96,23 +103,36 @@ updateAllowedReductions :: (AllowedReductions -> AllowedReductions) -> TCEnv -> TCEnv updateAllowedReductions f e = e { envAllowedReductions = f (envAllowedReductions e) } -modifyAllowedReductions :: (AllowedReductions -> AllowedReductions) -> TCM a -> TCM a +modifyAllowedReductions :: MonadTCEnv m => (AllowedReductions -> AllowedReductions) -> m a -> m a modifyAllowedReductions = localTC . updateAllowedReductions -putAllowedReductions :: AllowedReductions -> TCM a -> TCM a +putAllowedReductions :: MonadTCEnv m => AllowedReductions -> m a -> m a putAllowedReductions = modifyAllowedReductions . const -- | Reduce @Def f vs@ only if @f@ is a projection. -onlyReduceProjections :: TCM a -> TCM a -onlyReduceProjections = putAllowedReductions [ProjectionReductions] +onlyReduceProjections :: MonadTCEnv m => m a -> m a +onlyReduceProjections = putAllowedReductions $ SmallSet.singleton ProjectionReductions -- | Allow all reductions except for non-terminating functions (default). -allowAllReductions :: TCM a -> TCM a +allowAllReductions :: MonadTCEnv m => m a -> m a allowAllReductions = putAllowedReductions allReductions -- | Allow all reductions including non-terminating functions. -allowNonTerminatingReductions :: TCM a -> TCM a -allowNonTerminatingReductions = putAllowedReductions $ [NonTerminatingReductions] ++ allReductions +allowNonTerminatingReductions :: MonadTCEnv m => m a -> m a +allowNonTerminatingReductions = putAllowedReductions reallyAllReductions + +-- | Allow all reductions when reducing types +onlyReduceTypes :: MonadTCEnv m => m a -> m a +onlyReduceTypes = putAllowedReductions $ SmallSet.singleton TypeLevelReductions + +-- | Update allowed reductions when working on types +typeLevelReductions :: MonadTCEnv m => m a -> m a +typeLevelReductions = modifyAllowedReductions $ \reds -> if + | TypeLevelReductions `SmallSet.member` reds -> + if NonTerminatingReductions `SmallSet.member` reds + then reallyAllReductions + else allReductions + | otherwise -> reds -- * Concerning 'envInsideDotPattern' diff --git a/src/full/Agda/TypeChecking/Monad/Imports.hs b/src/full/Agda/TypeChecking/Monad/Imports.hs --- a/src/full/Agda/TypeChecking/Monad/Imports.hs +++ b/src/full/Agda/TypeChecking/Monad/Imports.hs @@ -1,10 +1,9 @@ -{-# LANGUAGE CPP #-} module Agda.TypeChecking.Monad.Imports where import Control.Monad.State -import Control.Monad.Reader + import Data.Set (Set) import qualified Data.Map as Map import qualified Data.Set as Set @@ -12,11 +11,9 @@ import Agda.Syntax.Abstract.Name import qualified Agda.Syntax.Concrete.Name as C import Agda.TypeChecking.Monad.Base -import Agda.Utils.Lens import Agda.Utils.List ( caseListM ) -import Agda.Utils.Monad -#include "undefined.h" + import Agda.Utils.Impossible addImport :: ModuleName -> TCM () diff --git a/src/full/Agda/TypeChecking/Monad/MetaVars.hs b/src/full/Agda/TypeChecking/Monad/MetaVars.hs --- a/src/full/Agda/TypeChecking/Monad/MetaVars.hs +++ b/src/full/Agda/TypeChecking/Monad/MetaVars.hs @@ -1,71 +1,129 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE NondecreasingIndentation #-} module Agda.TypeChecking.Monad.MetaVars where import Prelude hiding (null) -import Control.Applicative hiding (empty) import Control.Monad.State import Control.Monad.Reader import Control.Monad.Writer +import Control.Monad.Fail (MonadFail) -import Data.IntMap (IntMap) import qualified Data.IntMap as IntMap import Data.IntSet (IntSet) import qualified Data.IntSet as IntSet -import Data.Map (Map) import qualified Data.Map as Map import Data.Set (Set) import qualified Data.Set as Set import qualified Data.Foldable as Fold -import Data.Monoid import Agda.Syntax.Common import Agda.Syntax.Internal -import Agda.Syntax.Internal.Generic +import Agda.Syntax.Internal.MetaVars import Agda.Syntax.Position import Agda.Syntax.Scope.Base import Agda.TypeChecking.Monad.Base +import Agda.TypeChecking.Monad.Builtin (HasBuiltins) import Agda.TypeChecking.Monad.Trace import Agda.TypeChecking.Monad.Closure -import Agda.TypeChecking.Monad.Debug (reportSLn) +import Agda.TypeChecking.Monad.Constraints (MonadConstraint) +import Agda.TypeChecking.Monad.Debug (MonadDebug, reportSLn) import Agda.TypeChecking.Monad.Context +import Agda.TypeChecking.Monad.Signature (HasConstInfo) import Agda.TypeChecking.Substitute import {-# SOURCE #-} Agda.TypeChecking.Telescope +import Agda.Utils.Except import Agda.Utils.Functor ((<.>)) -import Agda.Utils.Lens -import Agda.Utils.List import Agda.Utils.Maybe import Agda.Utils.Monad import Agda.Utils.Null import Agda.Utils.Permutation import Agda.Utils.Pretty (prettyShow) import Agda.Utils.Tuple -import Agda.Utils.Singleton -import Agda.Utils.Size import qualified Agda.Utils.Maybe.Strict as Strict -#include "undefined.h" import Agda.Utils.Impossible +-- | Various kinds of metavariables. + +data MetaKind = + Records + -- ^ Meta variables of record type. + | SingletonRecords + -- ^ Meta variables of \"hereditarily singleton\" record type. + | Levels + -- ^ Meta variables of level type, if type-in-type is activated. + deriving (Eq, Enum, Bounded, Show) + +-- | All possible metavariable kinds. + +allMetaKinds :: [MetaKind] +allMetaKinds = [minBound .. maxBound] + +data KeepMetas = KeepMetas | RollBackMetas + +-- | Monad service class for creating, solving and eta-expanding of +-- metavariables. +class ( MonadConstraint m + , MonadReduce m + , MonadAddContext m + , MonadTCEnv m + , ReadTCState m + , HasBuiltins m + , HasConstInfo m + , MonadDebug m + ) => MonadMetaSolver m where + -- | Generate a new meta variable with some instantiation given. + -- For instance, the instantiation could be a 'PostponedTypeCheckingProblem'. + newMeta' :: MetaInstantiation -> Frozen -> MetaInfo -> MetaPriority -> Permutation -> + Judgement a -> m MetaId + + -- * Solve constraint @x vs = v@. + + -- | Assign to an open metavar which may not be frozen. + -- First check that metavar args are in pattern fragment. + -- Then do extended occurs check on given thing. + -- + -- Assignment is aborted by throwing a @PatternErr@ via a call to + -- @patternViolation@. This error is caught by @catchConstraint@ + -- during equality checking (@compareAtom@) and leads to + -- restoration of the original constraints. + assignV :: CompareDirection -> MetaId -> Args -> Term -> CompareAs -> m () + + -- | Directly instantiate the metavariable. Skip pattern check, + -- occurs check and frozen check. Used for eta expanding frozen + -- metas. + assignTerm' :: MonadMetaSolver m => MetaId -> [Arg ArgName] -> Term -> m () + + -- | Eta expand a metavariable, if it is of the specified kind. + -- Don't do anything if the metavariable is a blocked term. + etaExpandMeta :: [MetaKind] -> MetaId -> m () + + -- | Update the status of the metavariable + updateMetaVar :: MetaId -> (MetaVariable -> MetaVariable) -> m () + + -- | 'speculateMetas fallback m' speculatively runs 'm', but if the + -- result is 'RollBackMetas' any changes to metavariables are + -- rolled back and 'fallback' is run instead. + speculateMetas :: m () -> m KeepMetas -> m () + -- | Switch off assignment of metas. -dontAssignMetas :: TCM a -> TCM a +dontAssignMetas :: (MonadTCEnv m, HasOptions m, MonadDebug m) => m a -> m a dontAssignMetas cont = do reportSLn "tc.meta" 45 $ "don't assign metas" localTC (\ env -> env { envAssignMetas = False }) cont -- | Get the meta store. -getMetaStore :: TCM MetaStore -getMetaStore = useTC stMetaStore +getMetaStore :: (ReadTCState m) => m MetaStore +getMetaStore = useR stMetaStore modifyMetaStore :: (MetaStore -> MetaStore) -> TCM () modifyMetaStore f = stMetaStore `modifyTCLens` f -- | Run a computation and record which new metas it created. -metasCreatedBy :: TCM a -> TCM (a, IntSet) +metasCreatedBy :: ReadTCState m => m a -> m (a, IntSet) metasCreatedBy m = do before <- IntMap.keysSet <$> useTC stMetaStore a <- m @@ -73,25 +131,29 @@ return (a, after IntSet.\\ before) -- | Lookup a meta variable. -lookupMeta' :: MetaId -> TCM (Maybe MetaVariable) +lookupMeta' :: ReadTCState m => MetaId -> m (Maybe MetaVariable) lookupMeta' m = IntMap.lookup (metaId m) <$> getMetaStore -lookupMeta :: MetaId -> TCM MetaVariable +lookupMeta :: (MonadFail m, ReadTCState m) => MetaId -> m MetaVariable lookupMeta m = fromMaybeM failure $ lookupMeta' m where failure = fail $ "no such meta variable " ++ prettyShow m +-- | Type of a term or sort meta. +metaType :: (MonadFail m, ReadTCState m) => MetaId -> m Type +metaType x = jMetaType . mvJudgement <$> lookupMeta x + -- | Update the information associated with a meta variable. -updateMetaVar :: MetaId -> (MetaVariable -> MetaVariable) -> TCM () -updateMetaVar m f = modifyMetaStore $ IntMap.adjust f $ metaId m +updateMetaVarTCM :: MetaId -> (MetaVariable -> MetaVariable) -> TCM () +updateMetaVarTCM m f = modifyMetaStore $ IntMap.adjust f $ metaId m -- | Insert a new meta variable with associated information into the meta store. insertMetaVar :: MetaId -> MetaVariable -> TCM () insertMetaVar m mv = modifyMetaStore $ IntMap.insert (metaId m) mv -getMetaPriority :: MetaId -> TCM MetaPriority +getMetaPriority :: (MonadFail m, ReadTCState m) => MetaId -> m MetaPriority getMetaPriority = mvPriority <.> lookupMeta -isSortMeta :: MetaId -> TCM Bool +isSortMeta :: (MonadFail m, ReadTCState m) => MetaId -> m Bool isSortMeta m = isSortMeta_ <$> lookupMeta m isSortMeta_ :: MetaVariable -> Bool @@ -99,7 +161,7 @@ HasType{} -> False IsSort{} -> True -getMetaType :: MetaId -> TCM Type +getMetaType :: (MonadFail m, ReadTCState m) => MetaId -> m Type getMetaType m = do mv <- lookupMeta m return $ case mvJudgement mv of @@ -108,23 +170,28 @@ -- | Compute the context variables that a meta should be applied to, accounting -- for pruning. -getMetaContextArgs :: MetaVariable -> TCM Args +getMetaContextArgs :: MonadTCEnv m => MetaVariable -> m Args getMetaContextArgs MetaVar{ mvPermutation = p } = do args <- getContextArgs return $ permute (takeP (length args) p) args -- | Given a meta, return the type applied to the current context. -getMetaTypeInContext :: MetaId -> TCM Type +getMetaTypeInContext :: (MonadFail m, MonadTCEnv m, ReadTCState m, MonadReduce m) + => MetaId -> m Type getMetaTypeInContext m = do mv@MetaVar{ mvJudgement = j } <- lookupMeta m case j of HasType{ jMetaType = t } -> piApplyM t =<< getMetaContextArgs mv IsSort{} -> __IMPOSSIBLE__ +-- | Is it a meta that might be generalized? +isGeneralizableMeta :: (ReadTCState m, MonadFail m) => MetaId -> m DoGeneralize +isGeneralizableMeta x = unArg . miGeneralizable . mvInfo <$> lookupMeta x + -- | Check whether all metas are instantiated. -- Precondition: argument is a meta (in some form) or a list of metas. class IsInstantiatedMeta a where - isInstantiatedMeta :: a -> TCM Bool + isInstantiatedMeta :: (MonadFail m, ReadTCState m) => a -> m Bool instance IsInstantiatedMeta MetaId where isInstantiatedMeta m = isJust <$> isInstantiatedMeta' m @@ -141,7 +208,8 @@ _ -> __IMPOSSIBLE__ instance IsInstantiatedMeta Level where - isInstantiatedMeta (Max ls) = isInstantiatedMeta ls + isInstantiatedMeta (Max n ls) | n == 0 = isInstantiatedMeta ls + isInstantiatedMeta _ = __IMPOSSIBLE__ instance IsInstantiatedMeta PlusLevel where isInstantiatedMeta (Plus n l) | n == 0 = isInstantiatedMeta l @@ -164,7 +232,7 @@ instance IsInstantiatedMeta a => IsInstantiatedMeta (Abs a) where isInstantiatedMeta = isInstantiatedMeta . unAbs -isInstantiatedMeta' :: MetaId -> TCM (Maybe Term) +isInstantiatedMeta' :: (MonadFail m, ReadTCState m) => MetaId -> m (Maybe Term) isInstantiatedMeta' m = do mv <- lookupMeta m return $ case mvInstantiation mv of @@ -172,42 +240,6 @@ _ -> Nothing --- | Returns every meta-variable occurrence in the given type, except --- for those in 'Sort's. -allMetas :: (TermLike a, Monoid m) => (MetaId -> m) -> a -> m -allMetas singl = foldTerm metas - where - metas (MetaV m _) = singl m - metas (Level l) = levelMetas l - metas _ = mempty - - levelMetas (Max as) = foldMap plusLevelMetas as - - plusLevelMetas ClosedLevel{} = mempty - plusLevelMetas (Plus _ l) = levelAtomMetas l - - levelAtomMetas (MetaLevel m _) = singl m - levelAtomMetas _ = mempty - --- | Returns 'allMetas' in a list. --- @allMetasList = allMetas (:[])@. --- --- Note: this resulting list is computed via difference lists. --- Thus, use this function if you actually need the whole list of metas. --- Otherwise, use 'allMetas' with a suitable monoid. -allMetasList :: TermLike a => a -> [MetaId] -allMetasList t = allMetas singleton t `appEndo` [] - --- | 'True' if thing contains no metas. --- @noMetas = null . allMetasList@. -noMetas :: TermLike a => a -> Bool -noMetas = getAll . allMetas (\ _m -> All False) - --- | Returns the first meta it find in the thing, if any. --- @firstMeta == headMaybe . allMetasList@. -firstMeta :: TermLike a => a -> Maybe MetaId -firstMeta = getFirst . allMetas (First . Just) - -- | Returns all metavariables in a constraint. Slightly complicated by the -- fact that blocked terms are represented by two meta variables. To find the -- second one we need to look up the meta listeners for the one in the @@ -222,12 +254,11 @@ ValueCmp _ t u v -> return $ allMetas Set.singleton (t, u, v) ValueCmpOnFace _ p t u v -> return $ allMetas Set.singleton (p, t, u, v) ElimCmp _ _ t u es es' -> return $ allMetas Set.singleton (t, u, es, es') - TypeCmp _ t t' -> return $ allMetas Set.singleton (t, t') - LevelCmp _ l l' -> return $ allMetas Set.singleton (l, l') + LevelCmp _ l l' -> return $ allMetas Set.singleton (Level l, Level l') UnquoteTactic m t h g -> return $ Set.fromList [x | Just x <- [m]] `Set.union` allMetas Set.singleton (t, h, g) Guarded c _ -> metas c TelCmp _ _ _ tel1 tel2 -> return $ allMetas Set.singleton (tel1, tel2) - SortCmp _ s1 s2 -> return $ allMetas Set.singleton (s1, s2) + SortCmp _ s1 s2 -> return $ allMetas Set.singleton (Sort s1, Sort s2) UnBlock x -> Set.insert x . Set.unions <$> (mapM listenerMetas =<< getMetaListeners x) FindInstance{} -> return mempty -- v Ignore these constraints IsEmpty{} -> return mempty @@ -235,16 +266,19 @@ CheckSizeLtSat{} -> return mempty HasBiggerSort{} -> return mempty HasPTSRule{} -> return mempty + CheckMetaInst x -> return mempty -- For blocked constant twin variables listenerMetas EtaExpand{} = return Set.empty listenerMetas (CheckConstraint _ c) = constraintMetas (clValue $ theConstraint c) -- | Create 'MetaInfo' in the current environment. -createMetaInfo :: TCM MetaInfo +createMetaInfo :: (MonadTCEnv m, ReadTCState m) => m MetaInfo createMetaInfo = createMetaInfo' RunMetaOccursCheck -createMetaInfo' :: RunMetaOccursCheck -> TCM MetaInfo +createMetaInfo' + :: (MonadTCEnv m, ReadTCState m) + => RunMetaOccursCheck -> m MetaInfo createMetaInfo' b = do r <- getCurrentRange cl <- buildClosure r @@ -256,7 +290,7 @@ , miGeneralizable = hide $ defaultArg gen } -setValueMetaName :: Term -> MetaNameSuggestion -> TCM () +setValueMetaName :: MonadMetaSolver m => Term -> MetaNameSuggestion -> m () setValueMetaName v s = do case v of MetaV mi _ -> setMetaNameSuggestion mi s @@ -265,39 +299,53 @@ "cannot set meta name; newMeta returns " ++ show u return () -getMetaNameSuggestion :: MetaId -> TCM MetaNameSuggestion +getMetaNameSuggestion :: (MonadFail m, ReadTCState m) => MetaId -> m MetaNameSuggestion getMetaNameSuggestion mi = miNameSuggestion . mvInfo <$> lookupMeta mi -setMetaNameSuggestion :: MetaId -> MetaNameSuggestion -> TCM () +setMetaNameSuggestion :: MonadMetaSolver m => MetaId -> MetaNameSuggestion -> m () setMetaNameSuggestion mi s = unless (null s || isUnderscore s) $ do reportSLn "tc.meta.name" 20 $ "setting name of meta " ++ prettyShow mi ++ " to " ++ s updateMetaVar mi $ \ mvar -> mvar { mvInfo = (mvInfo mvar) { miNameSuggestion = s }} -setMetaArgInfo :: MetaId -> ArgInfo -> TCM () +setMetaArgInfo :: MonadMetaSolver m => MetaId -> ArgInfo -> m () setMetaArgInfo m i = updateMetaVar m $ \ mv -> mv { mvInfo = (mvInfo mv) { miGeneralizable = setArgInfo i (miGeneralizable (mvInfo mv)) } } -updateMetaVarRange :: MetaId -> Range -> TCM () +updateMetaVarRange :: MonadMetaSolver m => MetaId -> Range -> m () updateMetaVarRange mi r = updateMetaVar mi (setRange r) -setMetaOccursCheck :: MetaId -> RunMetaOccursCheck -> TCM () +setMetaOccursCheck :: MonadMetaSolver m => MetaId -> RunMetaOccursCheck -> m () setMetaOccursCheck mi b = updateMetaVar mi $ \ mvar -> mvar { mvInfo = (mvInfo mvar) { miMetaOccursCheck = b } } -- * Query and manipulate interaction points. -modifyInteractionPoints :: (InteractionPoints -> InteractionPoints) -> TCM () -modifyInteractionPoints f = - stInteractionPoints `modifyTCLens` f +class (MonadTCEnv m, ReadTCState m) => MonadInteractionPoints m where + freshInteractionId :: m InteractionId + modifyInteractionPoints :: (InteractionPoints -> InteractionPoints) -> m () +instance MonadInteractionPoints m => MonadInteractionPoints (ReaderT r m) where + freshInteractionId = lift freshInteractionId + modifyInteractionPoints = lift . modifyInteractionPoints + +instance MonadInteractionPoints m => MonadInteractionPoints (StateT r m) where + freshInteractionId = lift freshInteractionId + modifyInteractionPoints = lift . modifyInteractionPoints + +instance MonadInteractionPoints TCM where + freshInteractionId = fresh + modifyInteractionPoints f = stInteractionPoints `modifyTCLens` f + -- | Register an interaction point during scope checking. -- If there is no interaction id yet, create one. -registerInteractionPoint :: Bool -> Range -> Maybe Nat -> TCM InteractionId +registerInteractionPoint + :: forall m. MonadInteractionPoints m + => Bool -> Range -> Maybe Nat -> m InteractionId registerInteractionPoint preciseRange r maybeId = do - m <- useTC stInteractionPoints + m <- useR stInteractionPoints -- If we're given an interaction id we shouldn't look up by range. -- This is important when doing 'refine', since all interaction points -- created by the refine gets the same range. @@ -308,11 +356,12 @@ -- First, try to find the interaction point by Range. caseMaybe (findInteractionPoint_ r m) (continue m) {-else-} return where + continue :: InteractionPoints -> m InteractionId continue m = do -- We did not find an interaction id with the same Range, so let's create one! ii <- case maybeId of Just i -> return $ InteractionId i - Nothing -> fresh + Nothing -> freshInteractionId let ip = InteractionPoint { ipRange = r, ipMeta = Nothing, ipSolved = False, ipClause = IPNoClause } case Map.insertLookupWithKey (\ key new old -> old) ii ip m of -- If the interaction point is already present, we keep the old ip. @@ -331,17 +380,19 @@ findInteractionPoint_ :: Range -> InteractionPoints -> Maybe InteractionId findInteractionPoint_ r m = do guard $ not $ null r - headMaybe $ mapMaybe sameRange $ Map.toList m + listToMaybe $ mapMaybe sameRange $ Map.toList m where sameRange :: (InteractionId, InteractionPoint) -> Maybe InteractionId sameRange (ii, InteractionPoint r' _ _ _) | r == r' = Just ii sameRange _ = Nothing -- | Hook up meta variable to interaction point. -connectInteractionPoint :: InteractionId -> MetaId -> TCM () +connectInteractionPoint + :: MonadInteractionPoints m + => InteractionId -> MetaId -> m () connectInteractionPoint ii mi = do ipCl <- asksTC envClause - m <- useTC stInteractionPoints + m <- useR stInteractionPoints let ip = InteractionPoint { ipRange = __IMPOSSIBLE__, ipMeta = Just mi, ipSolved = False, ipClause = ipCl } -- The interaction point needs to be present already, we just set the meta. case Map.insertLookupWithKey (\ key new old -> new { ipRange = ipRange old }) ii ip m of @@ -349,63 +400,67 @@ (Just _, m') -> modifyInteractionPoints $ const m' -- | Mark an interaction point as solved. -removeInteractionPoint :: InteractionId -> TCM () -removeInteractionPoint ii = do - stInteractionPoints `modifyTCLens` Map.update (\ ip -> Just ip{ ipSolved = True }) ii +removeInteractionPoint :: MonadInteractionPoints m => InteractionId -> m () +removeInteractionPoint ii = + modifyInteractionPoints $ Map.update (\ ip -> Just ip{ ipSolved = True }) ii -- | Get a list of interaction ids. {-# SPECIALIZE getInteractionPoints :: TCM [InteractionId] #-} -getInteractionPoints :: MonadTCM tcm => tcm [InteractionId] -getInteractionPoints = Map.keys <$> useTC stInteractionPoints +getInteractionPoints :: ReadTCState m => m [InteractionId] +getInteractionPoints = Map.keys <$> useR stInteractionPoints -- | Get all metas that correspond to unsolved interaction ids. -getInteractionMetas :: TCM [MetaId] +getInteractionMetas :: ReadTCState m => m [MetaId] getInteractionMetas = - mapMaybe ipMeta . filter (not . ipSolved) . Map.elems <$> useTC stInteractionPoints + mapMaybe ipMeta . filter (not . ipSolved) . Map.elems <$> useR stInteractionPoints -- | Get all metas that correspond to unsolved interaction ids. -getInteractionIdsAndMetas :: TCM [(InteractionId,MetaId)] +getInteractionIdsAndMetas :: ReadTCState m => m [(InteractionId,MetaId)] getInteractionIdsAndMetas = - mapMaybe f . filter (not . ipSolved . snd) . Map.toList <$> useTC stInteractionPoints + mapMaybe f . filter (not . ipSolved . snd) . Map.toList <$> useR stInteractionPoints where f (ii, ip) = (ii,) <$> ipMeta ip -- | Does the meta variable correspond to an interaction point? -- -- Time: @O(n)@ where @n@ is the number of interaction metas. -isInteractionMeta :: MetaId -> TCM (Maybe InteractionId) +isInteractionMeta :: ReadTCState m => MetaId -> m (Maybe InteractionId) isInteractionMeta x = lookup x . map swap <$> getInteractionIdsAndMetas -- | Get the information associated to an interaction point. {-# SPECIALIZE lookupInteractionPoint :: InteractionId -> TCM InteractionPoint #-} -lookupInteractionPoint :: MonadTCM tcm => InteractionId -> tcm InteractionPoint +lookupInteractionPoint + :: (MonadFail m, ReadTCState m, MonadError TCErr m) + => InteractionId -> m InteractionPoint lookupInteractionPoint ii = - fromMaybeM err $ Map.lookup ii <$> useTC stInteractionPoints + fromMaybeM err $ Map.lookup ii <$> useR stInteractionPoints where err = fail $ "no such interaction point: " ++ show ii -- | Get 'MetaId' for an interaction point. -- Precondition: interaction point is connected. -lookupInteractionId :: InteractionId -> TCM MetaId +lookupInteractionId + :: (MonadFail m, ReadTCState m, MonadError TCErr m, MonadTCEnv m) + => InteractionId -> m MetaId lookupInteractionId ii = fromMaybeM err2 $ ipMeta <$> lookupInteractionPoint ii where err2 = typeError $ GenericError $ "No type nor action available for hole " ++ prettyShow ii ++ ". Possible cause: the hole has not been reached during type checking (do you see yellow?)" -- | Check whether an interaction id is already associated with a meta variable. -lookupInteractionMeta :: InteractionId -> TCM (Maybe MetaId) -lookupInteractionMeta ii = lookupInteractionMeta_ ii <$> useTC stInteractionPoints +lookupInteractionMeta :: ReadTCState m => InteractionId -> m (Maybe MetaId) +lookupInteractionMeta ii = lookupInteractionMeta_ ii <$> useR stInteractionPoints lookupInteractionMeta_ :: InteractionId -> InteractionPoints -> Maybe MetaId lookupInteractionMeta_ ii m = ipMeta =<< Map.lookup ii m -- | Generate new meta variable. -newMeta :: Frozen -> MetaInfo -> MetaPriority -> Permutation -> Judgement a -> TCM MetaId +newMeta :: MonadMetaSolver m => Frozen -> MetaInfo -> MetaPriority -> Permutation -> Judgement a -> m MetaId newMeta = newMeta' Open -- | Generate a new meta variable with some instantiation given. -- For instance, the instantiation could be a 'PostponedTypeCheckingProblem'. -newMeta' :: MetaInstantiation -> Frozen -> MetaInfo -> MetaPriority -> Permutation -> - Judgement a -> TCM MetaId -newMeta' inst frozen mi p perm j = do +newMetaTCM' :: MetaInstantiation -> Frozen -> MetaInfo -> MetaPriority -> Permutation -> + Judgement a -> TCM MetaId +newMetaTCM' inst frozen mi p perm j = do x <- fresh let j' = j { jMetaId = x } -- fill the identifier part of the judgement mv = MetaVar{ mvInfo = mi @@ -415,6 +470,7 @@ , mvInstantiation = inst , mvListeners = Set.empty , mvFrozen = frozen + , mvTwin = Nothing } -- printing not available (import cycle) -- reportSDoc "tc.meta.new" 50 $ "new meta" <+> prettyTCM j' @@ -423,11 +479,13 @@ -- | Get the 'Range' for an interaction point. {-# SPECIALIZE getInteractionRange :: InteractionId -> TCM Range #-} -getInteractionRange :: MonadTCM tcm => InteractionId -> tcm Range +getInteractionRange + :: (MonadInteractionPoints m, MonadFail m, MonadError TCErr m) + => InteractionId -> m Range getInteractionRange = ipRange <.> lookupInteractionPoint -- | Get the 'Range' for a meta variable. -getMetaRange :: MetaId -> TCM Range +getMetaRange :: (MonadFail m, ReadTCState m) => MetaId -> m Range getMetaRange = getRange <.> lookupMeta getInteractionScope :: InteractionId -> TCM ScopeInfo @@ -440,15 +498,15 @@ withMetaInfo mI cont = enterClosure mI $ \ r -> setCurrentRange r cont -getMetaVariableSet :: TCM IntSet +getMetaVariableSet :: ReadTCState m => m IntSet getMetaVariableSet = IntMap.keysSet <$> getMetaStore -getMetaVariables :: (MetaVariable -> Bool) -> TCM [MetaId] +getMetaVariables :: ReadTCState m => (MetaVariable -> Bool) -> m [MetaId] getMetaVariables p = do store <- getMetaStore return [ MetaId i | (i, mv) <- IntMap.assocs store, p mv ] -getInstantiatedMetas :: TCM [MetaId] +getInstantiatedMetas :: ReadTCState m => m [MetaId] getInstantiatedMetas = getMetaVariables (isInst . mvInstantiation) where isInst Open = False @@ -457,7 +515,7 @@ isInst PostponedTypeCheckingProblem{} = False isInst InstV{} = True -getOpenMetas :: TCM [MetaId] +getOpenMetas :: ReadTCState m => m [MetaId] getOpenMetas = getMetaVariables (isOpenMeta . mvInstantiation) isOpenMeta :: MetaInstantiation -> Bool @@ -469,20 +527,20 @@ -- | @listenToMeta l m@: register @l@ as a listener to @m@. This is done -- when the type of l is blocked by @m@. -listenToMeta :: Listener -> MetaId -> TCM () +listenToMeta :: MonadMetaSolver m => Listener -> MetaId -> m () listenToMeta l m = updateMetaVar m $ \mv -> mv { mvListeners = Set.insert l $ mvListeners mv } -- | Unregister a listener. -unlistenToMeta :: Listener -> MetaId -> TCM () +unlistenToMeta :: MonadMetaSolver m => Listener -> MetaId -> m () unlistenToMeta l m = updateMetaVar m $ \mv -> mv { mvListeners = Set.delete l $ mvListeners mv } -- | Get the listeners to a meta. -getMetaListeners :: MetaId -> TCM [Listener] +getMetaListeners :: (MonadFail m, ReadTCState m) => MetaId -> m [Listener] getMetaListeners m = Set.toList . mvListeners <$> lookupMeta m -clearMetaListeners :: MetaId -> TCM () +clearMetaListeners :: MonadMetaSolver m => MetaId -> m () clearMetaListeners m = updateMetaVar m $ \mv -> mv { mvListeners = Set.empty } @@ -526,7 +584,7 @@ | cond m = mvar { mvFrozen = Instantiable } | otherwise = mvar -isFrozen :: MetaId -> TCM Bool +isFrozen :: (MonadFail m, ReadTCState m) => MetaId -> m Bool isFrozen x = do mvar <- lookupMeta x return $ mvFrozen mvar == Frozen @@ -534,12 +592,12 @@ -- | Unfreeze meta and its type if this is a meta again. -- Does not unfreeze deep occurrences of metas. class UnFreezeMeta a where - unfreezeMeta :: a -> TCM () + unfreezeMeta :: MonadMetaSolver m => a -> m () instance UnFreezeMeta MetaId where unfreezeMeta x = do updateMetaVar x $ \ mv -> mv { mvFrozen = Instantiable } - unfreezeMeta =<< do jMetaType . mvJudgement <$> lookupMeta x + unfreezeMeta =<< metaType x instance UnFreezeMeta Type where unfreezeMeta (El s t) = unfreezeMeta s >> unfreezeMeta t @@ -557,11 +615,10 @@ unfreezeMeta _ = return () instance UnFreezeMeta Level where - unfreezeMeta (Max ls) = unfreezeMeta ls + unfreezeMeta (Max _ ls) = unfreezeMeta ls instance UnFreezeMeta PlusLevel where unfreezeMeta (Plus _ a) = unfreezeMeta a - unfreezeMeta ClosedLevel{} = return () instance UnFreezeMeta LevelAtom where unfreezeMeta (MetaLevel x _) = unfreezeMeta x diff --git a/src/full/Agda/TypeChecking/Monad/MetaVars.hs-boot b/src/full/Agda/TypeChecking/Monad/MetaVars.hs-boot new file mode 100644 --- /dev/null +++ b/src/full/Agda/TypeChecking/Monad/MetaVars.hs-boot @@ -0,0 +1,17 @@ + +module Agda.TypeChecking.Monad.MetaVars where + +import Control.Monad.Reader +import Control.Monad.State + +import Agda.Syntax.Common (InteractionId) +import Agda.TypeChecking.Monad.Base + +class (MonadTCEnv m, ReadTCState m) => MonadInteractionPoints m where + freshInteractionId :: m InteractionId + modifyInteractionPoints :: (InteractionPoints -> InteractionPoints) -> m () + +instance MonadInteractionPoints m => MonadInteractionPoints (ReaderT r m) +instance MonadInteractionPoints m => MonadInteractionPoints (StateT r m) + +instance MonadInteractionPoints TCM diff --git a/src/full/Agda/TypeChecking/Monad/Mutual.hs b/src/full/Agda/TypeChecking/Monad/Mutual.hs --- a/src/full/Agda/TypeChecking/Monad/Mutual.hs +++ b/src/full/Agda/TypeChecking/Monad/Mutual.hs @@ -1,13 +1,12 @@ --- {-# LANGUAGE CPP #-} module Agda.TypeChecking.Monad.Mutual where import Prelude hiding (null) -import Control.Monad.Reader + import Data.Functor ((<$>)) -import Data.Set (Set) + import qualified Data.Set as Set import qualified Data.Map as Map @@ -16,7 +15,6 @@ import Agda.TypeChecking.Monad.Base import Agda.TypeChecking.Monad.State -import Agda.Utils.Lens import Agda.Utils.Null import Agda.Utils.Pretty ( prettyShow ) diff --git a/src/full/Agda/TypeChecking/Monad/Open.hs b/src/full/Agda/TypeChecking/Monad/Open.hs --- a/src/full/Agda/TypeChecking/Monad/Open.hs +++ b/src/full/Agda/TypeChecking/Monad/Open.hs @@ -1,4 +1,3 @@ --- {-# LANGUAGE CPP #-} module Agda.TypeChecking.Monad.Open ( makeOpen @@ -7,10 +6,6 @@ , isClosed ) where -import Control.Monad -import Control.Monad.Reader -import qualified Data.List as List - import Agda.Syntax.Internal import Agda.TypeChecking.Substitute import Agda.TypeChecking.Monad.Base @@ -18,11 +13,9 @@ import {-# SOURCE #-} Agda.TypeChecking.Monad.Context import Agda.Utils.Lens -import Agda.Utils.Maybe -import Agda.Utils.Except ( MonadError(catchError) ) -- | Create an open term in the current context. -makeOpen :: a -> TCM (Open a) +makeOpen :: MonadTCEnv m => a -> m (Open a) makeOpen x = do cp <- viewTC eCurrentCheckpoint return $ OpenThing cp x diff --git a/src/full/Agda/TypeChecking/Monad/Options.hs b/src/full/Agda/TypeChecking/Monad/Options.hs --- a/src/full/Agda/TypeChecking/Monad/Options.hs +++ b/src/full/Agda/TypeChecking/Monad/Options.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} module Agda.TypeChecking.Monad.Options where @@ -6,42 +5,25 @@ import Control.Monad.Reader hiding (mapM) import Control.Monad.Writer -import Control.Monad.State hiding (mapM) import Data.Maybe -import Data.Traversable import System.Directory import System.FilePath -import Agda.Syntax.Internal -import Agda.Syntax.Common -import Agda.Syntax.Concrete -import {-# SOURCE #-} Agda.TypeChecking.Monad.Debug -import {-# SOURCE #-} Agda.TypeChecking.Errors +import Agda.TypeChecking.Monad.Debug (reportSDoc) import Agda.TypeChecking.Warnings import Agda.TypeChecking.Monad.Base import Agda.TypeChecking.Monad.State import Agda.TypeChecking.Monad.Benchmark -import {-# SOURCE #-} Agda.Interaction.FindFile import Agda.Interaction.Options import qualified Agda.Interaction.Options.Lenses as Lens -import Agda.Interaction.Response import Agda.Interaction.Library - -import Agda.Utils.Except ( MonadError(catchError) ) import Agda.Utils.FileName import Agda.Utils.Maybe -import Agda.Utils.Monad -import Agda.Utils.Lens -import Agda.Utils.List import Agda.Utils.Pretty -import Agda.Utils.Trie (Trie) -import qualified Agda.Utils.Trie as Trie import Agda.Utils.Except -import Agda.Utils.Either -#include "undefined.h" import Agda.Utils.Impossible -- | Sets the pragma options. @@ -114,7 +96,10 @@ setLibraryIncludes =<< addDefaultLibraries root o setLibraryIncludes :: CommandLineOptions -> TCM CommandLineOptions -setLibraryIncludes o = do +setLibraryIncludes o + | or [ not $ optUseLibs o + , optShowVersion o ] = pure o + | otherwise = do let libs = optLibraries o installed <- libToTCM $ getInstalledLibraries (optOverrideLibrariesFile o) paths <- libToTCM $ libraryIncludePaths (optOverrideLibrariesFile o) installed libs @@ -142,31 +127,19 @@ Right opts' -> setPragmaOptions opts' -- | Disable display forms. -enableDisplayForms :: TCM a -> TCM a +enableDisplayForms :: MonadTCEnv m => m a -> m a enableDisplayForms = localTC $ \e -> e { envDisplayFormsEnabled = True } -- | Disable display forms. -disableDisplayForms :: TCM a -> TCM a +disableDisplayForms :: MonadTCEnv m => m a -> m a disableDisplayForms = localTC $ \e -> e { envDisplayFormsEnabled = False } -- | Check if display forms are enabled. -displayFormsEnabled :: TCM Bool +displayFormsEnabled :: MonadTCEnv m => m Bool displayFormsEnabled = asksTC envDisplayFormsEnabled --- | Gets the include directories. --- --- Precondition: 'optAbsoluteIncludePaths' must be nonempty (i.e. --- 'setCommandLineOptions' must have run). - -getIncludeDirs :: TCM [AbsolutePath] -getIncludeDirs = do - incs <- optAbsoluteIncludePaths <$> commandLineOptions - case incs of - [] -> __IMPOSSIBLE__ - _ -> return incs - -- | Makes the given directories absolute and stores them as include -- directories. -- @@ -242,7 +215,7 @@ getInputFile' = mapM (liftIO . absolute) =<< do optInputFile <$> commandLineOptions -hasInputFile :: TCM Bool +hasInputFile :: HasOptions m => m Bool hasInputFile = isJust <$> optInputFile <$> commandLineOptions isPropEnabled :: HasOptions m => m Bool @@ -252,13 +225,10 @@ hasUniversePolymorphism :: HasOptions m => m Bool hasUniversePolymorphism = optUniversePolymorphism <$> pragmaOptions -enableCaching :: TCM Bool -enableCaching = optCaching <$> pragmaOptions - -showImplicitArguments :: TCM Bool +showImplicitArguments :: HasOptions m => m Bool showImplicitArguments = optShowImplicit <$> pragmaOptions -showIrrelevantArguments :: TCM Bool +showIrrelevantArguments :: HasOptions m => m Bool showIrrelevantArguments = optShowIrrelevant <$> pragmaOptions -- | Switch on printing of implicit and irrelevant arguments. @@ -268,107 +238,35 @@ -- Thus, do not attempt to make persistent 'PragmaOptions' -- changes in a `withShowAllArguments` bracket. -withShowAllArguments :: TCM a -> TCM a +withShowAllArguments :: ReadTCState m => m a -> m a withShowAllArguments = withShowAllArguments' True -withShowAllArguments' :: Bool -> TCM a -> TCM a +withShowAllArguments' :: ReadTCState m => Bool -> m a -> m a withShowAllArguments' yes = withPragmaOptions $ \ opts -> opts { optShowImplicit = yes, optShowIrrelevant = yes } -- | Change 'PragmaOptions' for a computation and restore afterwards. - -withPragmaOptions :: (PragmaOptions -> PragmaOptions) -> TCM a -> TCM a -withPragmaOptions f cont = do - opts <- pragmaOptions - setPragmaOptions $ f opts - x <- cont - setPragmaOptions opts - return x - +withPragmaOptions :: ReadTCState m => (PragmaOptions -> PragmaOptions) -> m a -> m a +withPragmaOptions = locallyTCState stPragmaOptions -ignoreInterfaces :: TCM Bool +ignoreInterfaces :: HasOptions m => m Bool ignoreInterfaces = optIgnoreInterfaces <$> commandLineOptions -ignoreAllInterfaces :: TCM Bool +ignoreAllInterfaces :: HasOptions m => m Bool ignoreAllInterfaces = optIgnoreAllInterfaces <$> commandLineOptions - -positivityCheckEnabled :: TCM Bool +positivityCheckEnabled :: HasOptions m => m Bool positivityCheckEnabled = not . optDisablePositivity <$> pragmaOptions {-# SPECIALIZE typeInType :: TCM Bool #-} typeInType :: HasOptions m => m Bool typeInType = not . optUniverseCheck <$> pragmaOptions -etaEnabled :: TCM Bool +etaEnabled :: HasOptions m => m Bool etaEnabled = optEta <$> pragmaOptions -maxInstanceSearchDepth :: TCM Int +maxInstanceSearchDepth :: HasOptions m => m Int maxInstanceSearchDepth = optInstanceSearchDepth <$> pragmaOptions -maxInversionDepth :: TCM Int +maxInversionDepth :: HasOptions m => m Int maxInversionDepth = optInversionMaxDepth <$> pragmaOptions - ------------------------------------------------------------------------- --- Verbosity - --- Invariant (which we may or may not currently break): Debug --- printouts use one of the following functions: --- --- reportS --- reportSLn --- reportSDoc - --- | Retrieve the current verbosity level. -{-# SPECIALIZE getVerbosity :: TCM (Trie String Int) #-} -getVerbosity :: HasOptions m => m (Trie String Int) -getVerbosity = optVerbose <$> pragmaOptions - -type VerboseKey = String - -parseVerboseKey :: VerboseKey -> [String] -parseVerboseKey = wordsBy (`elem` (".:" :: String)) - --- | Check whether a certain verbosity level is activated. --- --- Precondition: The level must be non-negative. -{-# SPECIALIZE hasVerbosity :: VerboseKey -> Int -> TCM Bool #-} -hasVerbosity :: HasOptions m => VerboseKey -> Int -> m Bool -hasVerbosity k n | n < 0 = __IMPOSSIBLE__ - | otherwise = do - t <- getVerbosity - let ks = parseVerboseKey k - m = last $ 0 : Trie.lookupPath ks t - return (n <= m) - --- | Check whether a certain verbosity level is activated (exact match). - -{-# SPECIALIZE hasExactVerbosity :: VerboseKey -> Int -> TCM Bool #-} -hasExactVerbosity :: HasOptions m => VerboseKey -> Int -> m Bool -hasExactVerbosity k n = - (Just n ==) . Trie.lookup (parseVerboseKey k) <$> getVerbosity - --- | Run a computation if a certain verbosity level is activated (exact match). - -{-# SPECIALIZE whenExactVerbosity :: VerboseKey -> Int -> TCM () -> TCM () #-} -whenExactVerbosity :: MonadTCM tcm => VerboseKey -> Int -> tcm () -> tcm () -whenExactVerbosity k n = whenM $ liftTCM $ hasExactVerbosity k n - --- | Run a computation if a certain verbosity level is activated. --- --- Precondition: The level must be non-negative. -{-# SPECIALIZE verboseS :: VerboseKey -> Int -> TCM () -> TCM () #-} --- {-# SPECIALIZE verboseS :: MonadIO m => VerboseKey -> Int -> TCMT m () -> TCMT m () #-} -- RULE left-hand side too complicated to desugar -{-# SPECIALIZE verboseS :: MonadTCM tcm => VerboseKey -> Int -> tcm () -> tcm () #-} -verboseS :: (MonadTCEnv m, HasOptions m) => VerboseKey -> Int -> m () -> m () -verboseS k n action = whenM (hasVerbosity k n) $ locallyTC eIsDebugPrinting (const True) action - --- | Verbosity lens. -verbosity :: VerboseKey -> Lens' Int TCState -verbosity k = stPragmaOptions . verbOpt . Trie.valueAt (parseVerboseKey k) . defaultTo 0 - where - verbOpt :: Lens' (Trie String Int) PragmaOptions - verbOpt f opts = f (optVerbose opts) <&> \ v -> opts { optVerbose = v } - - defaultTo :: Eq a => a -> Lens' a (Maybe a) - defaultTo x f m = f (fromMaybe x m) <&> \ v -> if v == x then Nothing else Just v diff --git a/src/full/Agda/TypeChecking/Monad/Options.hs-boot b/src/full/Agda/TypeChecking/Monad/Options.hs-boot deleted file mode 100644 --- a/src/full/Agda/TypeChecking/Monad/Options.hs-boot +++ /dev/null @@ -1,15 +0,0 @@ -module Agda.TypeChecking.Monad.Options where - -import Control.Monad.Reader - -import Agda.TypeChecking.Monad.Base -import Agda.Utils.FileName - -getIncludeDirs :: TCM [AbsolutePath] - -type VerboseKey = String - -hasVerbosity :: HasOptions m => VerboseKey -> Int -> m Bool -verboseS :: (MonadTCEnv m, HasOptions m) => VerboseKey -> Int -> m () -> m () - -enableCaching :: TCM Bool diff --git a/src/full/Agda/TypeChecking/Monad/Signature.hs b/src/full/Agda/TypeChecking/Monad/Signature.hs --- a/src/full/Agda/TypeChecking/Monad/Signature.hs +++ b/src/full/Agda/TypeChecking/Monad/Signature.hs @@ -1,30 +1,25 @@ {-# LANGUAGE BangPatterns #-} -{-# LANGUAGE CPP #-} {-# LANGUAGE NondecreasingIndentation #-} +{-# LANGUAGE TypeFamilies #-} -- for type equality ~ module Agda.TypeChecking.Monad.Signature where import Prelude hiding (null) -import Control.Arrow (first, second, (***)) -import Control.Applicative hiding (empty) - -#if __GLASGOW_HASKELL__ >= 800 import qualified Control.Monad.Fail as Fail -#endif import Control.Monad.State import Control.Monad.Reader import Control.Monad.Writer import Control.Monad.Trans.Maybe +import Control.Monad.Trans.Identity import qualified Data.List as List import Data.Set (Set) import qualified Data.Set as Set -import Data.Map (Map) import qualified Data.Map as Map +import qualified Data.HashMap.Strict as HMap import Data.Maybe -import Data.Monoid import Agda.Syntax.Abstract.Name import Agda.Syntax.Abstract (Ren, ScopeCopyInfo(..)) @@ -38,7 +33,6 @@ import Agda.TypeChecking.Monad.Builtin import Agda.TypeChecking.Monad.Debug import Agda.TypeChecking.Monad.Context -import Agda.TypeChecking.Monad.Options import Agda.TypeChecking.Monad.Env import Agda.TypeChecking.Monad.Mutual import Agda.TypeChecking.Monad.Open @@ -48,34 +42,35 @@ import Agda.TypeChecking.Warnings import Agda.TypeChecking.Positivity.Occurrence import Agda.TypeChecking.Substitute -import {-# SOURCE #-} Agda.TypeChecking.Telescope import Agda.TypeChecking.CompiledClause import Agda.TypeChecking.Coverage.SplitTree import {-# SOURCE #-} Agda.TypeChecking.CompiledClause.Compile import {-# SOURCE #-} Agda.TypeChecking.Polarity +import {-# SOURCE #-} Agda.TypeChecking.Pretty import {-# SOURCE #-} Agda.TypeChecking.ProjectionLike -import Agda.TypeChecking.Monad.Builtin +import {-# SOURCE #-} Agda.Compiler.Treeless.Erase + +import {-# SOURCE #-} Agda.Main + +import Agda.Utils.Either import Agda.Utils.Except ( ExceptT ) import Agda.Utils.Functor import Agda.Utils.Lens import Agda.Utils.List -import Agda.Utils.Map as Map +import Agda.Utils.ListT import Agda.Utils.Maybe import Agda.Utils.Monad import Agda.Utils.Null -import Agda.Utils.Permutation -import Agda.Utils.Pretty import Agda.Utils.Size -import qualified Agda.Utils.HashMap as HMap +import Agda.Utils.Update -#include "undefined.h" import Agda.Utils.Impossible -- | Add a constant to the signature. Lifts the definition to top level. addConstant :: QName -> Definition -> TCM () addConstant q d = do - reportSLn "tc.signature" 20 $ "adding constant " ++ prettyShow q ++ " to signature" + reportSDoc "tc.signature" 20 $ "adding constant " <+> pretty q <+> " to signature" tel <- getContextTelescope let tel' = replaceEmptyName "r" $ killRange $ case theDef d of Constructor{} -> fmap hideOrKeepInstance tel @@ -88,7 +83,7 @@ Just (doms, dom) -> telFromList $ fmap hideOrKeepInstance doms ++ [dom] _ -> tel let d' = abstract tel' $ d { defName = q } - reportSDoc "tc.signature" 60 $ return $ "lambda-lifted definition =" pretty d' + reportSDoc "tc.signature" 60 $ "lambda-lifted definition =" pretty d' modifySignature $ updateDefinitions $ HMap.insertWith (+++) q d' i <- currentOrFreshMutualBlock setMutualBlock i q @@ -126,17 +121,35 @@ addClauses :: QName -> [Clause] -> TCM () addClauses q cls = do tel <- getContextTelescope - modifySignature $ updateDefinition q $ updateTheDef - $ updateFunClauses (++ abstract tel cls) - . updateFunCopatternLHS (|| isCopatternLHS cls) + modifySignature $ updateDefinition q $ + updateTheDef (updateFunClauses (++ abstract tel cls)) + . updateDefCopatternLHS (|| isCopatternLHS cls) mkPragma :: String -> TCM CompilerPragma mkPragma s = CompilerPragma <$> getCurrentRange <*> pure s -- | Add a compiler pragma `{-\# COMPILE \#-}` addPragma :: BackendName -> QName -> String -> TCM () -addPragma b q s = modifySignature . updateDefinition q . addCompilerPragma b =<< mkPragma s +addPragma b q s = ifM erased + {- then -} (warning $ PragmaCompileErased b q) + {- else -} $ do + pragma <- mkPragma s + modifySignature $ updateDefinition q $ addCompilerPragma b pragma + where + + erased :: TCM Bool + erased = do + def <- theDef <$> getConstInfo q + case def of + -- If we have a defined symbol, we check whether it is erasable + Function{} -> + locallyTC eActiveBackendName (const $ Just b) $ + locallyTCState stBackends (const $ builtinBackends) $ + isErasable q + -- Otherwise (Axiom, Datatype, Record type, etc.) we keep it + _ -> pure False + getUniqueCompilerPragma :: BackendName -> QName -> TCM (Maybe CompilerPragma) getUniqueCompilerPragma backend q = do ps <- defCompilerPragmas backend <$> getConstInfo q @@ -145,7 +158,7 @@ [p] -> return $ Just p (_:p1:_) -> setCurrentRange p1 $ - genericDocError $ + genericDocError =<< do hang (text ("Conflicting " ++ backend ++ " pragmas for") <+> pretty q <+> "at") 2 $ vcat [ "-" <+> pretty (getRange p) | p <- ps ] @@ -183,12 +196,12 @@ if (sec == sec') then do -- Andreas, 2015-12-02: test/Succeed/Issue1701II.agda -- reports a "redundantly adding existing section". - reportSLn "tc.section" 10 $ "warning: redundantly adding existing section " ++ prettyShow m - reportSLn "tc.section" 60 $ "with content " ++ prettyShow sec + reportSDoc "tc.section" 10 $ "warning: redundantly adding existing section" <+> pretty m + reportSDoc "tc.section" 60 $ "with content" <+> pretty sec else do - reportSLn "impossible" 10 $ "overwriting existing section " ++ prettyShow m - reportSLn "impossible" 60 $ "of content " ++ prettyShow sec' - reportSLn "impossible" 60 $ "with content " ++ prettyShow sec + reportSDoc "impossible" 10 $ "overwriting existing section" <+> pretty m + reportSDoc "impossible" 60 $ "of content " <+> pretty sec' + reportSDoc "impossible" 60 $ "with content" <+> pretty sec __IMPOSSIBLE__ -- Add the new section. setModuleCheckpoint m @@ -254,27 +267,27 @@ case unSpine <$> body of Just (Def y es) -> do let df = Display m es $ DTerm $ Def top $ map Apply args - reportSLn "tc.display.section" 20 $ unlines - [ "adding display form " ++ prettyShow y ++ " --> " ++ prettyShow top - , show df + reportSDoc "tc.display.section" 20 $ vcat + [ "adding display form " <+> pretty y <+> " --> " <+> pretty top + , text (show df) ] addDisplayForm y df add args top y es - Just v -> noDispForm x $ "not a def body, but " ++ show v + Just v -> noDispForm x $ "not a def body, but " <+> pretty v Nothing -> noDispForm x $ "bad body" [] | Constructor{ conSrcCon = h } <- theDef def -> do let y = conName h df = Display 0 [] $ DTerm $ Con (h {conName = top }) ConOSystem [] - reportSLn "tc.display.section" 20 $ unlines - [ "adding display form " ++ prettyShow y ++ " --> " ++ prettyShow top - , show df + reportSDoc "tc.display.section" 20 $ vcat + [ "adding display form" <+> pretty y <+> "-->" <+> pretty top + , text (show df) ] addDisplayForm y df [] -> noDispForm x "no clauses" (_:_:_) -> noDispForm x "many clauses" - noDispForm x reason = reportSLn "tc.display.section" 30 $ - "no display form from " ++ prettyShow x ++ " because " ++ reason + noDispForm x reason = reportSDoc "tc.display.section" 30 $ + "no display form from" <+> pretty x <+> "because" <+> reason isVar VarP{} = True isVar _ = False @@ -295,31 +308,29 @@ -- and if a constructor is copied its datatype needs to be. closeConstructors :: Ren QName -> TCM (Ren QName) closeConstructors rd = do - ds <- List.nub . concat <$> mapM (constructorData . fst) rd - cs <- List.nub . concat <$> mapM (dataConstructors . fst) rd + ds <- nubOn id . catMaybes <$> mapM (constructorData . fst) rd + cs <- nubOn id . concat <$> mapM (dataConstructors . fst) rd new <- concat <$> mapM rename (ds ++ cs) - reportSLn "tc.mod.apply.complete" 30 $ - "also copying: " ++ prettyShow new + reportSDoc "tc.mod.apply.complete" 30 $ + "also copying: " <+> pretty new return $ new ++ rd where rename :: QName -> TCM (Ren QName) rename x = case lookup x rd of - Nothing -> do y <- freshName_ (prettyShow x) + Nothing -> do y <- freshName_ (show $ qnameName x) return [(x, qnameFromList [y])] Just{} -> return [] - constructorData :: QName -> TCM [QName] + constructorData :: QName -> TCM (Maybe QName) constructorData x = do - def <- theDef <$> getConstInfo x - return $ case def of - Constructor{ conData = d } -> [d] - _ -> [] + (theDef <$> getConstInfo x) <&> \case + Constructor{ conData = d } -> Just d + _ -> Nothing dataConstructors :: QName -> TCM [QName] dataConstructors x = do - def <- theDef <$> getConstInfo x - return $ case def of + (theDef <$> getConstInfo x) <&> \case Datatype{ dataCons = cs } -> cs Record{ recConHead = h } -> [conName h] _ -> [] @@ -331,7 +342,7 @@ forM_ (map fst rd) $ \ q -> do when (q `elem` noCopyList) $ typeError (TriedToCopyConstrainedPrim q) - reportSLn "tc.mod.apply" 10 $ render $ vcat + reportSDoc "tc.mod.apply" 10 $ vcat [ "applySection" , "new =" <+> pretty new , "ptel =" <+> pretty ptel @@ -354,7 +365,7 @@ argsToUse x = do let m = commonParentModule old x - reportSLn "tc.mod.apply" 80 $ "Common prefix: " ++ prettyShow m + reportSDoc "tc.mod.apply" 80 $ "Common prefix: " <+> pretty m size <$> lookupSection m copyDef :: Args -> (QName, QName) -> TCM () @@ -367,18 +378,18 @@ hidings <- map getHiding . telToList <$> lookupSection (qnameModule x) let ts' = zipWith setHiding hidings ts commonTel <- lookupSection (commonParentModule old $ qnameModule x) - reportSLn "tc.mod.apply" 80 $ init $ unlines - [ "copyDef " ++ prettyShow x ++ " -> " ++ prettyShow y - , "ts' = " ++ prettyShow ts' ] + reportSDoc "tc.mod.apply" 80 $ vcat + [ "copyDef" <+> pretty x <+> "->" <+> pretty y + , "ts' = " <+> pretty ts' ] copyDef' ts' np def where copyDef' ts np d = do - reportSLn "tc.mod.apply" 60 $ "making new def for " ++ prettyShow y ++ " from " ++ prettyShow x ++ " with " ++ show np ++ " args " ++ show (defAbstract d) - reportSLn "tc.mod.apply" 80 $ init $ unlines - [ "args = " ++ show ts' - , "old type = " ++ prettyShow (defType d) ] - reportSLn "tc.mod.apply" 80 $ - "new type = " ++ prettyShow t + reportSDoc "tc.mod.apply" 60 $ "making new def for" <+> pretty y <+> "from" <+> pretty x <+> "with" <+> text (show np) <+> "args" <+> text (show $ defAbstract d) + reportSDoc "tc.mod.apply" 80 $ vcat + [ "args = " <+> text (show ts') + , "old type = " <+> pretty (defType d) ] + reportSDoc "tc.mod.apply" 80 $ + "new type = " <+> pretty t addConstant y =<< nd y makeProjection y -- Issue1238: the copied def should be an 'instance' if the original @@ -418,9 +429,11 @@ , defCompiledRep = noCompiledRep , defInstance = inst , defCopy = True - , defMatchable = False + , defMatchable = Set.empty , defNoCompilation = defNoCompilation d , defInjective = False + , defCopatternLHS = isCopatternLHS [cl] + , defBlocked = defBlocked d , theDef = df } oldDef = theDef d isCon = case oldDef of { Constructor{} -> True ; _ -> False } @@ -458,7 +471,7 @@ } GeneralizableVar -> return GeneralizableVar _ -> do - (mst, cc) <- compileClauses Nothing [cl] -- Andreas, 2012-10-07 non need for record pattern translation + (mst, _, cc) <- compileClauses Nothing [cl] -- Andreas, 2012-10-07 non need for record pattern translation let newDef = set funMacro (oldDef ^. funMacro) $ set funStatic (oldDef ^. funStatic) $ @@ -472,9 +485,8 @@ , funTerminates = Just True , funExtLam = extlam , funWith = with - , funCopatternLHS = isCopatternLHS [cl] } - reportSDoc "tc.mod.apply" 80 $ return $ ("new def for" <+> pretty x) pretty newDef + reportSDoc "tc.mod.apply" 80 $ ("new def for" <+> pretty x) pretty newDef return newDef cl = Clause { clauseLHSRange = getRange $ defClauses d @@ -482,16 +494,19 @@ , clauseTel = EmptyTel , namedClausePats = [] , clauseBody = Just $ dropArgs pars $ case oldDef of - Function{funProjection = Just p} -> projDropParsApply p ProjSystem ts' + Function{funProjection = Just p} -> projDropParsApply p ProjSystem rel ts' _ -> Def x $ map Apply ts' , clauseType = Just $ defaultArg t , clauseCatchall = False + , clauseRecursive = Just False -- definitely not recursive , clauseUnreachable = Just False -- definitely not unreachable + , clauseEllipsis = NoEllipsis } where -- The number of remaining parameters. We need to drop the -- lambdas corresponding to these from the clause body above. pars = max 0 $ maybe 0 (pred . projIndex) proj + rel = getRelevance $ defArgInfo d {- Example @@ -528,11 +543,11 @@ totalArgs <- argsToUse x tel <- lookupSection x let sectionTel = apply tel $ take totalArgs ts - reportSLn "tc.mod.apply" 80 $ "Copying section " ++ prettyShow x ++ " to " ++ prettyShow y - reportSLn "tc.mod.apply" 80 $ " ts = " ++ List.intercalate "; " (map prettyShow ts) - reportSLn "tc.mod.apply" 80 $ " totalArgs = " ++ show totalArgs - reportSLn "tc.mod.apply" 80 $ " tel = " ++ List.intercalate " " (map (fst . unDom) $ telToList tel) -- only names - reportSLn "tc.mod.apply" 80 $ " sectionTel = " ++ List.intercalate " " (map (fst . unDom) $ telToList ptel) -- only names + reportSDoc "tc.mod.apply" 80 $ "Copying section" <+> pretty x <+> "to" <+> pretty y + reportSDoc "tc.mod.apply" 80 $ " ts = " <+> mconcat (List.intersperse "; " (map pretty ts)) + reportSDoc "tc.mod.apply" 80 $ " totalArgs = " <+> text (show totalArgs) + reportSDoc "tc.mod.apply" 80 $ " tel = " <+> text (List.intercalate " " (map (fst . unDom) $ telToList tel)) -- only names + reportSDoc "tc.mod.apply" 80 $ " sectionTel = " <+> text (List.intercalate " " (map (fst . unDom) $ telToList ptel)) -- only names addContext sectionTel $ addSection y -- | Add a display form to a definition (could be in this or imported signature). @@ -544,16 +559,16 @@ {-then-} (modifySignature add) {-else-} (stImportsDisplayForms `modifyTCLens` HMap.insertWith (++) x [d]) whenM (hasLoopingDisplayForm x) $ - typeError . GenericDocError $ "Cannot add recursive display form for" <+> pretty x + typeError . GenericDocError =<< do "Cannot add recursive display form for" <+> pretty x -isLocal :: QName -> TCM Bool -isLocal x = HMap.member x <$> useTC (stSignature . sigDefinitions) +isLocal :: ReadTCState m => QName -> m Bool +isLocal x = HMap.member x <$> useR (stSignature . sigDefinitions) -getDisplayForms :: QName -> TCM [LocalDisplayForm] +getDisplayForms :: (HasConstInfo m, ReadTCState m) => QName -> m [LocalDisplayForm] getDisplayForms q = do ds <- either (const []) defDisplay <$> getConstInfo' q - ds1 <- HMap.lookupDefault [] q <$> useTC stImportsDisplayForms - ds2 <- HMap.lookupDefault [] q <$> useTC stImportedDisplayForms + ds1 <- HMap.lookupDefault [] q <$> useR stImportsDisplayForms + ds2 <- HMap.lookupDefault [] q <$> useR stImportedDisplayForms ifM (isLocal q) (return $ ds ++ ds1 ++ ds2) (return $ ds1 ++ ds ++ ds2) @@ -572,7 +587,7 @@ hasLoopingDisplayForm :: QName -> TCM Bool hasLoopingDisplayForm q = Set.member q <$> chaseDisplayForms q -canonicalName :: QName -> TCM QName +canonicalName :: HasConstInfo m => QName -> m QName canonicalName x = do def <- theDef <$> getConstInfo x case def of @@ -585,7 +600,7 @@ extract (Def x _) = x extract _ = __IMPOSSIBLE__ -sameDef :: QName -> QName -> TCM (Maybe QName) +sameDef :: HasConstInfo m => QName -> QName -> m (Maybe QName) sameDef d1 d2 = do c1 <- canonicalName d1 c2 <- canonicalName d2 @@ -599,7 +614,7 @@ mz <- getBuiltinName' builtinIZero mo <- getBuiltinName' builtinIOne case def of - Datatype{ dataInduction = i } -> return i + Datatype{} -> return Inductive Record{} | not (recRecursive def) -> return Inductive Record{ recInduction = i } -> return $ fromMaybe Inductive i Constructor{ conInd = i } -> return i @@ -636,11 +651,7 @@ class ( Functor m , Applicative m -#if __GLASGOW_HASKELL__ < 800 - , Monad m -#else , Fail.MonadFail m -#endif , HasOptions m , MonadDebug m , MonadTCEnv m @@ -652,15 +663,27 @@ Right d -> return d Left (SigUnknown err) -> __IMPOSSIBLE_VERBOSE__ err Left SigAbstract -> __IMPOSSIBLE_VERBOSE__ $ - "Abstract, thus, not in scope: " ++ prettyShow q + "Abstract, thus, not in scope: " ++ show q -- | Version that reports exceptions: getConstInfo' :: QName -> m (Either SigError Definition) - getConstInfo' q = Right <$> getConstInfo q + -- getConstInfo' q = Right <$> getConstInfo q -- conflicts with default signature -- | Lookup the rewrite rules with the given head symbol. getRewriteRulesFor :: QName -> m RewriteRules + -- Lifting HasConstInfo through monad transformers: + + default getConstInfo' + :: (HasConstInfo n, MonadTrans t, m ~ t n) + => QName -> m (Either SigError Definition) + getConstInfo' = lift . getConstInfo' + + default getRewriteRulesFor + :: (HasConstInfo n, MonadTrans t, m ~ t n) + => QName -> m RewriteRules + getRewriteRulesFor = lift . getRewriteRulesFor + {-# SPECIALIZE getConstInfo :: QName -> TCM Definition #-} defaultGetRewriteRulesFor :: (Monad m) => m TCState -> QName -> m RewriteRules @@ -685,7 +708,7 @@ getConstInfo q = getConstInfo' q >>= \case Right d -> return d Left (SigUnknown err) -> fail err - Left SigAbstract -> notInScope $ qnameToConcrete q + Left SigAbstract -> notInScopeError $ qnameToConcrete q defaultGetConstInfo :: (HasOptions m, MonadDebug m, MonadTCEnv m) @@ -694,9 +717,9 @@ let defs = st^.(stSignature . sigDefinitions) idefs = st^.(stImports . sigDefinitions) case catMaybes [HMap.lookup q defs, HMap.lookup q idefs] of - [] -> return $ Left $ SigUnknown $ "Unbound name: " ++ prettyShow q ++ " " ++ showQNameId q + [] -> return $ Left $ SigUnknown $ "Unbound name: " ++ show q ++ showQNameId q [d] -> mkAbs env d - ds -> __IMPOSSIBLE_VERBOSE__ $ "Ambiguous name: " ++ prettyShow q + ds -> __IMPOSSIBLE_VERBOSE__ $ "Ambiguous name: " ++ show q where mkAbs env d | treatAbstractly' q' env = @@ -716,49 +739,41 @@ dropLastModule q@QName{ qnameModule = m } = q{ qnameModule = mnameFromList $ ifNull (mnameToList m) __IMPOSSIBLE__ init } -instance HasConstInfo m => HasConstInfo (MaybeT m) where - getConstInfo' = lift . getConstInfo' - getRewriteRulesFor = lift . getRewriteRulesFor - -instance HasConstInfo m => HasConstInfo (ExceptT err m) where - getConstInfo' = lift . getConstInfo' - getRewriteRulesFor = lift . getRewriteRulesFor - -instance HasConstInfo m => HasConstInfo (ReaderT r m) where - getConstInfo' = lift . getConstInfo' - getRewriteRulesFor = lift . getRewriteRulesFor - -instance (Monoid w, HasConstInfo m) => HasConstInfo (WriterT w m) where - getConstInfo' = lift . getConstInfo' - getRewriteRulesFor = lift . getRewriteRulesFor +-- HasConstInfo lifts through monad transformers +-- (see default signatures in HasConstInfo class). -instance HasConstInfo m => HasConstInfo (StateT s m) where - getConstInfo' = lift . getConstInfo' - getRewriteRulesFor = lift . getRewriteRulesFor +instance HasConstInfo m => HasConstInfo (ChangeT m) +instance HasConstInfo m => HasConstInfo (ExceptT err m) +instance HasConstInfo m => HasConstInfo (IdentityT m) +instance HasConstInfo m => HasConstInfo (ListT m) +instance HasConstInfo m => HasConstInfo (MaybeT m) +instance HasConstInfo m => HasConstInfo (ReaderT r m) +instance HasConstInfo m => HasConstInfo (StateT s m) +instance (Monoid w, HasConstInfo m) => HasConstInfo (WriterT w m) {-# INLINE getConInfo #-} getConInfo :: HasConstInfo m => ConHead -> m Definition getConInfo = getConstInfo . conName -- | Look up the polarity of a definition. -getPolarity :: QName -> TCM [Polarity] +getPolarity :: HasConstInfo m => QName -> m [Polarity] getPolarity q = defPolarity <$> getConstInfo q -- | Look up polarity of a definition and compose with polarity -- represented by 'Comparison'. -getPolarity' :: Comparison -> QName -> TCM [Polarity] +getPolarity' :: HasConstInfo m => Comparison -> QName -> m [Polarity] getPolarity' CmpEq q = map (composePol Invariant) <$> getPolarity q -- return [] getPolarity' CmpLeq q = getPolarity q -- composition with Covariant is identity -- | Set the polarity of a definition. setPolarity :: QName -> [Polarity] -> TCM () setPolarity q pol = do - reportSLn "tc.polarity.set" 20 $ - "Setting polarity of " ++ prettyShow q ++ " to " ++ prettyShow pol ++ "." + reportSDoc "tc.polarity.set" 20 $ + "Setting polarity of" <+> pretty q <+> "to" <+> pretty pol <> "." modifySignature $ updateDefinition q $ updateDefPolarity $ const pol -- | Look up the forced arguments of a definition. -getForcedArgs :: QName -> TCM [IsForced] +getForcedArgs :: HasConstInfo m => QName -> m [IsForced] getForcedArgs q = defForced <$> getConstInfo q -- | Get argument occurrence info for argument @i@ of definition @d@ (never fails). @@ -797,16 +812,21 @@ Function{ funTreeless = t } -> t _ -> Nothing +-- | Returns a list of length 'conArity'. +-- If no erasure analysis has been performed yet, this will be a list of 'False's. getErasedConArgs :: QName -> TCM [Bool] getErasedConArgs q = do def <- getConstInfo q case theDef def of - Constructor{ conData = d, conPars = np, conErased = es } -> return es + Constructor{ conArity, conErased } -> return $ + fromMaybe (replicate conArity False) conErased _ -> __IMPOSSIBLE__ setErasedConArgs :: QName -> [Bool] -> TCM () setErasedConArgs q args = modifyGlobalDefinition q $ updateTheDef $ \case - def@Constructor{} -> def{ conErased = args } + def@Constructor{ conArity } + | length args == conArity -> def{ conErased = Just args } + | otherwise -> __IMPOSSIBLE__ def -> def -- no-op for non-constructors getTreeless :: QName -> TCM (Maybe TTerm) @@ -859,12 +879,12 @@ -- For annoying reasons the qnameModule of a pattern lambda is not correct -- (#2883), so make sure to grab the right module for those. -getDefModule :: HasConstInfo m => QName -> m ModuleName -getDefModule f = do - def <- getConstInfo f - return $ case theDef def of - Function{ funExtLam = Just (ExtLamInfo m _) } -> m - _ -> qnameModule f +getDefModule :: HasConstInfo m => QName -> m (Either SigError ModuleName) +getDefModule f = mapRight modName <$> getConstInfo' f + where + modName def = case theDef def of + Function{ funExtLam = Just (ExtLamInfo m _) } -> m + _ -> qnameModule f -- | Compute the number of free variables of a defined name. This is the sum of -- number of parameters shared with the current module and the number of @@ -908,22 +928,30 @@ MonadTCEnv m, ReadTCState m, MonadDebug m) => ModuleName -> m Args moduleParamsToApply m = do - -- Get the correct number of free variables (correctly raised) of @m@. - reportSLn "tc.sig.param" 90 $ "computing module parameters of " ++ prettyShow m + traceSDoc "tc.sig.param" 90 ("computing module parameters of " <+> pretty m) $ do + + -- Jesper, 2020-01-22: If the module parameter substitution for the + -- module cannot be found, that likely means we are within a call to + -- @inTopContext@. In that case we should provide no arguments for + -- the module parameters (see #4383). + caseMaybeM (getModuleParameterSub m) (return []) $ \sub -> do + + traceSDoc "tc.sig.param" 60 (do + cxt <- getContext + nest 2 $ vcat + [ "cxt = " <+> prettyTCM (PrettyContext cxt) + , "sub = " <+> pretty sub + ]) $ do + + -- Get the correct number of free variables (correctly raised) of @m@. n <- getModuleFreeVars m + traceSDoc "tc.sig.param" 60 (nest 2 $ "n = " <+> text (show n)) $ do tel <- take n . telToList <$> lookupSection m - sub <- getModuleParameterSub m - verboseS "tc.sig.param" 60 $ do - cxt <- getContext - reportSLn "tc.sig.param" 60 $ unlines $ - [ " n = " ++ show n - , " cxt = " ++ show (map (fmap fst) cxt) - , " sub = " ++ show sub - ] + traceSDoc "tc.sig.param" 60 (nest 2 $ "tel = " <+> pretty tel) $ do unless (size tel == n) __IMPOSSIBLE__ let args = applySubst sub $ zipWith (\ i a -> var i <$ argFromDom a) (downFrom n) tel - reportSLn "tc.sig.param" 60 $ " args = " ++ show args + traceSDoc "tc.sig.param" 60 (nest 2 $ "args = " <+> prettyList_ (map pretty args)) $ do -- Apply the original ArgInfo, as the hiding information in the current -- context might be different from the hiding information expected by @m@. @@ -950,8 +978,8 @@ -- sure generated definitions work properly. inFreshModuleIfFreeParams :: TCM a -> TCM a inFreshModuleIfFreeParams k = do - sub <- getModuleParameterSub =<< currentModule - if sub == IdS then k else do + msub <- getModuleParameterSub =<< currentModule + if msub == Nothing || msub == Just IdS then k else do m <- currentModule m' <- qualifyM m . mnameFromList . (:[]) <$> freshName_ ("_" :: String) @@ -970,16 +998,16 @@ verboseS "tc.sig.inst" 30 $ do ctx <- getContext m <- currentModule - reportSLn "tc.sig.inst" 30 $ - "instDef in " ++ prettyShow m ++ ": " ++ prettyShow (defName d) ++ " " ++ - unwords (map show $ zipWith (<$) (reverse $ map (fst . unDom) ctx) vs) + reportSDoc "tc.sig.inst" 30 $ + "instDef in" <+> pretty m <> ":" <+> pretty (defName d) <+> + text (unwords $ map show $ zipWith (<$) (reverse $ map (fst . unDom) ctx) vs) return $ d `apply` vs instantiateRewriteRule :: (Functor m, HasConstInfo m, HasOptions m, ReadTCState m, MonadTCEnv m, MonadDebug m) => RewriteRule -> m RewriteRule instantiateRewriteRule rew = do - traceSLn "rewriting" 95 ("instantiating rewrite rule " ++ show (rewName rew) ++ " to the local context.") $ do + traceSDoc "rewriting" 95 ("instantiating rewrite rule" <+> pretty (rewName rew) <+> "to the local context.") $ do vs <- freeVarsToApply $ rewName rew let rew' = rew `apply` vs traceSLn "rewriting" 95 ("instantiated rewrite rule: ") $ do @@ -1064,7 +1092,7 @@ treatAbstractly' q env = case envAbstractMode env of ConcreteMode -> True IgnoreAbstractMode -> False - AbstractMode -> not $ current == m || current `isSubModuleOf` m + AbstractMode -> not $ current `isLeChildModuleOf` m where current = dropAnon $ envCurrentModule env m = dropAnon $ qnameModule q @@ -1072,19 +1100,18 @@ -- | Get type of a constant, instantiated to the current context. {-# SPECIALIZE typeOfConst :: QName -> TCM Type #-} -typeOfConst - :: ( Functor m, HasConstInfo m, HasOptions m - , ReadTCState m, MonadTCEnv m, MonadDebug m ) - => QName -> m Type +typeOfConst :: (HasConstInfo m, ReadTCState m) => QName -> m Type typeOfConst q = defType <$> (instantiateDef =<< getConstInfo q) -- | Get relevance of a constant. -relOfConst :: QName -> TCM Relevance -relOfConst q = defRelevance <$> getConstInfo q +{-# SPECIALIZE relOfConst :: QName -> TCM Relevance #-} +relOfConst :: HasConstInfo m => QName -> m Relevance +relOfConst q = getRelevance <$> getConstInfo q -- | Get modality of a constant. -modalityOfConst :: QName -> TCM Modality -modalityOfConst q = getModality . defArgInfo <$> getConstInfo q +{-# SPECIALIZE modalityOfConst :: QName -> TCM Modality #-} +modalityOfConst :: HasConstInfo m => QName -> m Modality +modalityOfConst q = getModality <$> getConstInfo q -- | The number of dropped parameters for a definition. -- 0 except for projection(-like) functions and constructors. @@ -1131,12 +1158,8 @@ projectionArgs = maybe 0 (max 0 . pred . projIndex) . isProjection_ -- | Check whether a definition uses copatterns. -usesCopatterns :: QName -> TCM Bool -usesCopatterns q = do - d <- theDef <$> getConstInfo q - return $ case d of - Function{ funCopatternLHS = b } -> b - _ -> False +usesCopatterns :: (HasConstInfo m) => QName -> m Bool +usesCopatterns q = defCopatternLHS <$> getConstInfo q -- | Apply a function @f@ to its first argument, producing the proper -- postfix projection if @f@ is a projection. diff --git a/src/full/Agda/TypeChecking/Monad/Signature.hs-boot b/src/full/Agda/TypeChecking/Monad/Signature.hs-boot --- a/src/full/Agda/TypeChecking/Monad/Signature.hs-boot +++ b/src/full/Agda/TypeChecking/Monad/Signature.hs-boot @@ -1,18 +1,16 @@ -{-# LANGUAGE CPP #-} +{-# LANGUAGE TypeFamilies #-} -- for type equality ~ module Agda.TypeChecking.Monad.Signature where -#if __GLASGOW_HASKELL__ >= 800 import qualified Control.Monad.Fail as Fail -#endif - import Control.Monad.Reader +import Control.Monad.State import Agda.Syntax.Abstract.Name (QName) import Agda.Syntax.Internal (ModuleName, Telescope) import Agda.TypeChecking.Monad.Base - ( TCM, ReadTCState, HasOptions, TCEnv, MonadTCEnv + ( TCM, ReadTCState, HasOptions, MonadTCEnv , Definition, RewriteRules ) import Agda.TypeChecking.Monad.Debug (MonadDebug) @@ -23,11 +21,7 @@ class ( Functor m , Applicative m -#if __GLASGOW_HASKELL__ < 800 - , Monad m -#else , Fail.MonadFail m -#endif , HasOptions m , MonadDebug m , MonadTCEnv m @@ -39,8 +33,19 @@ Left SigAbstract -> __IMPOSSIBLE_VERBOSE__ $ "Abstract, thus, not in scope: " ++ prettyShow q getConstInfo' :: QName -> m (Either SigError Definition) - getConstInfo' q = Right <$> getConstInfo q + -- getConstInfo' q = Right <$> getConstInfo q getRewriteRulesFor :: QName -> m RewriteRules + + default getConstInfo' :: (HasConstInfo n, MonadTrans t, m ~ t n) => QName -> m (Either SigError Definition) + getConstInfo' = lift . getConstInfo' + + default getRewriteRulesFor :: (HasConstInfo n, MonadTrans t, m ~ t n) => QName -> m RewriteRules + getRewriteRulesFor = lift . getRewriteRulesFor + +instance HasConstInfo m => HasConstInfo (ReaderT r m) +instance HasConstInfo m => HasConstInfo (StateT s m) + +instance HasConstInfo TCM where inFreshModuleIfFreeParams :: TCM a -> TCM a lookupSection :: (Functor m, ReadTCState m) => ModuleName -> m Telescope diff --git a/src/full/Agda/TypeChecking/Monad/SizedTypes.hs b/src/full/Agda/TypeChecking/Monad/SizedTypes.hs --- a/src/full/Agda/TypeChecking/Monad/SizedTypes.hs +++ b/src/full/Agda/TypeChecking/Monad/SizedTypes.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} -- | Stuff for sized types that does not require modules -- "Agda.TypeChecking.Reduce" or "Agda.TypeChecking.Constraints" @@ -7,30 +6,25 @@ module Agda.TypeChecking.Monad.SizedTypes where import qualified Data.Foldable as Fold +import Data.List.NonEmpty (NonEmpty(..)) +import qualified Data.List.NonEmpty as NonEmpty import qualified Data.Traversable as Trav -import Agda.Interaction.Options - import Agda.Syntax.Common import Agda.Syntax.Internal import Agda.TypeChecking.Monad.Base -import Agda.TypeChecking.Monad.Debug -import Agda.TypeChecking.Monad.Options import Agda.TypeChecking.Monad.Builtin import Agda.TypeChecking.Monad.State import Agda.TypeChecking.Positivity.Occurrence -import Agda.TypeChecking.Substitute () import Agda.Utils.Except ( MonadError(catchError) ) import Agda.Utils.List import Agda.Utils.Maybe import Agda.Utils.Monad -import Agda.Utils.NonemptyList import Agda.Utils.Pretty import Agda.Utils.Singleton -#include "undefined.h" import Agda.Utils.Impossible ------------------------------------------------------------------------ @@ -46,7 +40,7 @@ -- | Check if a type is the 'primSize' type. The argument should be 'reduce'd. class IsSizeType a where - isSizeType :: a -> TCM (Maybe BoundedSize) + isSizeType :: (HasOptions m, HasBuiltins m) => a -> m (Maybe BoundedSize) instance IsSizeType a => IsSizeType (Dom a) where isSizeType = isSizeType . unDom @@ -60,7 +54,12 @@ instance IsSizeType Term where isSizeType v = isSizeTypeTest <*> pure v -isSizeTypeTest :: TCM (Term -> Maybe BoundedSize) +instance IsSizeType CompareAs where + isSizeType (AsTermsOf a) = isSizeType a + isSizeType AsSizes = return $ Just BoundedNo + isSizeType AsTypes = return Nothing + +isSizeTypeTest :: (HasOptions m, HasBuiltins m) => m (Term -> Maybe BoundedSize) isSizeTypeTest = flip (ifM sizedTypesOption) (return $ const Nothing) $ do (size, sizelt) <- getBuiltinSize @@ -69,24 +68,24 @@ testType _ = Nothing return testType -getBuiltinDefName :: String -> TCM (Maybe QName) +getBuiltinDefName :: (HasBuiltins m) => String -> m (Maybe QName) getBuiltinDefName s = fromDef <$> getBuiltin' s where fromDef (Just (Def d [])) = Just d fromDef _ = Nothing -getBuiltinSize :: TCM (Maybe QName, Maybe QName) +getBuiltinSize :: (HasBuiltins m) => m (Maybe QName, Maybe QName) getBuiltinSize = do size <- getBuiltinDefName builtinSize sizelt <- getBuiltinDefName builtinSizeLt return (size, sizelt) -isSizeNameTest :: TCM (QName -> Bool) +isSizeNameTest :: (HasOptions m, HasBuiltins m) => m (QName -> Bool) isSizeNameTest = ifM sizedTypesOption isSizeNameTestRaw (return $ const False) -isSizeNameTestRaw :: TCM (QName -> Bool) +isSizeNameTestRaw :: (HasOptions m, HasBuiltins m) => m (QName -> Bool) isSizeNameTestRaw = do (size, sizelt) <- getBuiltinSize return $ (`elem` [size, sizelt]) . Just @@ -140,21 +139,22 @@ sizeType_ size = El sizeSort $ Def size [] -- | The built-in type @SIZE@. -sizeType :: TCM Type -sizeType = El sizeSort <$> primSize +sizeType :: (HasBuiltins m, MonadTCEnv m, ReadTCState m) => m Type +sizeType = El sizeSort . fromMaybe __IMPOSSIBLE__ <$> getBuiltin' builtinSize -- | The name of @SIZESUC@. -sizeSucName :: TCM (Maybe QName) +sizeSucName :: (HasBuiltins m, HasOptions m) => m (Maybe QName) sizeSucName = do - ifM (not <$> sizedTypesOption) (return Nothing) $ tryMaybe $ do - Def x [] <- primSizeSuc - return x + ifM (not <$> sizedTypesOption) (return Nothing) $ do + getBuiltin' builtinSizeSuc >>= \case + Just (Def x []) -> return $ Just x + _ -> return Nothing -sizeSuc :: Nat -> Term -> TCM Term +sizeSuc :: HasBuiltins m => Nat -> Term -> m Term sizeSuc n v | n < 0 = __IMPOSSIBLE__ | n == 0 = return v | otherwise = do - Def suc [] <- primSizeSuc + Def suc [] <- fromMaybe __IMPOSSIBLE__ <$> getBuiltin' builtinSizeSuc return $ case iterate (sizeSuc_ suc) v !!! n of Nothing -> __IMPOSSIBLE__ Just t -> t @@ -163,9 +163,10 @@ sizeSuc_ suc v = Def suc [Apply $ defaultArg v] -- | Transform list of terms into a term build from binary maximum. -sizeMax :: NonemptyList Term -> TCM Term +sizeMax :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) + => NonEmpty Term -> m Term sizeMax vs = case vs of - v :! [] -> return v + v :| [] -> return v vs -> do Def max [] <- primSizeMax return $ foldr1 (\ u v -> Def max $ map (Apply . defaultArg) [u,v]) vs @@ -179,7 +180,8 @@ data SizeView = SizeInf | SizeSuc Term | OtherSize Term -- | Expects argument to be 'reduce'd. -sizeView :: Term -> TCM SizeView +sizeView :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) + => Term -> m SizeView sizeView v = do Def inf [] <- primSizeInf Def suc [] <- primSizeSuc @@ -259,7 +261,8 @@ unSizeView (SizeSuc v) = sizeSuc 1 v unSizeView (OtherSize v) = return v -unDeepSizeView :: DeepSizeView -> TCM Term +unDeepSizeView :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) + => DeepSizeView -> m Term unDeepSizeView v = case v of DSizeInf -> primSizeInf DSizeVar i n -> sizeSuc n $ var i @@ -270,37 +273,38 @@ -- * View on sizes where maximum is pulled to the top ------------------------------------------------------------------------ -type SizeMaxView = NonemptyList DeepSizeView +type SizeMaxView = NonEmpty DeepSizeView type SizeMaxView' = [DeepSizeView] maxViewMax :: SizeMaxView -> SizeMaxView -> SizeMaxView maxViewMax v w = case (v,w) of - (DSizeInf :! _, _) -> singleton DSizeInf - (_, DSizeInf :! _) -> singleton DSizeInf + (DSizeInf :| _, _) -> singleton DSizeInf + (_, DSizeInf :| _) -> singleton DSizeInf _ -> Fold.foldr maxViewCons w v -- | @maxViewCons v ws = max v ws@. It only adds @v@ to @ws@ if it is not -- subsumed by an element of @ws@. maxViewCons :: DeepSizeView -> SizeMaxView -> SizeMaxView -maxViewCons _ (DSizeInf :! _) = singleton DSizeInf +maxViewCons _ (DSizeInf :| _) = singleton DSizeInf maxViewCons DSizeInf _ = singleton DSizeInf maxViewCons v ws = case sizeViewComparableWithMax v ws of - NotComparable -> consNe v ws - YesAbove _ ws' -> v :! ws' + NotComparable -> NonEmpty.cons v ws + YesAbove _ ws' -> v :| ws' YesBelow{} -> ws -- | @sizeViewComparableWithMax v ws@ tries to find @w@ in @ws@ that compares with @v@ -- and singles this out. -- Precondition: @v /= DSizeInv@. sizeViewComparableWithMax :: DeepSizeView -> SizeMaxView -> SizeViewComparable SizeMaxView' -sizeViewComparableWithMax v (w :! ws) = +sizeViewComparableWithMax v (w :| ws) = case (ws, sizeViewComparable v w) of - (w':ws', NotComparable) -> fmap (w:) $ sizeViewComparableWithMax v (w' :! ws') + (w':ws', NotComparable) -> fmap (w:) $ sizeViewComparableWithMax v (w' :| ws') (ws , r) -> fmap (const ws) r maxViewSuc_ :: QName -> SizeMaxView -> SizeMaxView maxViewSuc_ suc = fmap (sizeViewSuc_ suc) -unMaxView :: SizeMaxView -> TCM Term +unMaxView :: (HasBuiltins m, MonadError TCErr m, MonadTCEnv m, ReadTCState m) + => SizeMaxView -> m Term unMaxView vs = sizeMax =<< Trav.mapM unDeepSizeView vs diff --git a/src/full/Agda/TypeChecking/Monad/State.hs b/src/full/Agda/TypeChecking/Monad/State.hs --- a/src/full/Agda/TypeChecking/Monad/State.hs +++ b/src/full/Agda/TypeChecking/Monad/State.hs @@ -1,27 +1,28 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE BangPatterns #-} -- | Lenses for 'TCState' and more. module Agda.TypeChecking.Monad.State where -import Control.Arrow (first) + import qualified Control.Exception as E -import Control.Monad.Reader (asks) -import Control.Monad.State (put, get, gets, modify, modify', void) + +import Control.Monad.State (void) import Control.Monad.Trans (liftIO) import Data.Maybe -import Data.Map (Map) + import qualified Data.Map as Map -import Data.Monoid + +import Data.List.NonEmpty (NonEmpty(..)) +import qualified Data.List.NonEmpty as NonEmpty import Data.Set (Set) import qualified Data.Set as Set +import qualified Data.HashMap.Strict as HMap import Data.Traversable (traverse) import Agda.Benchmarking --- import {-# SOURCE #-} Agda.Interaction.Response import Agda.Interaction.Response (InteractionOutputCallback, Response) @@ -35,20 +36,17 @@ import Agda.TypeChecking.Monad.Base import Agda.TypeChecking.Warnings -import {-# SOURCE #-} Agda.TypeChecking.Monad.Debug -import {-# SOURCE #-} Agda.TypeChecking.Monad.Options + +import Agda.TypeChecking.Monad.Debug (reportSDoc, reportSLn, verboseS) import Agda.TypeChecking.Positivity.Occurrence import Agda.TypeChecking.CompiledClause import Agda.Utils.Hash -import qualified Agda.Utils.HashMap as HMap import Agda.Utils.Lens import Agda.Utils.Monad (bracket_) -import Agda.Utils.NonemptyList import Agda.Utils.Pretty import Agda.Utils.Tuple -#include "undefined.h" import Agda.Utils.Impossible -- | Resets the non-persistent part of the type checking state. @@ -93,6 +91,13 @@ modifyBenchmark $ const b return (result, newState) +-- | Same as 'localTCState' but keep all warnings. +localTCStateSavingWarnings :: TCM a -> TCM a +localTCStateSavingWarnings compute = do + (result, newState) <- localTCStateSaving compute + modifyTC $ over stTCWarnings $ const $ newState ^. stTCWarnings + return result + data SpeculateResult = SpeculateAbort | SpeculateCommit -- | Allow rolling back the state changes of a TCM computation. @@ -161,33 +166,35 @@ --------------------------------------------------------------------------- -- | Get the current scope. -getScope :: TCM ScopeInfo -getScope = useTC stScope +getScope :: ReadTCState m => m ScopeInfo +getScope = useR stScope -- | Set the current scope. setScope :: ScopeInfo -> TCM () setScope scope = modifyScope (const scope) -- | Modify the current scope without updating the inverse maps. -modifyScope_ :: (ScopeInfo -> ScopeInfo) -> TCM () +modifyScope_ :: MonadTCState m => (ScopeInfo -> ScopeInfo) -> m () modifyScope_ f = stScope `modifyTCLens` f -- | Modify the current scope. -modifyScope :: (ScopeInfo -> ScopeInfo) -> TCM () +modifyScope :: MonadTCState m => (ScopeInfo -> ScopeInfo) -> m () modifyScope f = modifyScope_ (recomputeInverseScopeMaps . f) +-- | Get a part of the current scope. +useScope :: ReadTCState m => Lens' a ScopeInfo -> m a +useScope l = useR $ stScope . l + +-- | Run a computation in a modified scope. +locallyScope :: ReadTCState m => Lens' a ScopeInfo -> (a -> a) -> m b -> m b +locallyScope l = locallyTCState $ stScope . l + -- | Run a computation in a local scope. -withScope :: ScopeInfo -> TCM a -> TCM (a, ScopeInfo) -withScope s m = do - s' <- getScope - setScope s - x <- m - s'' <- getScope - setScope s' - return (x, s'') +withScope :: ReadTCState m => ScopeInfo -> m a -> m (a, ScopeInfo) +withScope s m = locallyTCState stScope (recomputeInverseScopeMaps . const s) $ (,) <$> m <*> getScope -- | Same as 'withScope', but discard the scope from the computation. -withScope_ :: ScopeInfo -> TCM a -> TCM a +withScope_ :: ReadTCState m => ScopeInfo -> m a -> m a withScope_ s m = fst <$> withScope s m -- | Discard any changes to the scope by a computation. @@ -199,11 +206,16 @@ return x -- | Scope error. -notInScope :: C.QName -> TCM a -notInScope x = do +notInScopeError :: C.QName -> TCM a +notInScopeError x = do printScope "unbound" 5 "" typeError $ NotInScope [x] +notInScopeWarning :: C.QName -> TCM () +notInScopeWarning x = do + printScope "unbound" 5 "" + warning $ NotInScopeW [x] + -- | Debug print the scope. printScope :: String -> Int -> String -> TCM () printScope tag v s = verboseS ("scope." ++ tag) v $ do @@ -222,8 +234,8 @@ modifyImportedSignature :: (Signature -> Signature) -> TCM () modifyImportedSignature f = stImports `modifyTCLens` f -getSignature :: TCM Signature -getSignature = useTC stSignature +getSignature :: ReadTCState m => m Signature +getSignature = useR stSignature -- | Update a possibly imported definition. Warning: changes made to imported -- definitions (during type checking) will not persist outside the current @@ -250,14 +262,23 @@ addRewriteRulesFor :: QName -> RewriteRules -> [QName] -> Signature -> Signature addRewriteRulesFor f rews matchables = (over sigRewriteRules $ HMap.insertWith mappend f rews) - . (updateDefinition f $ updateTheDef setNotInjective) - . (foldr (.) id $ map (\g -> updateDefinition g setMatchable) matchables) + . (updateDefinition f $ updateTheDef setNotInjective . setCopatternLHS) + . (setMatchableSymbols f matchables) where setNotInjective def@Function{} = def { funInv = NotInjective } setNotInjective def = def - setMatchable def = def { defMatchable = True } + setCopatternLHS = + updateDefCopatternLHS (|| any hasProjectionPattern rews) + hasProjectionPattern rew = any (isJust . isProjElim) $ rewPats rew + +setMatchableSymbols :: QName -> [QName] -> Signature -> Signature +setMatchableSymbols f matchables = + foldr (.) id $ map (\g -> updateDefinition g $ setMatchable) matchables + where + setMatchable def = def { defMatchable = Set.insert f $ defMatchable def } + -- ** Modifiers for parts of the signature lookupDefinition :: QName -> Signature -> Maybe Definition @@ -291,7 +312,7 @@ updateFunClauses f def@Function{ funClauses = cs} = def { funClauses = f cs } updateFunClauses f _ = __IMPOSSIBLE__ -updateCovering :: ([Closure Clause] -> [Closure Clause]) -> (Defn -> Defn) +updateCovering :: ([Clause] -> [Clause]) -> (Defn -> Defn) updateCovering f def@Function{ funCovering = cs} = def { funCovering = f cs } updateCovering f _ = __IMPOSSIBLE__ @@ -299,10 +320,12 @@ updateCompiledClauses f def@Function{ funCompiled = cc} = def { funCompiled = f cc } updateCompiledClauses f _ = __IMPOSSIBLE__ -updateFunCopatternLHS :: (Bool -> Bool) -> Defn -> Defn -updateFunCopatternLHS f def@Function{ funCopatternLHS = b } = def { funCopatternLHS = f b } -updateFunCopatternLHS f _ = __IMPOSSIBLE__ +updateDefCopatternLHS :: (Bool -> Bool) -> Definition -> Definition +updateDefCopatternLHS f def@Defn{ defCopatternLHS = b } = def { defCopatternLHS = f b } +updateDefBlocked :: (Blocked_ -> Blocked_) -> Definition -> Definition +updateDefBlocked f def@Defn{ defBlocked = b } = def { defBlocked = f b } + --------------------------------------------------------------------------- -- * Top level module --------------------------------------------------------------------------- @@ -355,8 +378,8 @@ -- * Pattern synonyms --------------------------------------------------------------------------- -getPatternSyns :: TCM PatternSynDefns -getPatternSyns = useTC stPatternSyns +getPatternSyns :: ReadTCState m => m PatternSynDefns +getPatternSyns = useR stPatternSyns setPatternSyns :: PatternSynDefns -> TCM () setPatternSyns m = modifyPatternSyns (const m) @@ -365,11 +388,11 @@ modifyPatternSyns :: (PatternSynDefns -> PatternSynDefns) -> TCM () modifyPatternSyns f = stPatternSyns `modifyTCLens` f -getPatternSynImports :: TCM PatternSynDefns -getPatternSynImports = useTC stPatternSynImports +getPatternSynImports :: ReadTCState m => m PatternSynDefns +getPatternSynImports = useR stPatternSynImports -- | Get both local and imported pattern synonyms -getAllPatternSyns :: TCM PatternSynDefns +getAllPatternSyns :: ReadTCState m => m PatternSynDefns getAllPatternSyns = Map.union <$> getPatternSyns <*> getPatternSynImports lookupPatternSyn :: AmbiguousQName -> TCM PatternSynDefn @@ -377,7 +400,7 @@ defs <- traverse lookupSinglePatternSyn xs case mergePatternSynDefs defs of Just def -> return def - Nothing -> typeError $ CannotResolveAmbiguousPatternSynonym (zipNe xs defs) + Nothing -> typeError $ CannotResolveAmbiguousPatternSynonym (NonEmpty.zip xs defs) lookupSinglePatternSyn :: QName -> TCM PatternSynDefn lookupSinglePatternSyn x = do @@ -388,7 +411,7 @@ si <- getPatternSynImports case Map.lookup x si of Just d -> return d - Nothing -> notInScope $ qnameToConcrete x + Nothing -> notInScopeError $ qnameToConcrete x --------------------------------------------------------------------------- -- * Benchmark diff --git a/src/full/Agda/TypeChecking/Monad/Statistics.hs b/src/full/Agda/TypeChecking/Monad/Statistics.hs --- a/src/full/Agda/TypeChecking/Monad/Statistics.hs +++ b/src/full/Agda/TypeChecking/Monad/Statistics.hs @@ -1,67 +1,89 @@ -- | Collect statistics. +{-# LANGUAGE DefaultSignatures #-} +{-# LANGUAGE TypeFamilies #-} -- for type equality + module Agda.TypeChecking.Monad.Statistics - ( tick, tickN, tickMax, getStatistics, modifyStatistics, printStatistics + ( MonadStatistics(..), tick, tickN, tickMax, getStatistics, modifyStatistics, printStatistics ) where -import qualified Data.Map as Map import Control.DeepSeq +import Control.Monad.Except +import Control.Monad.Reader +import Control.Monad.State +import Control.Monad.Writer +import Control.Monad.Trans +import Control.Monad.Trans.Maybe +import qualified Data.Map as Map import qualified Text.PrettyPrint.Boxes as Boxes import Agda.Syntax.Concrete.Name as C import Agda.TypeChecking.Monad.Base import Agda.TypeChecking.Monad.Debug -import Agda.TypeChecking.Monad.Options -import Agda.Utils.Lens import Agda.Utils.Maybe import Agda.Utils.Null import Agda.Utils.Pretty import Agda.Utils.String +class ReadTCState m => MonadStatistics m where + modifyCounter :: String -> (Integer -> Integer) -> m () + + default modifyCounter + :: (MonadStatistics n, MonadTrans t, t n ~ m) + => String -> (Integer -> Integer) -> m () + modifyCounter x = lift . modifyCounter x + +instance MonadStatistics m => MonadStatistics (ExceptT e m) +instance MonadStatistics m => MonadStatistics (MaybeT m) +instance MonadStatistics m => MonadStatistics (ReaderT r m) +instance MonadStatistics m => MonadStatistics (StateT s m) +instance (MonadStatistics m, Monoid w) => MonadStatistics (WriterT w m) + +instance MonadStatistics TCM where + modifyCounter x f = modifyStatistics $ force . update + where + -- We need to be strict in the map. + -- Andreas, 2014-03-22: Could we take Data.Map.Strict instead of this hack? + -- Or force the map by looking up the very element we inserted? + -- force m = Map.lookup x m `seq` m + -- Or use insertLookupWithKey? + -- update m = old `seq` m' where + -- (old, m') = Map.insertLookupWithKey (\ _ new old -> f old) x dummy m + -- Ulf, 2018-04-10: Neither of these approaches are strict enough in the + -- map (nor are they less hacky). It's not enough to be strict in the + -- values stored in the map, we also need to be strict in the *structure* + -- of the map. A less hacky solution is to deepseq the map. + force m = rnf m `seq` m + update = Map.insertWith (\ new old -> f old) x dummy + dummy = f 0 + -- | Get the statistics. -getStatistics :: TCM Statistics -getStatistics = useTC stStatistics +getStatistics :: ReadTCState m => m Statistics +getStatistics = useR stStatistics -- | Modify the statistics via given function. modifyStatistics :: (Statistics -> Statistics) -> TCM () modifyStatistics f = stStatistics `modifyTCLens` f -- | Increase specified counter by @1@. -tick :: String -> TCM () +tick :: MonadStatistics m => String -> m () tick x = tickN x 1 -- | Increase specified counter by @n@. -tickN :: String -> Integer -> TCM () +tickN :: MonadStatistics m => String -> Integer -> m () tickN s n = modifyCounter s (n +) -- | Set the specified counter to the maximum of its current value and @n@. -tickMax :: String -> Integer -> TCM () +tickMax :: MonadStatistics m => String -> Integer -> m () tickMax s n = modifyCounter s (max n) --- | Modify specified counter by a function @f@. -modifyCounter :: String -> (Integer -> Integer) -> TCM () -modifyCounter x f = modifyStatistics $ force . update - where - -- We need to be strict in the map. - -- Andreas, 2014-03-22: Could we take Data.Map.Strict instead of this hack? - -- Or force the map by looking up the very element we inserted? - -- force m = Map.lookup x m `seq` m - -- Or use insertLookupWithKey? - -- update m = old `seq` m' where - -- (old, m') = Map.insertLookupWithKey (\ _ new old -> f old) x dummy m - -- Ulf, 2018-04-10: Neither of these approaches are strict enough in the - -- map (nor are they less hacky). It's not enough to be strict in the - -- values stored in the map, we also need to be strict in the *structure* - -- of the map. A less hacky solution is to deepseq the map. - force m = rnf m `seq` m - update = Map.insertWith (\ new old -> f old) x dummy - dummy = f 0 - -- | Print the given statistics if verbosity "profile.ticks" is given. -printStatistics :: Int -> Maybe C.TopLevelModuleName -> Statistics -> TCM () +printStatistics + :: (MonadDebug m, MonadTCEnv m, HasOptions m) + => Int -> Maybe C.TopLevelModuleName -> Statistics -> m () printStatistics vl mmname stats = verboseS "profile.ticks" vl $ do unlessNull (Map.toList stats) $ \ stats -> do let -- First column (left aligned) is accounts. diff --git a/src/full/Agda/TypeChecking/Monad/Trace.hs b/src/full/Agda/TypeChecking/Monad/Trace.hs --- a/src/full/Agda/TypeChecking/Monad/Trace.hs +++ b/src/full/Agda/TypeChecking/Monad/Trace.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} module Agda.TypeChecking.Monad.Trace where @@ -6,48 +5,101 @@ import Control.Monad.Reader -import {-# SOURCE #-} Agda.Interaction.Highlighting.Generate - (highlightAsTypeChecked) +import qualified Data.Set as Set import Agda.Syntax.Position +import qualified Agda.Syntax.Position as P + +import Agda.Interaction.Response +import Agda.Interaction.Highlighting.Precise +import Agda.Interaction.Highlighting.Range (rToR, minus) + import Agda.TypeChecking.Monad.Base + hiding (ModuleInfo, MetaInfo, Primitive, Constructor, Record, Function, Datatype) import Agda.TypeChecking.Monad.Debug -import Agda.TypeChecking.Monad.Options +import Agda.TypeChecking.Monad.State import Agda.Utils.Function -import Agda.Utils.Maybe + import qualified Agda.Utils.Maybe.Strict as Strict import Agda.Utils.Monad import Agda.Utils.Null import Agda.Utils.Pretty (prettyShow) -#include "undefined.h" -import Agda.Utils.Impossible - --------------------------------------------------------------------------- -- * Trace --------------------------------------------------------------------------- -interestingCall :: Closure Call -> Bool -interestingCall cl = case clValue cl of +interestingCall :: Call -> Bool +interestingCall = \case InferVar{} -> False InferDef{} -> False CheckArguments _ [] _ _ -> False SetRange{} -> False NoHighlighting{} -> False - _ -> True + -- Andreas, 2019-08-07, expanded catch-all pattern. + -- The previous presence of a catch-all raises the following question: + -- are all of the following really interesting? + CheckClause{} -> True + CheckLHS{} -> True + CheckPattern{} -> True + CheckLetBinding{} -> True + InferExpr{} -> True + CheckExprCall{} -> True + CheckDotPattern{} -> True + IsTypeCall{} -> True + IsType_{} -> True + CheckArguments{} -> True + CheckMetaSolution{} -> True + CheckTargetType{} -> True + CheckDataDef{} -> True + CheckRecDef{} -> True + CheckConstructor{} -> True + CheckConstructorFitsIn{} -> True + CheckFunDefCall{} -> True + CheckPragma{} -> True + CheckPrimitive{} -> True + CheckIsEmpty{} -> True + CheckConfluence{} -> True + CheckWithFunctionType{} -> True + CheckSectionApplication{} -> True + CheckNamedWhere{} -> True + ScopeCheckExpr{} -> True + ScopeCheckDeclaration{} -> True + ScopeCheckLHS{} -> True + CheckProjection{} -> True + ModuleContents{} -> True -traceCallM :: (MonadTCM tcm, MonadDebug tcm) => tcm Call -> tcm a -> tcm a -traceCallM mkCall m = flip traceCall m =<< mkCall +traceCallM :: (MonadTCM tcm, ReadTCState tcm, MonadDebug tcm) => tcm Call -> tcm a -> tcm a +traceCallM call m = flip traceCall m =<< call +-- | Reset 'envCall' to previous value in the continuation. +-- +-- Caveat: if the last 'traceCall' did not set an 'interestingCall', +-- for example, only set the 'Range' with 'SetRange', +-- we will revert to the last interesting call. + +traceCallCPS :: (MonadTCM tcm, ReadTCState tcm, MonadDebug tcm) + => Call + -> ((a -> tcm b) -> tcm b) + -> ((a -> tcm b) -> tcm b) +traceCallCPS call k ret = do + mcall <- asksTC envCall + traceCall call $ k $ \ a -> do + maybe id traceClosureCall mcall $ ret a + -- | Record a function call in the trace. -- RULE left-hand side too complicated to desugar -- {-# SPECIALIZE traceCall :: Call -> TCM a -> TCM a #-} -traceCall :: (MonadTCM tcm, MonadDebug tcm) => Call -> tcm a -> tcm a -traceCall mkCall m = do - let call = mkCall - callRange = getRange call +traceCall :: (MonadTCM tcm, ReadTCState tcm, MonadDebug tcm) => Call -> tcm a -> tcm a +traceCall call m = do + cl <- liftTCM $ buildClosure call + traceClosureCall cl m + +traceClosureCall :: (MonadTCM tcm, ReadTCState tcm, MonadDebug tcm) => Closure Call -> tcm a -> tcm a +traceClosureCall cl m = do + -- Andreas, 2016-09-13 issue #2177 -- Since the fix of #2092 we may report an error outside the current file. -- (For instance, if we import a module which then happens to have the @@ -63,33 +115,44 @@ prettyShow call ++ " is setting the current range to " ++ show callRange ++ " which is outside of the current file " ++ show currentFile - cl <- liftTCM $ buildClosure call - let trace = localTC $ foldr (.) id $ - [ \e -> e { envCall = Just cl } | interestingCall cl ] ++ - [ \e -> e { envHighlightingRange = callRange } - | callRange /= noRange && highlightCall call || isNoHighlighting call ] ++ - [ \e -> e { envRange = callRange } | callRange /= noRange ] - wrap <- ifM (do l <- envHighlightingLevel <$> askTC - return (l == Interactive && highlightCall call)) - (do oldRange <- envHighlightingRange <$> askTC - return $ highlightAsTypeChecked oldRange callRange) - (return id) - wrap $ trace m + + -- Compute update to 'Range' and 'Call' components of 'TCEnv'. + let withCall = localTC $ foldr (.) id $ concat $ + [ [ \e -> e { envCall = Just cl } | interestingCall call ] + , [ \e -> e { envHighlightingRange = callRange } + | callHasRange && highlightCall + || isNoHighlighting + ] + , [ \e -> e { envRange = callRange } | callHasRange ] + ] + + -- For interactive highlighting, also wrap computation @m@ in 'highlightAsTypeChecked': + ifNotM (pure highlightCall `and2M` do (Interactive ==) . envHighlightingLevel <$> askTC) + {-then-} (withCall m) + {-else-} $ do + oldRange <- envHighlightingRange <$> askTC + highlightAsTypeChecked oldRange callRange $ + withCall m where + call = clValue cl + callRange = getRange call + callHasRange = not $ null callRange + -- | Should the given call trigger interactive highlighting? - highlightCall call = case call of + highlightCall = case call of CheckClause{} -> True + CheckLHS{} -> True CheckPattern{} -> True CheckLetBinding{} -> True InferExpr{} -> True CheckExprCall{} -> True CheckDotPattern{} -> True - CheckPatternShadowing{} -> True IsTypeCall{} -> True IsType_{} -> True InferVar{} -> True InferDef{} -> True CheckArguments{} -> True + CheckMetaSolution{} -> False CheckTargetType{} -> False CheckDataDef{} -> True CheckRecDef{} -> True @@ -99,6 +162,7 @@ CheckPragma{} -> True CheckPrimitive{} -> True CheckIsEmpty{} -> True + CheckConfluence{} -> False CheckWithFunctionType{} -> True CheckSectionApplication{} -> True CheckNamedWhere{} -> False @@ -110,15 +174,71 @@ SetRange{} -> False ModuleContents{} -> False - isNoHighlighting NoHighlighting{} = True - isNoHighlighting _ = False + isNoHighlighting = case call of + NoHighlighting{} -> True + _ -> False -getCurrentRange :: (MonadTCM tcm, MonadDebug tcm) => tcm Range +getCurrentRange :: MonadTCEnv m => m Range getCurrentRange = asksTC envRange -- | Sets the current range (for error messages etc.) to the range -- of the given object, if it has a range (i.e., its range is not 'noRange'). -setCurrentRange :: (MonadTCM tcm, MonadDebug tcm, HasRange x) +setCurrentRange :: (MonadTCM tcm, ReadTCState tcm, MonadDebug tcm, HasRange x) => x -> tcm a -> tcm a setCurrentRange x = applyUnless (null r) $ traceCall $ SetRange r where r = getRange x + +-- | @highlightAsTypeChecked rPre r m@ runs @m@ and returns its +-- result. Additionally, some code may be highlighted: +-- +-- * If @r@ is non-empty and not a sub-range of @rPre@ (after +-- 'P.continuousPerLine' has been applied to both): @r@ is +-- highlighted as being type-checked while @m@ is running (this +-- highlighting is removed if @m@ completes /successfully/). +-- +-- * Otherwise: Highlighting is removed for @rPre - r@ before @m@ +-- runs, and if @m@ completes successfully, then @rPre - r@ is +-- highlighted as being type-checked. + +highlightAsTypeChecked + :: (MonadTCM tcm, ReadTCState tcm) + => Range -- ^ @rPre@ + -> Range -- ^ @r@ + -> tcm a + -> tcm a +highlightAsTypeChecked rPre r m + | r /= noRange && delta == rPre' = wrap r' highlight clear + | otherwise = wrap delta clear highlight + where + rPre' = rToR (P.continuousPerLine rPre) + r' = rToR (P.continuousPerLine r) + delta = rPre' `minus` r' + clear = mempty + highlight = parserBased { otherAspects = Set.singleton TypeChecks } + + wrap rs x y = do + p rs x + v <- m + p rs y + return v + where + p rs x = printHighlightingInfo KeepHighlighting (singletonC rs x) + +-- | Lispify and print the given highlighting information. + +printHighlightingInfo :: + (MonadTCM tcm, ReadTCState tcm) => + RemoveTokenBasedHighlighting -> + HighlightingInfo -> + tcm () +printHighlightingInfo remove info = do + modToSrc <- useTC stModuleToSource + method <- viewTC eHighlightingMethod + liftTCM $ reportS "highlighting" 50 + [ "Printing highlighting info:" + , show info + , " modToSrc = " ++ show modToSrc + ] + unless (null $ ranges info) $ do + liftTCM $ appInteractionOutputCallback $ + Resp_HighlightingInfo info remove method modToSrc diff --git a/src/full/Agda/TypeChecking/Names.hs b/src/full/Agda/TypeChecking/Names.hs --- a/src/full/Agda/TypeChecking/Names.hs +++ b/src/full/Agda/TypeChecking/Names.hs @@ -1,10 +1,4 @@ -{-# LANGUAGE CPP #-} -{-# LANGUAGE FlexibleInstances #-} -{-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} -{-# LANGUAGE MultiParamTypeClasses #-} -{-# LANGUAGE ScopedTypeVariables #-} -{-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE UndecidableInstances #-} {-| EDSL to construct terms without touching De Bruijn indices. @@ -27,54 +21,23 @@ -} module Agda.TypeChecking.Names where -import Control.Monad -import Control.Applicative - -#if __GLASGOW_HASKELL__ >= 800 -import qualified Control.Monad.Fail as Fail -#endif +import Control.Monad.Fail (MonadFail) -import Control.Monad.Identity import Control.Monad.Reader import Control.Monad.State -import Control.Monad.Trans -import Data.Char -import Data.Map (Map) -import qualified Data.Map as Map -import Data.Maybe import Data.List -import Data.Traversable (traverse) -import Data.Monoid (mempty) -import Agda.Interaction.Options - -import Agda.Syntax.Position import Agda.Syntax.Common hiding (Nat) import Agda.Syntax.Internal -import Agda.Syntax.Internal.Generic (TermLike(..)) -import Agda.Syntax.Literal -import Agda.Syntax.Concrete.Pretty () import Agda.TypeChecking.Monad hiding (getConstInfo, typeOfConst) -import qualified Agda.TypeChecking.Monad as TCM import Agda.TypeChecking.Monad.Builtin -import Agda.TypeChecking.Reduce -import Agda.TypeChecking.Reduce.Monad import Agda.TypeChecking.Substitute -import Agda.TypeChecking.Errors -import Agda.TypeChecking.Level -import Agda.TypeChecking.Quote (QuotingKit, quoteTermWithKit, quoteTypeWithKit, quoteClauseWithKit, quotingKit) -import Agda.TypeChecking.Pretty () -- instances only import Agda.TypeChecking.Free -import Agda.Utils.Monad -import Agda.Utils.Pretty (pretty) -import Agda.Utils.Maybe - -#include "undefined.h" -import Agda.Utils.Impossible -import Debug.Trace +import Agda.Utils.Except +import Agda.Utils.Fail (Fail, runFail_) instance HasBuiltins m => HasBuiltins (NamesT m) where getBuiltinThing b = lift $ getBuiltinThing b @@ -83,9 +46,7 @@ deriving ( Functor , Applicative , Monad -#if __GLASGOW_HASKELL__ >= 800 - , Fail.MonadFail -#endif + , MonadFail , MonadTrans , MonadState s , MonadIO @@ -96,6 +57,8 @@ , MonadTCM , ReadTCState , MonadReduce + , MonadError e + , MonadAddContext ) -- deriving instance MonadState s m => MonadState s (NamesT m) @@ -105,20 +68,21 @@ runNamesT :: Names -> NamesT m a -> m a runNamesT n m = runReaderT (unName m) n -runNames :: Names -> NamesT Identity a -> a -runNames n m = runIdentity (runNamesT n m) +-- We use @Fail@ instead of @Identity@ because the computation can fail. +runNames :: Names -> NamesT Fail a -> a +runNames n m = runFail_ (runNamesT n m) currentCxt :: Monad m => NamesT m Names currentCxt = NamesT ask -cxtSubst :: Monad m => Names -> NamesT m (Substitution' a) +cxtSubst :: MonadFail m => Names -> NamesT m (Substitution' a) cxtSubst ctx = do ctx' <- currentCxt if (ctx `isSuffixOf` ctx') then return $ raiseS (genericLength ctx' - genericLength ctx) else fail $ "thing out of context (" ++ show ctx ++ " is not a sub context of " ++ show ctx' ++ ")" -inCxt :: (Monad m, Subst t a) => Names -> a -> NamesT m a +inCxt :: (MonadFail m, Subst t a) => Names -> a -> NamesT m a inCxt ctx a = do sigma <- cxtSubst ctx return $ applySubst sigma a @@ -130,17 +94,17 @@ cl :: Monad m => m a -> NamesT m a cl = lift -open :: (Monad m, Subst t a) => a -> NamesT m (NamesT m a) +open :: (MonadFail m, Subst t a) => a -> NamesT m (NamesT m a) open a = do ctx <- NamesT ask pure $ inCxt ctx a -bind' :: (Monad m, Subst t' b, DeBruijn b, Subst t a, Free a) => ArgName -> (NamesT m b -> NamesT m a) -> NamesT m a +bind' :: (MonadFail m, Subst t' b, DeBruijn b, Subst t a, Free a) => ArgName -> (NamesT m b -> NamesT m a) -> NamesT m a bind' n f = do cxt <- NamesT ask (NamesT . local (n:) . unName $ f (inCxt (n:cxt) (deBruijnVar 0))) -bind :: ( Monad m +bind :: ( MonadFail m , Subst t' b , DeBruijn b , Subst t a @@ -149,19 +113,19 @@ ArgName -> (NamesT m b -> NamesT m a) -> NamesT m (Abs a) bind n f = Abs n <$> bind' n f -glam :: Monad m +glam :: MonadFail m => ArgInfo -> ArgName -> (NamesT m Term -> NamesT m Term) -> NamesT m Term glam info n f = Lam info <$> bind n f -glamN :: (Functor m, Monad m) => +glamN :: (Functor m, MonadFail m) => [Arg ArgName] -> (NamesT m Args -> NamesT m Term) -> NamesT m Term glamN [] f = f $ pure [] glamN (Arg i n:ns) f = glam i n $ \ x -> glamN ns (\ xs -> f ((:) <$> (Arg i <$> x) <*> xs)) -lam :: Monad m +lam :: MonadFail m => ArgName -> (NamesT m Term -> NamesT m Term) -> NamesT m Term lam n f = glam defaultArgInfo n f -ilam :: Monad m +ilam :: MonadFail m => ArgName -> (NamesT m Term -> NamesT m Term) -> NamesT m Term ilam n f = glam (setRelevance Irrelevant defaultArgInfo) n f diff --git a/src/full/Agda/TypeChecking/Patterns/Abstract.hs b/src/full/Agda/TypeChecking/Patterns/Abstract.hs --- a/src/full/Agda/TypeChecking/Patterns/Abstract.hs +++ b/src/full/Agda/TypeChecking/Patterns/Abstract.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE TypeFamilies #-} -- | Tools to manipulate patterns in abstract syntax @@ -7,7 +6,6 @@ module Agda.TypeChecking.Patterns.Abstract where import qualified Data.List as List -import Data.Traversable hiding (mapM, sequence) import Data.Void import qualified Agda.Syntax.Abstract as A @@ -23,9 +21,6 @@ import Agda.TypeChecking.Monad import Agda.TypeChecking.Monad.Builtin -import Agda.Utils.Functor - -#include "undefined.h" import Agda.Utils.Impossible -- | Expand literal integer pattern into suc/zero constructor patterns. @@ -43,7 +38,7 @@ info = A.PatRange r cinfo = A.ConPatInfo ConOCon info ConPatEager p' = foldr ($) zero $ List.genericReplicate n suc - return $ foldr (A.AsP info) p' (map A.BindName xs) + return $ foldr (A.AsP info) p' (map A.mkBindName xs) _ -> return p where diff --git a/src/full/Agda/TypeChecking/Patterns/Internal.hs b/src/full/Agda/TypeChecking/Patterns/Internal.hs --- a/src/full/Agda/TypeChecking/Patterns/Internal.hs +++ b/src/full/Agda/TypeChecking/Patterns/Internal.hs @@ -1,6 +1,4 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE GADTs #-} -{-# LANGUAGE ScopedTypeVariables #-} -- | Tools to manipulate patterns in internal syntax -- in the TCM (type checking monad). @@ -17,12 +15,9 @@ import Agda.TypeChecking.Monad import Agda.TypeChecking.Monad.Builtin -import Agda.TypeChecking.Reduce (reduce, normalise, instantiate, instantiateFull) +import Agda.TypeChecking.Reduce (reduce) import Agda.TypeChecking.Substitute.DeBruijn -import Agda.Utils.Pretty - -#include "undefined.h" import Agda.Utils.Impossible -- | Convert a term (from a dot pattern) to a DeBruijn pattern. @@ -42,7 +37,7 @@ -- Constructors. Con c _ args -> ConP c noConPatternInfo . map (fmap unnamed) <$> termToPattern (fromMaybe __IMPOSSIBLE__ $ allApplyElims args) Var i [] -> return $ deBruijnVar i - Lit l -> return $ LitP l + Lit l -> return $ litP l t -> return $ dotP t dotPatternsToPatterns :: forall a. (DeBruijn (Pattern' a)) diff --git a/src/full/Agda/TypeChecking/Patterns/Match.hs b/src/full/Agda/TypeChecking/Patterns/Match.hs --- a/src/full/Agda/TypeChecking/Patterns/Match.hs +++ b/src/full/Agda/TypeChecking/Patterns/Match.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE NondecreasingIndentation #-} -- | Pattern matcher used in the reducer for clauses that @@ -8,26 +7,24 @@ import Prelude hiding (null) +import Control.Monad import Data.IntMap (IntMap) import qualified Data.IntMap as IntMap -import Data.Monoid import Data.Traversable (traverse) import Agda.Syntax.Common import Agda.Syntax.Internal +import Agda.Syntax.Internal.Pattern import Agda.TypeChecking.Reduce import Agda.TypeChecking.Reduce.Monad import Agda.TypeChecking.Substitute -import Agda.TypeChecking.Monad -import Agda.TypeChecking.Monad.Builtin (getName',builtinHComp) +import Agda.TypeChecking.Monad hiding (constructorForm) import Agda.TypeChecking.Pretty import Agda.TypeChecking.Records -import Agda.TypeChecking.Datatypes import Agda.Utils.Empty import Agda.Utils.Functor (for, ($>)) -import Agda.Utils.List import Agda.Utils.Maybe import Agda.Utils.Monad import Agda.Utils.Null @@ -35,7 +32,6 @@ import Agda.Utils.Size import Agda.Utils.Tuple -#include "undefined.h" import Agda.Utils.Impossible -- | If matching is inconclusive (@DontKnow@) we want to know whether @@ -61,24 +57,21 @@ buildSubstitution err n vs = parallelS $ map unArg $ matchedArgs err n vs --- 'mappend' is UNUSED. --- --- instance Monoid (Match a) where --- mempty = Yes mempty [] - --- Yes s us `mappend` Yes s' vs = Yes (s `mappend` s') (us ++ vs) --- Yes _ _ `mappend` No = No --- Yes _ _ `mappend` DontKnow m = DontKnow m --- No `mappend` _ = No - --- -- @NotBlocked (StuckOn e)@ means blocked by a variable. --- -- In this case, no instantiation of --- -- meta-variables will make progress. --- DontKnow b `mappend` DontKnow b' = DontKnow $ b `mappend` b' +instance Semigroup (Match a) where + -- @NotBlocked (StuckOn e)@ means blocked by a variable. + -- In this case, no instantiation of meta-variables will make progress. + DontKnow b <> DontKnow b' = DontKnow $ b <> b' + DontKnow m <> _ = DontKnow m + _ <> DontKnow m = DontKnow m + -- One could imagine DontKnow _ <> No = No, but would break the + -- equivalence to case-trees (Issue 2964). + No <> _ = No + _ <> No = No + Yes s us <> Yes s' vs = Yes (s <> s') (us <> vs) --- -- One could imagine DontKnow _ `mappend` No = No, but would break the --- -- equivalence to case-trees. --- DontKnow m `mappend` _ = DontKnow m +instance Monoid (Match a) where + mempty = empty + mappend = (<>) -- | Instead of 'zipWithM', we need to use this lazy version -- of combining pattern matching computations. @@ -110,7 +103,7 @@ (r, v') <- match p v case r of No | Just{} <- isProjP p -> return (No, v' : vs) - No -> do + No -> do -- Issue 2964: Even when the first pattern doesn't match we should -- continue to the next patterns (and potentially block on them) -- because the splitting order in the case tree may not be @@ -119,19 +112,11 @@ -- Issue 2968: do not use vs' here, because it might -- contain ill-typed terms due to eta-expansion at wrong -- type. - let vs1 = v' : vs - case r' of - Yes s' us' -> return (No , vs1) - No -> return (No , vs1) - DontKnow m -> return (DontKnow m , vs1) + return (r <> r', v' : vs) DontKnow m -> return (DontKnow m, v' : vs) - Yes s us -> do + Yes{} -> do (r', vs') <- loop ps vs - let vs1 = v' : vs' - case r' of - Yes s' us' -> return (Yes (s `mappend` s') (us `mappend` us'), vs1) - No -> return (No , vs1) - DontKnow m -> return (DontKnow m , vs1) + return (r <> r', v' : vs') _ -> __IMPOSSIBLE__ @@ -216,7 +201,7 @@ (VarP _ x , arg ) -> return (Yes NoSimplification entry, arg) where entry = singleton (dbPatVarIndex x, arg) (DotP _ _ , arg@(Arg _ v)) -> return (Yes NoSimplification empty, arg) - (LitP l , arg@(Arg _ v)) -> do + (LitP _ l , arg@(Arg _ v)) -> do w <- reduceB' v let arg' = arg $> ignoreBlocking w case w of @@ -230,7 +215,7 @@ -- Case constructor pattern. (ConP c cpi ps, Arg info v) -> do - if isNothing $ conPRecord cpi then fallback c ps (Arg info v) else do + if not (conPRecord cpi) then fallback c ps (Arg info v) else do isEtaRecordCon (conName c) >>= \case Nothing -> fallback c ps (Arg info v) Just fs -> do @@ -246,7 +231,7 @@ (theDef <$> getConstInfo c) >>= \case Constructor{ conData = d } -> do (theDef <$> getConstInfo d) >>= \case - r@Record{ recFields = fs } | YesEta <- recEtaEquality r -> return $ Just fs + r@Record{ recFields = fs } | YesEta <- recEtaEquality r -> return $ Just $ map argFromDom fs _ -> return Nothing _ -> __IMPOSSIBLE__ (DefP o q ps, v) -> do @@ -319,3 +304,40 @@ yesSimplification :: (Match a, b) -> (Match a, b) yesSimplification (Yes _ vs, us) = (Yes YesSimplification vs, us) yesSimplification r = r + +-- Matching patterns against patterns ------------------------------------- + +-- | Match a single pattern. +matchPatternP :: DeBruijnPattern + -> Arg DeBruijnPattern + -> ReduceM (Match DeBruijnPattern) +matchPatternP p (Arg info (DotP _ v)) = do + (m, arg) <- matchPattern p (Arg info v) + return $ fmap (DotP defaultPatternInfo) m +matchPatternP p arg@(Arg info q) = do + let varMatch x = return $ Yes NoSimplification $ singleton (dbPatVarIndex x, arg) + termMatch = do + (m, arg) <- matchPattern p (fmap patternToTerm arg) + return $ fmap (DotP defaultPatternInfo) m + case p of + ProjP{} -> __IMPOSSIBLE__ + IApplyP _ _ _ x -> varMatch x + VarP _ x -> varMatch x + DotP _ _ -> return $ Yes NoSimplification empty + LitP{} -> termMatch -- Literal patterns bind no variables so we can fall back to the Term version. + DefP{} -> termMatch + + ConP c cpi ps -> + case q of + ConP c' _ qs | c == c' -> matchPatternsP ps ((map . fmap) namedThing qs) + | otherwise -> return No + LitP{} -> fmap toLitP <$> termMatch + where toLitP (DotP _ (Lit l)) = litP l -- All bindings should be to literals + toLitP _ = __IMPOSSIBLE__ + _ -> termMatch + +matchPatternsP :: [NamedArg DeBruijnPattern] + -> [Arg DeBruijnPattern] + -> ReduceM (Match DeBruijnPattern) +matchPatternsP ps qs = do + mconcat <$> zipWithM matchPatternP (map namedArg ps) qs diff --git a/src/full/Agda/TypeChecking/Polarity.hs b/src/full/Agda/TypeChecking/Polarity.hs --- a/src/full/Agda/TypeChecking/Polarity.hs +++ b/src/full/Agda/TypeChecking/Polarity.hs @@ -1,16 +1,13 @@ -{-# LANGUAGE CPP #-} module Agda.TypeChecking.Polarity where import Control.Monad.State import Data.Maybe -import Data.Traversable (traverse) import Agda.Syntax.Abstract.Name import Agda.Syntax.Common import Agda.Syntax.Internal -import Agda.Syntax.Internal.Pattern import Agda.TypeChecking.Monad import Agda.TypeChecking.Datatypes (getNumberOfParameters) @@ -19,19 +16,15 @@ import Agda.TypeChecking.Substitute import Agda.TypeChecking.Telescope import Agda.TypeChecking.Reduce -import Agda.TypeChecking.Free hiding (Occurrence(..)) +import Agda.TypeChecking.Free import Agda.TypeChecking.Positivity.Occurrence -import Agda.Interaction.Options - import Agda.Utils.List import Agda.Utils.Maybe ( whenNothingM ) import Agda.Utils.Monad -import Agda.Utils.Permutation import Agda.Utils.Pretty ( prettyShow ) import Agda.Utils.Size -#include "undefined.h" import Agda.Utils.Impossible ------------------------------------------------------------------------ @@ -375,10 +368,9 @@ Dummy{} -> return [] instance HasPolarity Level where - polarities i (Max as) = polarities i as + polarities i (Max _ as) = polarities i as instance HasPolarity PlusLevel where - polarities i ClosedLevel{} = return [] polarities i (Plus _ l) = polarities i l instance HasPolarity LevelAtom where diff --git a/src/full/Agda/TypeChecking/Positivity.hs b/src/full/Agda/TypeChecking/Positivity.hs --- a/src/full/Agda/TypeChecking/Positivity.hs +++ b/src/full/Agda/TypeChecking/Positivity.hs @@ -1,25 +1,20 @@ {-# LANGUAGE BangPatterns #-} -{-# LANGUAGE CPP #-} +{-# LANGUAGE TypeFamilies #-} -- for type equality ~ {-# LANGUAGE UndecidableInstances #-} -- | Check that a datatype is strictly positive. module Agda.TypeChecking.Positivity where -#if MIN_VERSION_base(4,11,0) -import Prelude hiding ( (<>), null ) -#else import Prelude hiding ( null ) -#endif import Control.Applicative hiding (empty) import Control.DeepSeq import Control.Monad.Reader -import Control.Monad.State (get) import Data.Either import qualified Data.Foldable as Fold import Data.Function -import Data.Graph (SCC(..), flattenSCC) +import Data.Graph (SCC(..)) import Data.IntMap (IntMap) import qualified Data.IntMap as IntMap import qualified Data.List as List @@ -36,12 +31,11 @@ import Agda.Syntax.Common import qualified Agda.Syntax.Info as Info import Agda.Syntax.Internal -import Agda.Syntax.Internal.Pattern -import Agda.Syntax.Position (fuseRange, Range, HasRange(..), noRange) +import Agda.Syntax.Position (HasRange(..), noRange) import Agda.TypeChecking.Datatypes ( isDataOrRecordType ) import Agda.TypeChecking.Functions import Agda.TypeChecking.Monad -import Agda.TypeChecking.Monad.Builtin (primInf, CoinductionKit(..), coinductionKit) +import Agda.TypeChecking.Monad.Builtin (builtinInf, getBuiltin', CoinductionKit(..), coinductionKit) import Agda.TypeChecking.Positivity.Occurrence import Agda.TypeChecking.Pretty import Agda.TypeChecking.Records @@ -57,14 +51,12 @@ import Agda.Utils.Maybe import Agda.Utils.Monad import Agda.Utils.Null -import qualified Agda.Utils.Permutation as Perm import qualified Agda.Utils.Pretty as P import Agda.Utils.Pretty (Pretty, prettyShow) import Agda.Utils.SemiRing import Agda.Utils.Singleton import Agda.Utils.Size -#include "undefined.h" import Agda.Utils.Impossible type Graph n e = Graph.Graph n e @@ -162,7 +154,7 @@ -- ASR (23 December 2015). We don't raise a strictly positive -- error if the NO_POSITIVITY_CHECK pragma was set on in the -- mutual block. See Issue 1614. - when (Info.mutualPositivityCheck mi) $ + when (Info.mutualPositivityCheck mi == YesPositivityCheck) $ whenM positivityCheckEnabled $ case loop of Just o | o <= JustPos -> @@ -195,7 +187,7 @@ -- ASR (01 January 2016). We don't raise this error if the -- NO_POSITIVITY_CHECK pragma was set on in the record. See -- Issue 1760. - when (Info.mutualPositivityCheck mi) $ + when (Info.mutualPositivityCheck mi == YesPositivityCheck) $ whenM positivityCheckEnabled $ do -- Check whether the recursive record has been declared as -- 'Inductive' or 'Coinductive'. Otherwise, error. @@ -306,11 +298,15 @@ | OccursAs' Where OccurrencesBuilder' | OccursHere' Item -emptyOB :: OccurrencesBuilder -emptyOB = Concat [] +-- | The semigroup laws only hold up to flattening of 'Concat'. +instance Semigroup OccurrencesBuilder where + occs1 <> occs2 = Concat [occs1, occs2] -(>+<) :: OccurrencesBuilder -> OccurrencesBuilder -> OccurrencesBuilder -occs1 >+< occs2 = Concat [occs1, occs2] +-- | The monoid laws only hold up to flattening of 'Concat'. +instance Monoid OccurrencesBuilder where + mempty = Concat [] + mappend = (<>) + mconcat = Concat -- | Removes 'OnlyVarsUpTo' entries. preprocess :: OccurrencesBuilder -> OccurrencesBuilder' @@ -352,8 +348,10 @@ flip flatten' [] . preprocess where - flatten' :: OccurrencesBuilder' - -> [(Item, Integer)] -> [(Item, Integer)] + flatten' + :: OccurrencesBuilder' + -> [(Item, Integer)] + -> [(Item, Integer)] flatten' (Concat' obs) = foldr (\occs f -> flatten' occs . f) id obs flatten' (OccursAs' _ ob) = flatten' ob flatten' (OccursHere' i) = ((i, 1) :) @@ -374,6 +372,14 @@ -- | Monad for computing occurrences. type OccM = Reader OccEnv +instance Semigroup a => Semigroup (OccM a) where + ma <> mb = liftA2 (<>) ma mb + +instance (Semigroup a, Monoid a) => Monoid (OccM a) where + mempty = return mempty + mappend = (<>) + mconcat = mconcat <.> sequence + withExtendedOccEnv :: Maybe Item -> OccM a -> OccM a withExtendedOccEnv i = withExtendedOccEnv' [i] @@ -383,7 +389,9 @@ -- | Running the monad getOccurrences :: (Show a, PrettyTCM a, ComputeOccurrences a) - => [Maybe Item] -> a -> TCM OccurrencesBuilder + => [Maybe Item] -- ^ Extension of the 'OccEnv', usually a local variable context. + -> a + -> TCM OccurrencesBuilder getOccurrences vars a = do reportSDoc "tc.pos.occ" 70 $ "computing occurrences in " <+> text (show a) reportSDoc "tc.pos.occ" 20 $ "computing occurrences in " <+> prettyTCM a @@ -393,12 +401,16 @@ class ComputeOccurrences a where occurrences :: a -> OccM OccurrencesBuilder + default occurrences :: (Foldable t, ComputeOccurrences b, t b ~ a) => a -> OccM OccurrencesBuilder + occurrences = foldMap occurrences + instance ComputeOccurrences Clause where occurrences cl = do let ps = namedClausePats cl items = IntMap.elems $ patItems ps -- sorted from low to high DBI - (Concat (mapMaybe matching (zip [0..] ps)) >+<) <$> - withExtendedOccEnv' items (occurrences $ clauseBody cl) + (Concat (mapMaybe matching (zip [0..] ps)) <>) <$> do + withExtendedOccEnv' items $ + occurrences $ clauseBody cl where matching (i, p) | properlyMatching (namedThing $ unArg p) = @@ -419,14 +431,12 @@ instance ComputeOccurrences Term where occurrences v = case unSpine v of - Var i args -> do - vars <- asks vars - occs <- occurrences args - let mi = indexWithDefault unbound vars i - unbound = flip trace __IMPOSSIBLE__ $ - "impossible: occurrence of de Bruijn index " ++ show i ++ - " in vars " ++ show vars ++ " is unbound" - return $ maybe emptyOB OccursHere mi >+< OccursAs VarArg occs + Var i args -> (occI <$> asks vars) <> (OccursAs VarArg <$> occurrences args) + where + occI vars = maybe mempty OccursHere $ indexWithDefault unbound vars i + unbound = flip trace __IMPOSSIBLE__ $ + "impossible: occurrence of de Bruijn index " ++ show i ++ + " in vars " ++ show vars ++ " is unbound" Def d args -> do inf <- asks inf @@ -435,43 +445,39 @@ -- the first is a level argument (n==0, counting from 0!) if n == 1 then OccursAs UnderInf else OccursAs (DefArg d n) occs <- mapM occurrences args - return $ OccursHere (ADef d) >+< Concat (zipWith occsAs [0..] occs) + return . Concat $ OccursHere (ADef d) : zipWith occsAs [0..] occs + Con _ _ args -> occurrences args MetaV _ args -> OccursAs MetaArg <$> occurrences args - Pi a b -> do - oa <- occurrences a - ob <- occurrences b - return $ OccursAs LeftOfArrow oa >+< ob + Pi a b -> (OccursAs LeftOfArrow <$> occurrences a) <> occurrences b Lam _ b -> occurrences b Level l -> occurrences l - Lit{} -> return emptyOB - Sort{} -> return emptyOB - DontCare _ -> return emptyOB -- Andreas, 2011-09-09: do we need to check for negative occurrences in irrelevant positions? - Dummy{} -> return emptyOB + Lit{} -> mempty + Sort{} -> mempty + -- Jesper, 2020-01-12: this information is also used for the + -- occurs check, so we need to look under DontCare (see #4371) + DontCare v -> occurrences v + Dummy{} -> mempty instance ComputeOccurrences Level where - occurrences (Max as) = occurrences as + occurrences (Max _ as) = occurrences as instance ComputeOccurrences PlusLevel where - occurrences ClosedLevel{} = return emptyOB - occurrences (Plus _ l) = occurrences l + occurrences (Plus _ l) = occurrences l instance ComputeOccurrences LevelAtom where - occurrences l = case l of - MetaLevel x es -> occurrences $ MetaV x es + occurrences = occurrences . unLevelAtom + -- MetaLevel x es -> occurrences $ MetaV x es -- Andreas, 2016-07-25, issue 2108 - -- NOT: OccursAs MetaArg <$> occurrences vs + -- NOT: OccursAs MetaArg <$> occurrences es -- since we need to unSpine! -- (Otherwise, we run into __IMPOSSIBLE__ at Proj elims) - BlockedLevel _ v -> occurrences v - NeutralLevel _ v -> occurrences v - UnreducedLevel v -> occurrences v instance ComputeOccurrences Type where occurrences (El _ v) = occurrences v instance ComputeOccurrences a => ComputeOccurrences (Tele a) where - occurrences EmptyTel = return emptyOB + occurrences EmptyTel = mempty occurrences (ExtendTel a b) = occurrences (a, b) instance ComputeOccurrences a => ComputeOccurrences (Abs a) where @@ -479,27 +485,17 @@ occurrences (NoAbs _ b) = occurrences b instance ComputeOccurrences a => ComputeOccurrences (Elim' a) where - occurrences Proj{} = __IMPOSSIBLE__ - occurrences (Apply a) = occurrences a + occurrences Proj{} = __IMPOSSIBLE__ -- unSpine + occurrences (Apply a) = occurrences a occurrences (IApply x y a) = occurrences (x,(y,a)) -- TODO Andrea: conservative -instance ComputeOccurrences a => ComputeOccurrences (Arg a) where - occurrences = occurrences . unArg -instance ComputeOccurrences a => ComputeOccurrences (Dom a) where - occurrences = occurrences . unDom - -instance ComputeOccurrences a => ComputeOccurrences [a] where - occurrences vs = Concat <$> mapM occurrences vs - +instance ComputeOccurrences a => ComputeOccurrences (Arg a) where +instance ComputeOccurrences a => ComputeOccurrences (Dom a) where +instance ComputeOccurrences a => ComputeOccurrences [a] where instance ComputeOccurrences a => ComputeOccurrences (Maybe a) where - occurrences (Just v) = occurrences v - occurrences Nothing = return emptyOB instance (ComputeOccurrences a, ComputeOccurrences b) => ComputeOccurrences (a, b) where - occurrences (x, y) = do - ox <- occurrences x - oy <- occurrences y - return $ ox >+< oy + occurrences (x, y) = occurrences x <> occurrences y -- | Computes the number of occurrences of different 'Item's in the -- given definition. @@ -520,35 +516,66 @@ "computeOccurrences" <+> prettyTCM q <+> text (show a) <+> text (show m) <+> prettyTCM cur OccursAs (InDefOf q) <$> case theDef def of + Function{funClauses = cs} -> do cs <- mapM etaExpandClause =<< instantiateFull cs Concat . zipWith (OccursAs . InClause) [0..] <$> mapM (getOccurrences []) cs + Datatype{dataClause = Just c} -> getOccurrences [] =<< instantiateFull c Datatype{dataPars = np0, dataCons = cs} -> do -- Andreas, 2013-02-27 (later edited by someone else): First, -- include each index of an inductive family. - TelV tel t <- telView $ defType def + TelV tel _ <- telView $ defType def -- Andreas, 2017-04-26, issue #2554: count first index as parameter if it has type Size. -- We compute sizeIndex=1 if first first index has type Size, otherwise sizeIndex==0 - sizeIndex <- caseMaybe (headMaybe $ drop np0 $ telToList tel) (return 0) $ \ dom -> do + sizeIndex <- caseList (drop np0 $ telToList tel) (return 0) $ \ dom _ -> do caseMaybeM (isSizeType dom) (return 0) $ \ _ -> return 1 let np = np0 + sizeIndex let xs = [np .. size tel - 1] -- argument positions corresponding to indices - ioccs = Concat $ map (OccursHere . AnArg) [np0 .. np - 1] + let ioccs = Concat $ map (OccursHere . AnArg) [np0 .. np - 1] ++ map (OccursAs IsIndex . OccursHere . AnArg) xs -- Then, we compute the occurrences in the constructor types. let conOcc c = do - a <- defType <$> getConstInfo c - TelV tel t <- telView'Path =<< normalise a -- normalization needed e.g. for test/succeed/Bush.agda - let indices = case unEl t of - Def _ vs -> drop np vs - _ -> __IMPOSSIBLE__ - let tel' = telFromList $ drop np $ telToList tel - vars np = map (Just . AnArg) $ downFrom np - (>+<) <$> (OccursAs (ConArgType c) <$> getOccurrences (vars np) tel') - <*> (OccursAs (IndArgType c) . OnlyVarsUpTo np <$> getOccurrences (vars $ size tel) indices) - (>+<) ioccs <$> (Concat <$> mapM conOcc cs) + -- Andreas, 2020-02-15, issue #4447: + -- Allow UnconfimedReductions here to make sure we get the constructor type + -- in same way as it was obtained when the data types was checked. + TelV tel t <- putAllowedReductions allReductions $ + telViewPath . defType =<< getConstInfo c + -- Do not collect occurrences in the data parameters. + -- Normalization needed e.g. for test/succeed/Bush.agda. + -- (Actually, for Bush.agda, reducing the parameters should be sufficient.) + tel' <- normalise $ telFromList $ drop np $ telToList tel + let vars = map (Just . AnArg) . downFrom + -- Occurrences in the types of the constructor arguments. + mappend (OccursAs (ConArgType c) <$> getOccurrences (vars np) tel') $ do + -- Occurrences in the indices of the data type the constructor targets. + -- Andreas, 2020-02-15, issue #4447: + -- WAS: @t@ is not necessarily a data type, but it could be something + -- that reduces to a data type once UnconfirmedReductions are confirmed + -- as safe by the termination checker. + -- In any case, if @t@ is not showing itself as the data type, we need to + -- do something conservative. We will just collect *all* occurrences + -- and flip their sign (variance) using 'LeftOfArrow'. + let fallback = OccursAs LeftOfArrow <$> getOccurrences (vars $ size tel) t + case unEl t of + Def q' vs + | q == q' -> do + let indices = fromMaybe __IMPOSSIBLE__ $ allApplyElims $ drop np vs + OccursAs (IndArgType c) . OnlyVarsUpTo np <$> getOccurrences (vars $ size tel) indices + | otherwise -> __IMPOSSIBLE__ -- fallback -- this ought to be impossible now (but wasn't, see #4447) + Pi{} -> __IMPOSSIBLE__ -- eliminated by telView + MetaV{} -> __IMPOSSIBLE__ -- not a constructor target; should have been solved by now + Var{} -> __IMPOSSIBLE__ -- not a constructor target + Sort{} -> __IMPOSSIBLE__ -- not a constructor target + Lam{} -> __IMPOSSIBLE__ -- not a type + Lit{} -> __IMPOSSIBLE__ -- not a type + Con{} -> __IMPOSSIBLE__ -- not a type + Level{} -> __IMPOSSIBLE__ -- not a type + DontCare{} -> __IMPOSSIBLE__ -- not a type + Dummy{} -> __IMPOSSIBLE__ + mconcat $ pure ioccs : map conOcc cs + Record{recClause = Just c} -> getOccurrences [] =<< instantiateFull c Record{recPars = np, recTel = tel} -> do let tel' = telFromList $ drop np $ telToList tel @@ -556,11 +583,11 @@ getOccurrences vars =<< normalise tel' -- Andreas, 2017-01-01, issue #1899, treat like data types -- Arguments to other kinds of definitions are hard-wired. - Constructor{} -> return emptyOB - Axiom{} -> return emptyOB - DataOrRecSig{} -> return emptyOB - Primitive{} -> return emptyOB - GeneralizableVar{} -> return emptyOB + Constructor{} -> mempty + Axiom{} -> mempty + DataOrRecSig{} -> mempty + Primitive{} -> mempty + GeneralizableVar{} -> mempty AbstractDefn{} -> __IMPOSSIBLE__ -- Building the occurrence graph ------------------------------------------ @@ -577,7 +604,7 @@ mergeEdges :: Edge a -> Edge a -> Edge a mergeEdges _ e@(Edge Mixed _) = e -- dominant -mergeEdges e@(Edge Mixed _) _ = e +mergeEdges e@(Edge Mixed _) _ = e mergeEdges (Edge Unused _) e = e -- neutral mergeEdges e (Edge Unused _) = e mergeEdges (Edge JustNeg _) e@(Edge JustNeg _) = e @@ -613,11 +640,11 @@ occs <- computeOccurrences' q reportSDoc "tc.pos.occs" 40 $ - ("Occurrences in" <+> prettyTCM q <> ":") + (("Occurrences in" <+> prettyTCM q) <> ":") $+$ (nest 2 $ vcat $ map (\(i, n) -> - text (show i) <> ":" <+> text (show n) <+> + (text (show i) <> ":") <+> text (show n) <+> "occurrences") $ List.sortBy (compare `on` snd) $ Map.toList (flatten occs)) @@ -633,7 +660,7 @@ map (\e -> let Edge o w = Graph.label e in prettyTCM (Graph.source e) <+> - "-[" <+> return (P.pretty o) <> "," <+> + "-[" <+> (return (P.pretty o) <> ",") <+> return (P.pretty w) <+> "]->" <+> prettyTCM (Graph.target e)) es) @@ -757,7 +784,7 @@ instance Pretty Node where pretty = \case DefNode q -> P.pretty q - ArgNode q i -> P.pretty q P.<> P.text ("." ++ show i) + ArgNode q i -> P.pretty q <> P.text ("." ++ show i) instance PrettyTCM Node where prettyTCM = return . P.pretty @@ -783,25 +810,25 @@ where snd' (OccursWhere _ _ ws) = ws - prettyOWs :: [OccursWhere] -> TCM (String, Doc) + prettyOWs :: MonadPretty m => [OccursWhere] -> m (String, Doc) prettyOWs [] = __IMPOSSIBLE__ prettyOWs [o] = do (s, d) <- prettyOW o - return (s, d P.<> ".") + return (s, d <> ".") prettyOWs (o:os) = do (s1, d1) <- prettyOW o (s2, d2) <- prettyOWs os - return (s1, d1 P.<> "," P.<+> "which" P.<+> P.text s2 P.$$ d2) + return (s1, d1 <> ("," P.<+> "which" P.<+> P.text s2 P.$$ d2)) - prettyOW :: OccursWhere -> TCM (String, Doc) + prettyOW :: MonadPretty m => OccursWhere -> m (String, Doc) prettyOW (OccursWhere _ cs ws) | null cs = prettyWs ws | otherwise = do (s, d1) <- prettyWs ws (_, d2) <- prettyWs cs - return (s, d1 P.$$ "(" P.<> d2 P.<> ")") + return (s, d1 P.$$ "(" <> d2 <> ")") - prettyWs :: Seq Where -> TCM (String, Doc) + prettyWs :: MonadPretty m => Seq Where -> m (String, Doc) prettyWs ws = case Fold.toList ws of [InDefOf d, IsIndex] -> (,) "is" <$> fsep (pwords "an index of" ++ [prettyTCM d]) @@ -809,14 +836,14 @@ (,) "occurs" <$> Fold.foldrM (\w d -> return d $$ fsep (prettyW w)) empty ws - prettyW :: Where -> [TCM Doc] + prettyW :: MonadPretty m => Where -> [m Doc] prettyW w = case w of LeftOfArrow -> pwords "to the left of an arrow" DefArg q i -> pwords "in the" ++ nth i ++ pwords "argument of" ++ [prettyTCM q] UnderInf -> pwords "under" ++ [do -- this cannot fail if an 'UnderInf' has been generated - Def inf _ <- primInf + Def inf _ <- fromMaybe __IMPOSSIBLE__ <$> getBuiltin' builtinInf prettyTCM inf] VarArg -> pwords "in an argument of a bound variable" MetaArg -> pwords "in an argument of a metavariable" diff --git a/src/full/Agda/TypeChecking/Positivity/Occurrence.hs b/src/full/Agda/TypeChecking/Positivity/Occurrence.hs --- a/src/full/Agda/TypeChecking/Positivity/Occurrence.hs +++ b/src/full/Agda/TypeChecking/Positivity/Occurrence.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE DeriveDataTypeable #-} @@ -16,27 +15,25 @@ import Control.Monad import Data.Data (Data) -import Data.Either + import Data.Foldable (toList) -import Data.Maybe + import Data.Map.Strict (Map) import qualified Data.Map.Strict as Map import Data.Sequence (Seq) -import qualified Data.Sequence as Seq + import Agda.Syntax.Common import Agda.Syntax.Abstract.Name import Agda.Syntax.Position import Agda.Utils.Graph.AdjacencyMap.Unidirectional (Graph) import qualified Agda.Utils.Graph.AdjacencyMap.Unidirectional as Graph -import Agda.Utils.List import Agda.Utils.Null import Agda.Utils.Pretty import Agda.Utils.SemiRing import Agda.Utils.Size -#include "undefined.h" import Agda.Utils.Impossible -- Specification of occurrences ------------------------------------------- diff --git a/src/full/Agda/TypeChecking/Pretty.hs b/src/full/Agda/TypeChecking/Pretty.hs --- a/src/full/Agda/TypeChecking/Pretty.hs +++ b/src/full/Agda/TypeChecking/Pretty.hs @@ -1,32 +1,21 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE UndecidableInstances #-} --- To define <>, we need to add with GHC >= 8.4 --- --- import Prelude hiding ((<>)) --- --- but using that gives warnings and doesn't silence -Wsemigroup in --- some versions of GHC. -#if __GLASGOW_HASKELL__ >= 800 && __GLASGOW_HASKELL__ < 804 -{-# OPTIONS_GHC -Wno-semigroup #-} -#endif - -module Agda.TypeChecking.Pretty where +module Agda.TypeChecking.Pretty + ( module Agda.TypeChecking.Pretty + -- This re-export can be removed once ), null ) -#else import Prelude hiding ( null ) -#endif -import Control.Applicative hiding (empty) import Control.Monad import Data.Map (Map) import qualified Data.Map as Map -import Data.Set (Set) import qualified Data.Set as Set import Data.Maybe +import Data.String +import Data.Semigroup (Semigroup((<>))) import Agda.Syntax.Position import Agda.Syntax.Common @@ -37,10 +26,8 @@ import Agda.Syntax.Translation.ReflectedToAbstract import Agda.Syntax.Translation.AbstractToConcrete import qualified Agda.Syntax.Translation.ReflectedToAbstract as R -import qualified Agda.Syntax.Reflected as R import qualified Agda.Syntax.Abstract as A import qualified Agda.Syntax.Concrete as C -import qualified Agda.Syntax.Reflected as R import qualified Agda.Syntax.Abstract.Pretty as AP import Agda.Syntax.Concrete.Pretty (bracesAndSemicolons) import qualified Agda.Syntax.Concrete.Pretty as CP @@ -53,6 +40,7 @@ import Agda.TypeChecking.Positivity.Occurrence import Agda.TypeChecking.Substitute +import Agda.Utils.Except import Agda.Utils.Graph.AdjacencyMap.Unidirectional (Graph) import qualified Agda.Utils.Graph.AdjacencyMap.Unidirectional as Graph import Agda.Utils.Maybe @@ -61,7 +49,6 @@ import Agda.Utils.Pretty (Pretty, prettyShow) import qualified Agda.Utils.Pretty as P -#include "undefined.h" import Agda.Utils.Impossible --------------------------------------------------------------------------- @@ -70,75 +57,74 @@ type Doc = P.Doc -comma, colon, equals :: TCM Doc +comma, colon, equals :: Monad m => m Doc comma = return P.comma colon = return P.colon equals = return P.equals -pretty :: P.Pretty a => a -> TCM Doc +pretty :: (Monad m, P.Pretty a) => a -> m Doc pretty x = return $ P.pretty x -prettyA :: (P.Pretty c, ToConcrete a c) => a -> TCM Doc +prettyA :: (P.Pretty c, ToConcrete a c, MonadAbsToCon m) => a -> m Doc prettyA x = AP.prettyA x -prettyAs :: (P.Pretty c, ToConcrete a [c]) => a -> TCM Doc +prettyAs :: (P.Pretty c, ToConcrete a [c], MonadAbsToCon m) => a -> m Doc prettyAs x = AP.prettyAs x -text :: String -> TCM Doc +text :: Monad m => String -> m Doc text s = return $ P.text s -multiLineText :: String -> TCM Doc +multiLineText :: Monad m => String -> m Doc multiLineText s = return $ P.multiLineText s -pwords :: String -> [TCM Doc] +pwords :: Monad m => String -> [m Doc] pwords s = map return $ P.pwords s -fwords :: String -> TCM Doc +fwords :: Monad m => String -> m Doc fwords s = return $ P.fwords s -sep, fsep, hsep, hcat, vcat :: [TCM Doc] -> TCM Doc +sep, fsep, hsep, hcat, vcat :: Monad m => [m Doc] -> m Doc sep ds = P.sep <$> sequence ds fsep ds = P.fsep <$> sequence ds hsep ds = P.hsep <$> sequence ds hcat ds = P.hcat <$> sequence ds vcat ds = P.vcat <$> sequence ds -hang :: TCM Doc -> Int -> TCM Doc -> TCM Doc +hang :: Applicative m => m Doc -> Int -> m Doc -> m Doc hang p n q = P.hang <$> p <*> pure n <*> q -infixl 6 <>, <+>, +infixl 6 <+>, infixl 5 $$, $+$ -($$), ($+$), (<>), (<+>), () :: TCM Doc -> TCM Doc -> TCM Doc +($$), ($+$), (<+>), () :: Applicative m => m Doc -> m Doc -> m Doc d1 $$ d2 = (P.$$) <$> d1 <*> d2 d1 $+$ d2 = (P.$+$) <$> d1 <*> d2 -d1 <> d2 = (P.<>) <$> d1 <*> d2 d1 <+> d2 = (P.<+>) <$> d1 <*> d2 d1 d2 = (P.) <$> d1 <*> d2 -nest :: Int -> TCM Doc -> TCM Doc +nest :: Functor m => Int -> m Doc -> m Doc nest n d = P.nest n <$> d -braces, dbraces, brackets, parens :: TCM Doc -> TCM Doc +braces, dbraces, brackets, parens :: Functor m => m Doc -> m Doc braces d = P.braces <$> d dbraces d = CP.dbraces <$> d brackets d = P.brackets <$> d parens d = P.parens <$> d -pshow :: Show a => a -> TCM Doc +pshow :: (Applicative m, Show a) => a -> m Doc pshow = pure . P.pshow -- | Comma-separated list in brackets. -prettyList :: [TCM Doc] -> TCM Doc +prettyList :: (Monad m, Semigroup (m Doc)) => [m Doc] -> m Doc prettyList ds = P.pretty <$> sequence ds -- | 'prettyList' without the brackets. -prettyList_ :: [TCM Doc] -> TCM Doc +prettyList_ :: (Monad m, Semigroup (m Doc)) => [m Doc] -> m Doc prettyList_ ds = fsep $ punctuate comma ds -punctuate :: TCM Doc -> [TCM Doc] -> [TCM Doc] +punctuate :: (Applicative m, Semigroup (m Doc)) => m Doc -> [m Doc] -> [m Doc] punctuate _ [] = [] -punctuate d ds = zipWith (<>) ds (replicate n d ++ [empty]) +punctuate d ds = zipWith (<>) ds (replicate n d ++ [pure empty]) where n = length ds - 1 @@ -146,11 +132,19 @@ -- * The PrettyTCM class --------------------------------------------------------------------------- +type MonadPretty m = + ( MonadReify m + , MonadAbsToCon m + , IsString (m Doc) + , Null (m Doc) + , Semigroup (m Doc) + ) + class PrettyTCM a where - prettyTCM :: a -> TCM Doc + prettyTCM :: MonadPretty m => a -> m Doc -- | Pretty print with a given context precedence -prettyTCMCtx :: PrettyTCM a => Precedence -> a -> TCM Doc +prettyTCMCtx :: (PrettyTCM a, MonadPretty m) => Precedence -> a -> m Doc prettyTCMCtx p = withContextPrecedence p . prettyTCM instance PrettyTCM Bool where prettyTCM = pretty @@ -188,8 +182,11 @@ instance PrettyTCM Permutation where prettyTCM = text . show instance PrettyTCM Polarity where prettyTCM = text . show instance PrettyTCM IsForced where prettyTCM = text . show -instance PrettyTCM R.Term where prettyTCM = prettyA <=< toAbstractWithoutImplicit +prettyR + :: (R.ToAbstract r a, PrettyTCM a, MonadPretty m, MonadError TCErr m) + => r -> m Doc +prettyR = prettyTCM <=< toAbstractWithoutImplicit instance (Pretty a, PrettyTCM a, Subst a a) => PrettyTCM (Substitution' a) where prettyTCM IdS = "idS" @@ -206,7 +203,7 @@ prettyTCM (QNamed x cl) instance PrettyTCM a => PrettyTCM (Judgement a) where - prettyTCM (HasType a t) = prettyTCM a <+> ":" <+> prettyTCM t + prettyTCM (HasType a cmp t) = prettyTCM a <+> ":" <+> prettyTCM t prettyTCM (IsSort a t) = "Sort" <+> prettyTCM a <+> ":" <+> prettyTCM t instance PrettyTCM MetaId where @@ -215,7 +212,7 @@ pretty $ NamedMeta mn x instance PrettyTCM a => PrettyTCM (Blocked a) where - prettyTCM (Blocked x a) = "[" <+> prettyTCM a <+> "]" <> text (P.prettyShow x) + prettyTCM (Blocked x a) = ("[" <+> prettyTCM a <+> "]") <> text (P.prettyShow x) prettyTCM (NotBlocked _ x) = prettyTCM x instance (Reify a e, ToConcrete e c, P.Pretty c) => PrettyTCM (Named_ a) where @@ -253,28 +250,36 @@ prettyTCM = prettyA instance PrettyTCM Relevance where - prettyTCM Irrelevant = "." - prettyTCM NonStrict = ".." - prettyTCM Relevant = empty + prettyTCM = pretty +instance PrettyTCM Quantity where + prettyTCM = pretty + +instance PrettyTCM Modality where + prettyTCM mod = hsep + [ prettyTCM (getQuantity mod) + , prettyTCM (getRelevance mod) + ] + instance PrettyTCM ProblemConstraint where - prettyTCM (PConstr pids c) - | Set.null pids = prettyTCM c - | otherwise = prettyList (map prettyTCM $ Set.toList pids) <+> prettyTCM c + prettyTCM (PConstr pids c) = prettyTCM c prPids (Set.toList pids) + where + prPids [] = empty + prPids [pid] = parens $ "problem" <+> prettyTCM pid + prPids pids = parens $ "problems" <+> fsep (punctuate "," $ map prettyTCM pids) instance PrettyTCM Constraint where prettyTCM c = case c of - ValueCmp cmp ty s t -> prettyCmp (prettyTCM cmp) s t (":" <+> prettyTCMCtx TopCtx ty) + ValueCmp cmp ty s t -> prettyCmp (prettyTCM cmp) s t prettyTCM ty ValueCmpOnFace cmp p ty s t -> sep [ prettyTCM p <+> "|" , prettyCmp (prettyTCM cmp) s t ] (":" <+> prettyTCMCtx TopCtx ty) ElimCmp cmps fs t v us vs -> prettyCmp "~~" us vs (":" <+> prettyTCMCtx TopCtx t) LevelCmp cmp a b -> prettyCmp (prettyTCM cmp) a b - TypeCmp cmp a b -> prettyCmp (prettyTCM cmp) a b TelCmp a b cmp tela telb -> prettyCmp (prettyTCM cmp) tela telb SortCmp cmp s1 s2 -> prettyCmp (prettyTCM cmp) s1 s2 - Guarded c pid -> prettyTCM c (brackets $ "blocked on problem" <+> prettyTCM pid) + Guarded c pid -> prettyTCM c (parens $ "blocked by problem" <+> prettyTCM pid) UnBlock m -> do -- BlockedConst t <- mvInstantiation <$> lookupMeta m mi <- mvInstantiation <$> lookupMeta m @@ -291,7 +296,7 @@ -- Thus, this case is not IMPOSSIBLE. -- -- InstV args t -> do - -- reportSLn "impossible" 10 $ unlines + -- reportS "impossible" 10 -- [ "UnBlock meta " ++ show m ++ " surprisingly has InstV instantiation:" -- , show m ++ show args ++ " := " ++ show t -- ] @@ -325,15 +330,26 @@ HasBiggerSort a -> "Has bigger sort:" <+> prettyTCM a HasPTSRule a b -> "Has PTS rule:" <+> case b of NoAbs _ b -> prettyTCM (a,b) - Abs x b -> "(" <> prettyTCM a <+> "," <+> addContext x (prettyTCM b) <> ")" + Abs x b -> "(" <> (prettyTCM a <+> "," <+> addContext x (prettyTCM b)) <> ")" UnquoteTactic _ v _ _ -> do e <- reify v prettyTCM (A.App A.defaultAppInfo_ (A.Unquote A.exprNoRange) (defaultNamedArg e)) + CheckMetaInst x -> do + m <- lookupMeta x + case mvJudgement m of + HasType{ jMetaType = t } -> prettyTCM x <+> ":" <+> prettyTCM t + IsSort{} -> prettyTCM x <+> "is a sort" where - prettyCmp :: (PrettyTCM a, PrettyTCM b) => TCM Doc -> a -> b -> TCM Doc + prettyCmp + :: (PrettyTCM a, PrettyTCM b, MonadPretty m) + => m Doc -> a -> b -> m Doc prettyCmp cmp x y = prettyTCMCtx TopCtx x (cmp <+> prettyTCMCtx TopCtx y) +instance PrettyTCM CompareAs where + prettyTCM (AsTermsOf a) = ":" <+> prettyTCMCtx TopCtx a + prettyTCM AsSizes = ":" <+> do prettyTCM =<< sizeType + prettyTCM AsTypes = empty instance PrettyTCM TypeCheckingProblem where prettyTCM (CheckExpr cmp e a) = @@ -398,24 +414,26 @@ prettyTCM (ConP c i ps) = (if b then braces else parens) $ prTy $ prettyTCM c <+> fsep (map (prettyTCM . namedArg) ps) where - b = maybe False (/= PatOCon) $ conPRecord i - showRec :: TCM Doc + b = conPRecord i && patOrigin (conPInfo i) /= PatOCon + showRec :: MonadPretty m => m Doc showRec = sep [ "record" , bracesAndSemicolons <$> zipWithM showField (conFields c) ps ] + showField :: MonadPretty m => Arg QName -> NamedArg (Pattern' a) -> m Doc showField (Arg ai x) p = sep [ prettyTCM (A.qnameName x) <+> "=" , nest 2 $ prettyTCM $ namedArg p ] + showCon :: MonadPretty m => m Doc showCon = parens $ prTy $ prettyTCM c <+> fsep (map (prettyTCM . namedArg) ps) prTy d = d -- caseMaybe (conPType i) d $ \ t -> d <+> ":" <+> prettyTCM t - prettyTCM (LitP l) = text (P.prettyShow l) + prettyTCM (LitP _ l) = text (P.prettyShow l) prettyTCM (ProjP _ q) = text ("." ++ P.prettyShow q) -- | Proper pretty printing of patterns: -prettyTCMPatterns :: [NamedArg DeBruijnPattern] -> TCM [Doc] +prettyTCMPatterns :: MonadPretty m => [NamedArg DeBruijnPattern] -> m [Doc] prettyTCMPatterns = mapM prettyA <=< reifyPatterns -prettyTCMPatternList :: [NamedArg DeBruijnPattern] -> TCM Doc +prettyTCMPatternList :: MonadPretty m => [NamedArg DeBruijnPattern] -> m Doc prettyTCMPatternList = prettyList . map prettyA <=< reifyPatterns instance PrettyTCM (Elim' DisplayTerm) where @@ -425,22 +443,28 @@ instance PrettyTCM NLPat where prettyTCM (PVar x bvs) = prettyTCM (Var x (map (Apply . fmap var) bvs)) - prettyTCM (PWild) = text $ "_" prettyTCM (PDef f es) = parens $ prettyTCM f <+> fsep (map prettyTCM es) prettyTCM (PLam i u) = parens $ text ("λ " ++ absName u ++ " →") <+> (addContext (absName u) $ prettyTCM $ absBody u) prettyTCM (PPi a b) = parens $ - text ("(" ++ absName b ++ " :") <+> prettyTCM (unDom a) <> ") →" <+> + text ("(" ++ absName b ++ " :") <+> (prettyTCM (unDom a) <> ") →") <+> (addContext (absName b) $ prettyTCM $ unAbs b) + prettyTCM (PSort s) = prettyTCM s prettyTCM (PBoundVar i []) = prettyTCM (var i) prettyTCM (PBoundVar i es) = parens $ prettyTCM (var i) <+> fsep (map prettyTCM es) prettyTCM (PTerm t) = "." <> parens (prettyTCM t) instance PrettyTCM NLPType where - prettyTCM (NLPType PWild a) = prettyTCM a - prettyTCM (NLPType l a) = "{" <> prettyTCM l <> "}" <> prettyTCM a + prettyTCM (NLPType s a) = prettyTCM a + +instance PrettyTCM NLPSort where + prettyTCM = \case + PType l -> parens $ "Set" <+> prettyTCM l + PProp l -> parens $ "Prop" <+> prettyTCM l + PInf -> prettyTCM (Inf :: Sort) + PSizeUniv -> prettyTCM (SizeUniv :: Sort) instance PrettyTCM (Elim' NLPat) where prettyTCM (IApply x y v) = prettyTCM v diff --git a/src/full/Agda/TypeChecking/Pretty.hs-boot b/src/full/Agda/TypeChecking/Pretty.hs-boot --- a/src/full/Agda/TypeChecking/Pretty.hs-boot +++ b/src/full/Agda/TypeChecking/Pretty.hs-boot @@ -1,22 +1,61 @@ -{-# LANGUAGE FlexibleInstances #-} module Agda.TypeChecking.Pretty where --- import Agda.Syntax.Common +import Data.String (IsString) +import Data.Semigroup (Semigroup) + +import Agda.Syntax.Common (NameId) import Agda.Syntax.Internal --- import Agda.Syntax.Literal + + import Agda.TypeChecking.Monad.Base +import {-# SOURCE #-} Agda.TypeChecking.Monad.Builtin +import {-# SOURCE #-} Agda.TypeChecking.Monad.Context (MonadAddContext) +import Agda.TypeChecking.Monad.Debug (MonadDebug) +import {-# SOURCE #-} Agda.TypeChecking.Monad.MetaVars (MonadInteractionPoints) +import {-# SOURCE #-} Agda.TypeChecking.Monad.Signature (HasConstInfo) +import Agda.Utils.Null (Null) import Agda.Utils.Pretty (Doc) --- import qualified Agda.Utils.Pretty as P +import qualified Agda.Utils.Pretty as P -text :: String -> TCM Doc -sep, fsep, hsep, vcat :: [TCM Doc] -> TCM Doc -($$), (<>), (<+>) :: TCM Doc -> TCM Doc -> TCM Doc +text :: Monad m => String -> m Doc +sep, fsep, hsep, vcat :: Monad m => [m Doc] -> m Doc +hang :: Applicative m => m Doc -> Int -> m Doc -> m Doc +($$), (<+>), () :: Applicative m => m Doc -> m Doc -> m Doc +nest :: Functor m => Int -> m Doc -> m Doc +pretty :: (Monad m, P.Pretty a) => a -> m Doc +prettyList_ :: (Monad m, Semigroup (m Doc)) => [m Doc] -> m Doc +-- Inlining definitions of MonadReify and MonadAbsToCon to avoid +-- having to import them +type MonadPretty m = + ( ( MonadReduce m + , MonadAddContext m + , MonadInteractionPoints m + , MonadFresh NameId m + , HasConstInfo m + , HasOptions m + , HasBuiltins m + , MonadDebug m + ) + , ( MonadTCEnv m + , ReadTCState m + , MonadStConcreteNames m + , HasOptions m + , HasBuiltins m + , MonadDebug m + ) + , IsString (m Doc) + , Null (m Doc) + , Semigroup (m Doc) + ) + class PrettyTCM a where - prettyTCM :: a -> TCM Doc + prettyTCM :: MonadPretty m => a -> m Doc +newtype PrettyContext = PrettyContext Context + instance PrettyTCM a => PrettyTCM (Closure a) instance PrettyTCM a => PrettyTCM [a] @@ -28,3 +67,4 @@ instance PrettyTCM Sort instance PrettyTCM DisplayTerm instance PrettyTCM DBPatVar +instance PrettyTCM PrettyContext diff --git a/src/full/Agda/TypeChecking/Pretty/Call.hs b/src/full/Agda/TypeChecking/Pretty/Call.hs new file mode 100644 --- /dev/null +++ b/src/full/Agda/TypeChecking/Pretty/Call.hs @@ -0,0 +1,192 @@ + +module Agda.TypeChecking.Pretty.Call where + +import Prelude hiding ( null ) + +import Agda.Syntax.Abstract as A +import Agda.Syntax.Abstract.Views +import Agda.Syntax.Common +import Agda.Syntax.Fixity +import qualified Agda.Syntax.Concrete.Definitions as D +import qualified Agda.Syntax.Info as A +import Agda.Syntax.Position +import Agda.Syntax.Scope.Monad +import Agda.Syntax.Translation.AbstractToConcrete + +import Agda.TypeChecking.Monad.Base +import Agda.TypeChecking.Monad.Context +import Agda.TypeChecking.Monad.Debug +import Agda.TypeChecking.Pretty + +import Agda.Utils.Function +import Agda.Utils.Null +import qualified Agda.Utils.Pretty as P + +import Agda.Utils.Impossible + +sayWhere :: MonadPretty m => HasRange a => a -> m Doc -> m Doc +sayWhere x d = applyUnless (null r) (prettyTCM r $$) d + where r = getRange x + +sayWhen :: MonadPretty m => Range -> Maybe (Closure Call) -> m Doc -> m Doc +sayWhen r Nothing m = sayWhere r m +sayWhen r (Just cl) m = sayWhere r (m $$ prettyTCM cl) + +instance PrettyTCM CallInfo where + prettyTCM c = do + let call = prettyTCM $ callInfoCall c + r = callInfoRange c + if null $ P.pretty r + then call + else call $$ nest 2 ("(at" <+> prettyTCM r) <> ")" + +instance PrettyTCM Call where + prettyTCM = withContextPrecedence TopCtx . \case + + CheckClause t cl -> do + + verboseS "error.checkclause" 40 $ do + reportSLn "error.checkclause" 60 $ "prettyTCM CheckClause: cl = " ++ show (deepUnscope cl) + clc <- abstractToConcrete_ cl + reportSLn "error.checkclause" 40 $ "cl (Concrete) = " ++ show clc + + fsep $ + pwords "when checking that the clause" + ++ [prettyA cl] ++ pwords "has type" ++ [prettyTCM t] + + CheckLHS lhs -> vcat $ + [ fsep $ pwords "when checking the clause left hand side" + , prettyA $ lhs { A.spLhsInfo = (A.spLhsInfo lhs) { A.lhsEllipsis = NoEllipsis } } + ] + + CheckPattern p tel t -> addContext tel $ fsep $ + pwords "when checking that the pattern" + ++ [prettyA p] ++ pwords "has type" ++ [prettyTCM t] + + CheckLetBinding b -> fsep $ + pwords "when checking the let binding" ++ [prettyA b] + + InferExpr e -> fsep $ pwords "when inferring the type of" ++ [prettyA e] + + CheckExprCall cmp e t -> fsep $ + pwords "when checking that the expression" + ++ [prettyA e] ++ pwords "has type" ++ [prettyTCM t] + + IsTypeCall cmp e s -> fsep $ + pwords "when checking that the expression" + ++ [prettyA e] ++ pwords "is a type of sort" ++ [prettyTCM s] + + IsType_ e -> fsep $ + pwords "when checking that the expression" + ++ [prettyA e] ++ pwords "is a type" + + CheckProjection _ x t -> fsep $ + pwords "when checking the projection" ++ + [ sep [ prettyTCM x <+> ":" + , nest 2 $ prettyTCM t ] ] + + CheckArguments r es t0 t1 -> fsep $ + pwords "when checking that" ++ + map hPretty es ++ + pwords (P.singPlural es "is a valid argument" "are valid arguments") ++ + pwords "to a function of type" ++ + [prettyTCM t0] + + CheckMetaSolution r m a v -> fsep $ + pwords "when checking that the solution" ++ [prettyTCM v] ++ + pwords "of metavariable" ++ [prettyTCM m] ++ + pwords "has the expected type" ++ [prettyTCM a] + + CheckTargetType r infTy expTy -> sep + [ "when checking that the inferred type of an application" + , nest 2 $ prettyTCM infTy + , "matches the expected type" + , nest 2 $ prettyTCM expTy ] + + CheckRecDef _ x ps cs -> + fsep $ pwords "when checking the definition of" ++ [prettyTCM x] + + CheckDataDef _ x ps cs -> + fsep $ pwords "when checking the definition of" ++ [prettyTCM x] + + CheckConstructor d _ _ (A.Axiom _ _ _ _ c _) -> fsep $ + pwords "when checking the constructor" ++ [prettyTCM c] ++ + pwords "in the declaration of" ++ [prettyTCM d] + + CheckConstructor{} -> __IMPOSSIBLE__ + + CheckConstructorFitsIn c t s -> fsep $ + pwords "when checking that the type" ++ [prettyTCM t] ++ + pwords "of the constructor" ++ [prettyTCM c] ++ + pwords "fits in the sort" ++ [prettyTCM s] ++ + pwords "of the datatype." + + CheckFunDefCall _ f _ -> + fsep $ pwords "when checking the definition of" ++ [prettyTCM f] + + CheckPragma _ p -> + fsep $ pwords "when checking the pragma" + ++ [prettyA $ RangeAndPragma noRange p] + + CheckPrimitive _ x e -> fsep $ + pwords "when checking that the type of the primitive function" ++ + [prettyTCM x] ++ pwords "is" ++ [prettyA e] + + CheckWithFunctionType a -> fsep $ + pwords "when checking that the type" ++ + [prettyTCM a] ++ pwords "of the generated with function is well-formed" + + CheckDotPattern e v -> fsep $ + pwords "when checking that the given dot pattern" ++ [prettyA e] ++ + pwords "matches the inferred value" ++ [prettyTCM v] + + CheckNamedWhere m -> fsep $ + pwords "when checking the named where block" ++ [prettyA m] + + InferVar x -> + fsep $ pwords "when inferring the type of" ++ [prettyTCM x] + + InferDef x -> + fsep $ pwords "when inferring the type of" ++ [prettyTCM x] + + CheckIsEmpty r t -> + fsep $ pwords "when checking that" ++ [prettyTCM t] ++ + pwords "has no constructors" + + CheckConfluence r1 r2 -> + fsep $ pwords "when checking confluence of the rewrite rule" ++ + [prettyTCM r1] ++ pwords "with" ++ + if r1 == r2 then pwords "itself" else [prettyTCM r2] + + ScopeCheckExpr e -> fsep $ pwords "when scope checking" ++ [pretty e] + + ScopeCheckDeclaration d -> + fwords ("when scope checking the declaration" ++ suffix) $$ + nest 2 (vcat $ map pretty ds) + where + ds = D.notSoNiceDeclarations d + suffix = case ds of + [_] -> "" + _ -> "s" + + ScopeCheckLHS x p -> + fsep $ pwords "when scope checking the left-hand side" ++ [pretty p] ++ + pwords "in the definition of" ++ [pretty x] + + NoHighlighting -> empty + + SetRange r -> fsep (pwords "when doing something at") <+> prettyTCM r + + CheckSectionApplication _ m1 modapp -> fsep $ + pwords "when checking the module application" ++ + [prettyA $ A.Apply info m1 modapp initCopyInfo defaultImportDir] + where + info = A.ModuleInfo noRange noRange Nothing Nothing Nothing + + ModuleContents -> fsep $ pwords "when retrieving the contents of a module" + + where + hPretty :: MonadPretty m => Arg (Named_ Expr) -> m Doc + hPretty a = do + withContextPrecedence (ArgumentCtx PreferParen) $ + pretty =<< abstractToConcreteHiding a a diff --git a/src/full/Agda/TypeChecking/Pretty/Call.hs-boot b/src/full/Agda/TypeChecking/Pretty/Call.hs-boot new file mode 100644 --- /dev/null +++ b/src/full/Agda/TypeChecking/Pretty/Call.hs-boot @@ -0,0 +1,12 @@ + +module Agda.TypeChecking.Pretty.Call where + +import Agda.Syntax.Position + +import Agda.TypeChecking.Monad.Base + +import {-# SOURCE #-} Agda.TypeChecking.Pretty (MonadPretty) + +import Agda.Utils.Pretty + +sayWhen :: MonadPretty m => Range -> Maybe (Closure Call) -> m Doc -> m Doc diff --git a/src/full/Agda/TypeChecking/Pretty/Warning.hs b/src/full/Agda/TypeChecking/Pretty/Warning.hs new file mode 100644 --- /dev/null +++ b/src/full/Agda/TypeChecking/Pretty/Warning.hs @@ -0,0 +1,353 @@ + +module Agda.TypeChecking.Pretty.Warning where + +import Prelude hiding ( null ) + +import Data.Char ( toLower ) +import Data.Function +import qualified Data.Set as Set +import qualified Data.List as List + +import Agda.TypeChecking.Monad.Base +import {-# SOURCE #-} Agda.TypeChecking.Errors +import Agda.TypeChecking.Monad.MetaVars +import Agda.TypeChecking.Monad.Options +import Agda.TypeChecking.Monad.State ( getScope ) +import Agda.TypeChecking.Positivity () --instance only +import Agda.TypeChecking.Pretty +import Agda.TypeChecking.Pretty.Call + +import Agda.Syntax.Position +import qualified Agda.Syntax.Concrete as C +import Agda.Syntax.Scope.Base ( concreteNamesInScope, NameOrModule(..) ) +import Agda.Syntax.Internal +import Agda.Syntax.Translation.InternalToAbstract + +import {-# SOURCE #-} Agda.Interaction.Imports +import Agda.Interaction.Options +import Agda.Interaction.Options.Warnings + +import Agda.Utils.Lens +import Agda.Utils.List ( editDistance ) +import Agda.Utils.Null +import qualified Agda.Utils.Pretty as P + +instance PrettyTCM TCWarning where + prettyTCM = return . tcWarningPrintedWarning + +instance PrettyTCM Warning where + prettyTCM = prettyWarning + +prettyConstraint :: MonadPretty m => ProblemConstraint -> m Doc +prettyConstraint c = f (locallyTCState stInstantiateBlocking (const True) $ prettyTCM c) + where + r = getRange c + f :: MonadPretty m => m Doc -> m Doc + f d = if null $ P.pretty r + then d + else d $$ nest 4 ("[ at" <+> prettyTCM r <+> "]") + +interestingConstraint :: ProblemConstraint -> Bool +interestingConstraint pc = go $ clValue (theConstraint pc) + where + go UnBlock{} = False + go (Guarded c _) = go c + go _ = True + +prettyInterestingConstraints :: MonadPretty m => [ProblemConstraint] -> m [Doc] +prettyInterestingConstraints cs = mapM (prettyConstraint . stripPids) $ List.sortBy (compare `on` isBlocked) cs' + where + isBlocked = not . null . blocking . clValue . theConstraint + cs' = filter interestingConstraint cs + interestingPids = Set.fromList $ concatMap (blocking . clValue . theConstraint) cs' + stripPids (PConstr pids c) = PConstr (Set.intersection pids interestingPids) c + blocking (Guarded c pid) = pid : blocking c + blocking _ = [] + +{-# SPECIALIZE prettyWarning :: Warning -> TCM Doc #-} +prettyWarning :: MonadPretty m => Warning -> m Doc +prettyWarning wng = case wng of + + UnsolvedMetaVariables ms -> + fsep ( pwords "Unsolved metas at the following locations:" ) + $$ nest 2 (vcat $ map prettyTCM ms) + + UnsolvedInteractionMetas is -> + fsep ( pwords "Unsolved interaction metas at the following locations:" ) + $$ nest 2 (vcat $ map prettyTCM is) + + UnsolvedConstraints cs -> do + pcs <- prettyInterestingConstraints cs + if null pcs + then fsep $ pwords "Unsolved constraints" -- #4065: keep minimal warning text + else vcat + [ fsep $ pwords "Failed to solve the following constraints:" + , nest 2 $ return $ P.vcat $ List.nub pcs + ] + + TerminationIssue because -> do + dropTopLevel <- topLevelModuleDropper + fwords "Termination checking failed for the following functions:" + $$ (nest 2 $ fsep $ punctuate comma $ + map (pretty . dropTopLevel) $ + concatMap termErrFunctions because) + $$ fwords "Problematic calls:" + $$ (nest 2 $ fmap (P.vcat . List.nub) $ + mapM prettyTCM $ List.sortBy (compare `on` callInfoRange) $ + concatMap termErrCalls because) + + UnreachableClauses f pss -> fsep $ + pwords "Unreachable" ++ pwords (plural (length pss) "clause") + where + plural 1 thing = thing + plural n thing = thing ++ "s" + + CoverageIssue f pss -> fsep ( + pwords "Incomplete pattern matching for" ++ [prettyTCM f <> "."] ++ + pwords "Missing cases:") $$ nest 2 (vcat $ map display pss) + where + display (tel, ps) = prettyTCM $ NamedClause f True $ + empty { clauseTel = tel, namedClausePats = ps } + + CoverageNoExactSplit f cs -> vcat $ + [ fsep $ pwords "Exact splitting is enabled, but the following" ++ pwords (P.singPlural cs "clause" "clauses") ++ + pwords "could not be preserved as definitional equalities in the translation to a case tree:" + ] ++ + map (nest 2 . prettyTCM . NamedClause f True) cs + + NotStrictlyPositive d ocs -> fsep $ + [prettyTCM d] ++ pwords "is not strictly positive, because it occurs" + ++ [prettyTCM ocs] + + CantGeneralizeOverSorts ms -> vcat + [ text "Cannot generalize over unsolved sort metas:" + , nest 2 $ vcat [ prettyTCM x <+> text "at" <+> (pretty =<< getMetaRange x) | x <- ms ] + , fsep $ pwords "Suggestion: add a `variable Any : Set _` and replace unsolved metas by Any" + ] + + AbsurdPatternRequiresNoRHS ps -> fwords $ + "The right-hand side must be omitted if there " ++ + "is an absurd pattern, () or {}, in the left-hand side." + + OldBuiltin old new -> fwords $ + "Builtin " ++ old ++ " no longer exists. " ++ + "It is now bound by BUILTIN " ++ new + + EmptyRewritePragma -> fsep . pwords $ "Empty REWRITE pragma" + + IllformedAsClause s -> fsep . pwords $ + "`as' must be followed by an identifier" ++ s + + ClashesViaRenaming nm xs -> fsep $ concat $ + [ [ case nm of NameNotModule -> "Name"; ModuleNotName -> "Module" ] + , pwords "clashes introduced by `renaming':" + , map prettyTCM xs + ] + + UselessPublic -> fwords $ "Keyword `public' is ignored here" + + UselessInline q -> fsep $ + pwords "It is pointless for INLINE'd function" ++ [prettyTCM q] ++ + pwords "to have a separate Haskell definition" + + WrongInstanceDeclaration -> fwords "Terms marked as eligible for instance search should end with a name, so `instance' is ignored here." + + InstanceWithExplicitArg q -> fsep $ + pwords "Instance declarations with explicit arguments are never considered by instance search," ++ + pwords "so making" ++ [prettyTCM q] ++ pwords "into an instance has no effect." + + InstanceNoOutputTypeName b -> fsep $ + pwords "Instance arguments whose type does not end in a named or variable type are never considered by instance search," ++ + pwords "so having an instance argument" ++ [return b] ++ pwords "has no effect." + + InstanceArgWithExplicitArg b -> fsep $ + pwords "Instance arguments with explicit arguments are never considered by instance search," ++ + pwords "so having an instance argument" ++ [return b] ++ pwords "has no effect." + + InversionDepthReached f -> do + maxDepth <- maxInversionDepth + fsep $ pwords "Refusing to invert pattern matching of" ++ [prettyTCM f] ++ + pwords ("because the maximum depth (" ++ show maxDepth ++ ") has been reached.") ++ + pwords "Most likely this means you have an unsatisfiable constraint, but it could" ++ + pwords "also mean that you need to increase the maximum depth using the flag" ++ + pwords "--inversion-max-depth=N" + + GenericWarning d -> return d + + GenericNonFatalError d -> return d + + SafeFlagPostulate e -> fsep $ + pwords "Cannot postulate" ++ [pretty e] ++ pwords "with safe flag" + + SafeFlagPragma xs -> + let plural | length xs == 1 = "" + | otherwise = "s" + in fsep $ [fwords ("Cannot set OPTIONS pragma" ++ plural)] + ++ map text xs ++ [fwords "with safe flag."] + + SafeFlagNonTerminating -> fsep $ + pwords "Cannot use NON_TERMINATING pragma with safe flag." + + SafeFlagTerminating -> fsep $ + pwords "Cannot use TERMINATING pragma with safe flag." + + SafeFlagWithoutKFlagPrimEraseEquality -> fsep (pwords "Cannot use primEraseEquality with safe and without-K flags.") + + WithoutKFlagPrimEraseEquality -> fsep (pwords "Using primEraseEquality with the without-K flag is inconsistent.") + + SafeFlagNoPositivityCheck -> fsep $ + pwords "Cannot use NO_POSITIVITY_CHECK pragma with safe flag." + + SafeFlagPolarity -> fsep $ + pwords "Cannot use POLARITY pragma with safe flag." + + SafeFlagNoUniverseCheck -> fsep $ + pwords "Cannot use NO_UNIVERSE_CHECK pragma with safe flag." + + SafeFlagEta -> fsep $ + pwords "Cannot use ETA pragma with safe flag." + + SafeFlagInjective -> fsep $ + pwords "Cannot use INJECTIVE pragma with safe flag." + + SafeFlagNoCoverageCheck -> fsep $ + pwords "Cannot use NON_COVERING pragma with safe flag." + + ParseWarning pw -> pretty pw + + DeprecationWarning old new version -> fsep $ + [text old] ++ pwords "has been deprecated. Use" ++ [text new] ++ pwords + "instead. This will be an error in Agda" ++ [text version <> "."] + + NicifierIssue w -> sayWhere (getRange w) $ pretty w + + UserWarning str -> text str + + ModuleDoesntExport m xs -> fsep $ + pwords "The module" ++ [pretty m] ++ pwords "doesn't export the following:" ++ + punctuate comma (map pretty xs) + + FixityInRenamingModule _rs -> fsep $ pwords "Modules do not have fixity" + + LibraryWarning lw -> pretty lw + + InfectiveImport o m -> fsep $ + pwords "Importing module" ++ [pretty m] ++ pwords "using the" ++ + [pretty o] ++ pwords "flag from a module which does not." + + CoInfectiveImport o m -> fsep $ + pwords "Importing module" ++ [pretty m] ++ pwords "not using the" ++ + [pretty o] ++ pwords "flag from a module which does." + + RewriteNonConfluent lhs rhs1 rhs2 err -> fsep + [ "Confluence check failed:" + , prettyTCM lhs , "reduces to both" + , prettyTCM rhs1 , "and" , prettyTCM rhs2 + , "which are not equal because" + , return err + ] + + RewriteMaybeNonConfluent lhs1 lhs2 cs -> do + vcat $ + [ fsep + [ "Couldn't determine overlap between left-hand sides" + , prettyTCM lhs1 , "and" , prettyTCM lhs2 + , "because of unsolved constraints:" + ] + ] ++ map (nest 2 . return) cs + + PragmaCompileErased bn qn -> fsep $ + pwords "The backend" ++ [text bn] ++ pwords "erases" ++ [prettyTCM qn] + ++ pwords "so the COMPILE pragma will be ignored." + + NotInScopeW xs -> do + inscope <- Set.toList . concreteNamesInScope <$> getScope + fsep (pwords "Not in scope:") $$ nest 2 (vcat $ map (name inscope) xs) + where + name inscope x = + fsep [ pretty x + , "at" <+> prettyTCM (getRange x) + , suggestion inscope x + ] + suggestion inscope x = nest 2 $ par $ + [ "did you forget space around the ':'?" | ':' `elem` s ] ++ + [ "did you forget space around the '->'?" | List.isInfixOf "->" s ] ++ + [ sep [ "did you mean" + , nest 2 $ vcat (punctuate " or" + $ map (\ y -> text $ "'" ++ y ++ "'") ys) + <> "?" ] + | not $ null ys ] + where + s = P.prettyShow x + par [] = empty + par [d] = parens d + par ds = parens $ vcat ds + + strip x = map toLower $ filter (/= '_') $ P.prettyShow $ C.unqualify x + maxDist n = div n 3 + close a b = editDistance a b <= maxDist (length a) + ys = map P.prettyShow $ filter (close (strip x) . strip) inscope + + +prettyTCWarnings :: [TCWarning] -> TCM String +prettyTCWarnings = fmap (unlines . List.intersperse "") . prettyTCWarnings' + +prettyTCWarnings' :: [TCWarning] -> TCM [String] +prettyTCWarnings' = mapM (fmap P.render . prettyTCM) . filterTCWarnings + +-- | If there are several warnings, remove the unsolved-constraints warning +-- in case there are no interesting constraints to list. +filterTCWarnings :: [TCWarning] -> [TCWarning] +filterTCWarnings = \case + -- #4065: Always keep the only warning + [w] -> [w] + -- Andreas, 2019-09-10, issue #4065: + -- If there are several warnings, remove the unsolved-constraints warning + -- in case there are no interesting constraints to list. + ws -> (`filter` ws) $ \ w -> case tcWarning w of + UnsolvedConstraints cs -> not $ null $ filter interestingConstraint cs + _ -> True + + +-- | Turns all warnings into errors. +tcWarningsToError :: [TCWarning] -> TCM a +tcWarningsToError ws = typeError $ case ws of + [] -> SolvedButOpenHoles + _ -> NonFatalErrors ws + + +-- | Depending which flags are set, one may happily ignore some +-- warnings. + +applyFlagsToTCWarnings' :: MainInterface -> [TCWarning] -> TCM [TCWarning] +applyFlagsToTCWarnings' isMain ws = do + + -- For some reason some SafeFlagPragma seem to be created multiple times. + -- This is a way to collect all of them and remove duplicates. + let pragmas w = case tcWarning w of { SafeFlagPragma ps -> ([w], ps); _ -> ([], []) } + let sfp = case fmap List.nub (foldMap pragmas ws) of + (TCWarning r w p b:_, sfp) -> + [TCWarning r (SafeFlagPragma sfp) p b] + _ -> [] + + warnSet <- do + opts <- pragmaOptions + let warnSet = optWarningMode opts ^. warningSet + pure $ if isMain /= NotMainInterface + then Set.union warnSet unsolvedWarnings + else warnSet + + -- filter out the warnings the flags told us to ignore + let cleanUp w = let wName = warningName w in + wName /= SafeFlagPragma_ + && wName `Set.member` warnSet + && case w of + UnsolvedMetaVariables ums -> not $ null ums + UnsolvedInteractionMetas uis -> not $ null uis + UnsolvedConstraints ucs -> not $ null ucs + _ -> True + + return $ sfp ++ filter (cleanUp . tcWarning) ws + +applyFlagsToTCWarnings :: [TCWarning] -> TCM [TCWarning] +applyFlagsToTCWarnings = applyFlagsToTCWarnings' NotMainInterface diff --git a/src/full/Agda/TypeChecking/Pretty/Warning.hs-boot b/src/full/Agda/TypeChecking/Pretty/Warning.hs-boot new file mode 100644 --- /dev/null +++ b/src/full/Agda/TypeChecking/Pretty/Warning.hs-boot @@ -0,0 +1,7 @@ +module Agda.TypeChecking.Pretty.Warning where + +import Agda.TypeChecking.Monad.Base +import {-# SOURCE #-} Agda.TypeChecking.Pretty (PrettyTCM) + +instance PrettyTCM Warning + diff --git a/src/full/Agda/TypeChecking/Primitive.hs b/src/full/Agda/TypeChecking/Primitive.hs --- a/src/full/Agda/TypeChecking/Primitive.hs +++ b/src/full/Agda/TypeChecking/Primitive.hs @@ -1,2135 +1,840 @@ -{-# LANGUAGE CPP #-} -{-# LANGUAGE GeneralizedNewtypeDeriving #-} -{-# LANGUAGE UndecidableInstances #-} -{-# LANGUAGE DeriveFunctor #-} -{-# LANGUAGE DeriveFoldable #-} -{-# LANGUAGE DeriveTraversable #-} -{-# LANGUAGE NondecreasingIndentation #-} - --- ASR (2017-04-10). TODO: Is this option required by the final --- version of GHC 8.2.1 (it was required by the RC 1)? -#if __GLASGOW_HASKELL__ >= 802 -{-# OPTIONS -Wno-simplifiable-class-constraints #-} -#endif - -{-| Primitive functions, such as addition on builtin integers. --} -module Agda.TypeChecking.Primitive where - -import Control.Monad -import Control.Monad.Reader (asks) -import Control.Monad.Trans (lift) - -import Data.Char -import Data.Either (partitionEithers) -import Data.List (nub) -import Data.Map (Map) -import qualified Data.Map as Map -import Data.Set (Set) -import qualified Data.Set as Set -import Data.Maybe -import Data.Monoid -import Data.Traversable (traverse) -import Data.Monoid (mempty) -import Data.Word - -import Agda.Interaction.Options -import qualified Agda.Interaction.Options.Lenses as Lens - -import Agda.Syntax.Position -import Agda.Syntax.Common hiding (Nat) -import Agda.Syntax.Internal -import Agda.Syntax.Internal.Generic (TermLike(..)) -import Agda.Syntax.Literal -import Agda.Syntax.Concrete.Pretty () -import Agda.Syntax.Fixity - -import Agda.TypeChecking.Monad hiding (getConstInfo, typeOfConst) -import qualified Agda.TypeChecking.Monad as TCM -import Agda.TypeChecking.Monad.Builtin -import Agda.TypeChecking.Records -import Agda.TypeChecking.Reduce -import Agda.TypeChecking.Reduce.Monad as Reduce -import Agda.TypeChecking.Substitute -import Agda.TypeChecking.Telescope -import Agda.TypeChecking.Errors -import Agda.TypeChecking.Functions -import Agda.TypeChecking.Level -import Agda.TypeChecking.Quote (QuotingKit, quoteTermWithKit, quoteTypeWithKit, quoteClauseWithKit, quotingKit) -import Agda.TypeChecking.Pretty () -- instances only -import Agda.TypeChecking.Names -import Agda.TypeChecking.Warnings - -import Agda.Utils.Float -import Agda.Utils.Functor -import Agda.Utils.List -import Agda.Utils.Maybe -import Agda.Utils.Monad -import Agda.Utils.Pretty (pretty, prettyShow) -import Agda.Utils.Singleton -import Agda.Utils.Size -import Agda.Utils.String ( Str(Str), unStr ) -import Agda.Utils.Tuple - -#include "undefined.h" -import Agda.Utils.Impossible -import Debug.Trace - ------------------------------------------------------------------------- --- * Builtin Sigma ------------------------------------------------------------------------- - -data SigmaKit = SigmaKit - { sigmaName :: QName - , sigmaCon :: ConHead - , sigmaFst :: QName - , sigmaSnd :: QName - } - deriving (Eq,Show) - -getSigmaKit :: (HasBuiltins m, HasConstInfo m) => m (Maybe SigmaKit) -getSigmaKit = do - ms <- getBuiltinName' builtinSigma - case ms of - Nothing -> return Nothing - Just sigma -> do - def <- theDef <$> getConstInfo sigma - case def of - Record { recFields = [fst,snd], recConHead = con } -> do - return . Just $ SigmaKit - { sigmaName = sigma - , sigmaCon = con - , sigmaFst = unArg fst - , sigmaSnd = unArg snd - } - _ -> __IMPOSSIBLE__ - ---------------------------------------------------------------------------- --- * Primitive functions ---------------------------------------------------------------------------- - -data PrimitiveImpl = PrimImpl Type PrimFun - --- Haskell type to Agda type - -newtype Nat = Nat { unNat :: Integer } - deriving (Eq, Ord, Num, Enum, Real) - --- In GHC > 7.8 deriving Integral causes an unnecessary toInteger --- warning. -instance Integral Nat where - toInteger = unNat - quotRem (Nat a) (Nat b) = (Nat q, Nat r) - where (q, r) = quotRem a b - -instance TermLike Nat where - traverseTermM _ = pure - foldTerm _ = mempty - -instance Show Nat where - show = show . toInteger - -newtype Lvl = Lvl { unLvl :: Integer } - deriving (Eq, Ord) - -instance Show Lvl where - show = show . unLvl - -class PrimType a where - primType :: a -> TCM Type - -instance (PrimType a, PrimType b) => PrimTerm (a -> b) where - primTerm _ = unEl <$> (primType (undefined :: a) --> primType (undefined :: b)) - -instance PrimTerm a => PrimType a where - primType _ = el $ primTerm (undefined :: a) - -class PrimTerm a where primTerm :: a -> TCM Term -instance PrimTerm Integer where primTerm _ = primInteger -instance PrimTerm Word64 where primTerm _ = primWord64 -instance PrimTerm Bool where primTerm _ = primBool -instance PrimTerm Char where primTerm _ = primChar -instance PrimTerm Double where primTerm _ = primFloat -instance PrimTerm Str where primTerm _ = primString -instance PrimTerm Nat where primTerm _ = primNat -instance PrimTerm Lvl where primTerm _ = primLevel -instance PrimTerm QName where primTerm _ = primQName -instance PrimTerm MetaId where primTerm _ = primAgdaMeta -instance PrimTerm Type where primTerm _ = primAgdaTerm - -instance PrimTerm Fixity' where primTerm _ = primFixity - -instance PrimTerm a => PrimTerm [a] where - primTerm _ = list (primTerm (undefined :: a)) - -instance PrimTerm a => PrimTerm (IO a) where - primTerm _ = io (primTerm (undefined :: a)) - --- From Agda term to Haskell value - -class ToTerm a where - toTerm :: TCM (a -> Term) - toTermR :: TCM (a -> ReduceM Term) - - toTermR = (pure .) <$> toTerm - -instance ToTerm Nat where toTerm = return $ Lit . LitNat noRange . toInteger -instance ToTerm Word64 where toTerm = return $ Lit . LitWord64 noRange -instance ToTerm Lvl where toTerm = return $ Level . Max . (:[]) . ClosedLevel . unLvl -instance ToTerm Double where toTerm = return $ Lit . LitFloat noRange -instance ToTerm Char where toTerm = return $ Lit . LitChar noRange -instance ToTerm Str where toTerm = return $ Lit . LitString noRange . unStr -instance ToTerm QName where toTerm = return $ Lit . LitQName noRange -instance ToTerm MetaId where - toTerm = do - file <- getCurrentPath - return $ Lit . LitMeta noRange file - -instance ToTerm Integer where - toTerm = do - pos <- primIntegerPos - negsuc <- primIntegerNegSuc - fromNat <- toTerm :: TCM (Nat -> Term) - let intToTerm = fromNat . fromIntegral :: Integer -> Term - let fromInt n | n >= 0 = apply pos [defaultArg $ intToTerm n] - | otherwise = apply negsuc [defaultArg $ intToTerm (-n - 1)] - return fromInt - -instance ToTerm Bool where - toTerm = do - true <- primTrue - false <- primFalse - return $ \b -> if b then true else false - -instance ToTerm Term where - toTerm = do kit <- quotingKit; runReduceF (quoteTermWithKit kit) - toTermR = do kit <- quotingKit; return (quoteTermWithKit kit) - -instance ToTerm Type where - toTerm = do kit <- quotingKit; runReduceF (quoteTypeWithKit kit) - toTermR = do kit <- quotingKit; return (quoteTypeWithKit kit) - -instance ToTerm ArgInfo where - toTerm = do - info <- primArgArgInfo - vis <- primVisible - hid <- primHidden - ins <- primInstance - rel <- primRelevant - irr <- primIrrelevant - return $ \ i -> info `applys` - [ case getHiding i of - NotHidden -> vis - Hidden -> hid - Instance{} -> ins - , case getRelevance i of - Relevant -> rel - Irrelevant -> irr - NonStrict -> rel - ] - -instance ToTerm Fixity' where - toTerm = (. theFixity) <$> toTerm - -instance ToTerm Fixity where - toTerm = do - lToTm <- toTerm - aToTm <- toTerm - fixity <- primFixityFixity - return $ \ Fixity{fixityAssoc = a, fixityLevel = l} -> - fixity `apply` [defaultArg (aToTm a), defaultArg (lToTm l)] - -instance ToTerm Associativity where - toTerm = do - lassoc <- primAssocLeft - rassoc <- primAssocRight - nassoc <- primAssocNon - return $ \ a -> - case a of - NonAssoc -> nassoc - LeftAssoc -> lassoc - RightAssoc -> rassoc - -instance ToTerm PrecedenceLevel where - toTerm = do - (iToTm :: Integer -> Term) <- toTerm - related <- primPrecRelated - unrelated <- primPrecUnrelated - return $ \ p -> - case p of - Unrelated -> unrelated - Related n -> related `apply` [defaultArg $ iToTm n] - --- | @buildList A ts@ builds a list of type @List A@. Assumes that the terms --- @ts@ all have type @A@. -buildList :: TCM ([Term] -> Term) -buildList = do - nil' <- primNil - cons' <- primCons - let nil = nil' - cons x xs = cons' `applys` [x, xs] - return $ foldr cons nil - -instance ToTerm a => ToTerm [a] where - toTerm = do - mkList <- buildList - fromA <- toTerm - return $ mkList . map fromA - --- From Haskell value to Agda term - -type FromTermFunction a = Arg Term -> - ReduceM (Reduced (MaybeReduced (Arg Term)) a) - -class FromTerm a where - fromTerm :: TCM (FromTermFunction a) - -instance FromTerm Integer where - fromTerm = do - Con pos _ [] <- primIntegerPos - Con negsuc _ [] <- primIntegerNegSuc - toNat <- fromTerm :: TCM (FromTermFunction Nat) - return $ \ v -> do - b <- reduceB' v - let v' = ignoreBlocking b - arg = (<$ v') - case unArg (ignoreBlocking b) of - Con c ci [Apply u] - | c == pos -> - redBind (toNat u) - (\ u' -> notReduced $ arg $ Con c ci [Apply $ ignoreReduced u']) $ \ n -> - redReturn $ fromIntegral n - | c == negsuc -> - redBind (toNat u) - (\ u' -> notReduced $ arg $ Con c ci [Apply $ ignoreReduced u']) $ \ n -> - redReturn $ fromIntegral $ -n - 1 - _ -> return $ NoReduction (reduced b) - -instance FromTerm Nat where - fromTerm = fromLiteral $ \l -> case l of - LitNat _ n -> Just $ fromInteger n - _ -> Nothing - -instance FromTerm Word64 where - fromTerm = fromLiteral $ \ case - LitWord64 _ n -> Just n - _ -> Nothing - -instance FromTerm Lvl where - fromTerm = fromReducedTerm $ \l -> case l of - Level (Max [ClosedLevel n]) -> Just $ Lvl n - _ -> Nothing - -instance FromTerm Double where - fromTerm = fromLiteral $ \l -> case l of - LitFloat _ x -> Just x - _ -> Nothing - -instance FromTerm Char where - fromTerm = fromLiteral $ \l -> case l of - LitChar _ c -> Just c - _ -> Nothing - -instance FromTerm Str where - fromTerm = fromLiteral $ \l -> case l of - LitString _ s -> Just $ Str s - _ -> Nothing - -instance FromTerm QName where - fromTerm = fromLiteral $ \l -> case l of - LitQName _ x -> Just x - _ -> Nothing - -instance FromTerm MetaId where - fromTerm = fromLiteral $ \l -> case l of - LitMeta _ _ x -> Just x - _ -> Nothing - -instance FromTerm Bool where - fromTerm = do - true <- primTrue - false <- primFalse - fromReducedTerm $ \t -> case t of - _ | t =?= true -> Just True - | t =?= false -> Just False - | otherwise -> Nothing - where - a =?= b = a === b - Def x [] === Def y [] = x == y - Con x _ [] === Con y _ [] = x == y - Var n [] === Var m [] = n == m - _ === _ = False - -instance (ToTerm a, FromTerm a) => FromTerm [a] where - fromTerm = do - nil' <- primNil - cons' <- primCons - nil <- isCon nil' - cons <- isCon cons' - toA <- fromTerm - fromA <- toTerm - return $ mkList nil cons toA fromA - where - isCon (Lam _ b) = isCon $ absBody b - isCon (Con c _ _)= return c - isCon v = __IMPOSSIBLE__ - - mkList nil cons toA fromA t = do - b <- reduceB' t - let t = ignoreBlocking b - let arg = (<$ t) - case unArg t of - Con c ci [] - | c == nil -> return $ YesReduction NoSimplification [] - Con c ci es - | c == cons, Just [x,xs] <- allApplyElims es -> - redBind (toA x) - (\x' -> notReduced $ arg $ Con c ci (map Apply [ignoreReduced x',xs])) $ \y -> - redBind - (mkList nil cons toA fromA xs) - (fmap $ \xs' -> arg $ Con c ci (map Apply [defaultArg $ fromA y, xs'])) $ \ys -> - redReturn (y : ys) - _ -> return $ NoReduction (reduced b) - --- | Conceptually: @redBind m f k = either (return . Left . f) k =<< m@ -redBind :: ReduceM (Reduced a a') -> (a -> b) -> - (a' -> ReduceM (Reduced b b')) -> ReduceM (Reduced b b') -redBind ma f k = do - r <- ma - case r of - NoReduction x -> return $ NoReduction $ f x - YesReduction _ y -> k y - -redReturn :: a -> ReduceM (Reduced a' a) -redReturn = return . YesReduction YesSimplification - -fromReducedTerm :: (Term -> Maybe a) -> TCM (FromTermFunction a) -fromReducedTerm f = return $ \t -> do - b <- reduceB' t - case f $ unArg (ignoreBlocking b) of - Just x -> return $ YesReduction NoSimplification x - Nothing -> return $ NoReduction (reduced b) - -fromLiteral :: (Literal -> Maybe a) -> TCM (FromTermFunction a) -fromLiteral f = fromReducedTerm $ \t -> case t of - Lit lit -> f lit - _ -> Nothing - -requireCubical :: TCM () -requireCubical = do - cubical <- optCubical <$> pragmaOptions - unless cubical $ - typeError $ GenericError "Missing option --cubical" - -primINeg' :: TCM PrimitiveImpl -primINeg' = do - requireCubical - t <- elInf primInterval --> elInf primInterval - return $ PrimImpl t $ primFun __IMPOSSIBLE__ 1 $ \ ts -> do - case ts of - [x] -> do - unview <- intervalUnview' - view <- intervalView' - sx <- reduceB' x - ix <- intervalView (unArg $ ignoreBlocking sx) - let - ineg :: Arg Term -> Arg Term - ineg = fmap (unview . f . view) - f ix = case ix of - IZero -> IOne - IOne -> IZero - IMin x y -> IMax (ineg x) (ineg y) - IMax x y -> IMin (ineg x) (ineg y) - INeg x -> OTerm (unArg x) - OTerm t -> INeg (Arg defaultArgInfo t) - case ix of - OTerm t -> return $ NoReduction [reduced sx] - _ -> redReturn (unview $ f ix) - _ -> __IMPOSSIBLE__ - -primDepIMin' :: TCM PrimitiveImpl -primDepIMin' = do - requireCubical - t <- runNamesT [] $ - nPi' "φ" (elInf $ cl primInterval) $ \ φ -> - (pPi' "o" φ $ \ o -> elInf $ cl primInterval) --> elInf (cl primInterval) - return $ PrimImpl t $ primFun __IMPOSSIBLE__ 2 $ \ ts -> do - case ts of - [x,y] -> do - sx <- reduceB' x - ix <- intervalView (unArg $ ignoreBlocking sx) - itisone <- getTerm "primDepIMin" builtinItIsOne - case ix of - IZero -> redReturn =<< intervalUnview IZero - IOne -> redReturn =<< (pure (unArg y) <@> pure itisone) - _ -> do - sy <- reduceB' y - iy <- intervalView =<< reduce' =<< (pure (unArg $ ignoreBlocking sy) <@> pure itisone) - case iy of - IZero -> redReturn =<< intervalUnview IZero - IOne -> redReturn (unArg $ ignoreBlocking sx) - _ -> return $ NoReduction [reduced sx, reduced sy] - _ -> __IMPOSSIBLE__ - -primIBin :: IntervalView -> IntervalView -> TCM PrimitiveImpl -primIBin unit absorber = do - requireCubical - t <- elInf primInterval --> elInf primInterval --> elInf primInterval - return $ PrimImpl t $ primFun __IMPOSSIBLE__ 2 $ \ ts -> do - case ts of - [x,y] -> do - sx <- reduceB' x - ix <- intervalView (unArg $ ignoreBlocking sx) - case ix of - ix | ix ==% absorber -> redReturn =<< intervalUnview absorber - ix | ix ==% unit -> return $ YesReduction YesSimplification (unArg y) - _ -> do - sy <- reduceB' y - iy <- intervalView (unArg $ ignoreBlocking sy) - case iy of - iy | iy ==% absorber -> redReturn =<< intervalUnview absorber - iy | iy ==% unit -> return $ YesReduction YesSimplification (unArg x) - _ -> return $ NoReduction [reduced sx,reduced sy] - _ -> __IMPOSSIBLE__ - where - (==%) IZero IZero = True - (==%) IOne IOne = True - (==%) _ _ = False - - -primIMin' :: TCM PrimitiveImpl -primIMin' = primIBin IOne IZero - -primIMax' :: TCM PrimitiveImpl -primIMax' = primIBin IZero IOne - -imax :: HasBuiltins m => m Term -> m Term -> m Term -imax x y = do - x' <- x - y' <- y - intervalUnview (IMax (argN x') (argN y')) - -imin :: HasBuiltins m => m Term -> m Term -> m Term -imin x y = do - x' <- x - y' <- y - intervalUnview (IMin (argN x') (argN y')) - --- ∀ {a}{c}{A : Set a}{x : A}(C : ∀ y → Id x y → Set c) → C x (conid i1 (\ i → x)) → ∀ {y} (p : Id x y) → C y p -primIdJ :: TCM PrimitiveImpl -primIdJ = do - requireCubical - t <- runNamesT [] $ - hPi' "a" (el $ cl primLevel) $ \ a -> - hPi' "c" (el $ cl primLevel) $ \ c -> - hPi' "A" (sort . tmSort <$> a) $ \ bA -> - hPi' "x" (el' a bA) $ \ x -> - nPi' "C" (nPi' "y" (el' a bA) $ \ y -> - (el' a $ cl primId <#> a <#> bA <@> x <@> y) --> (sort . tmSort <$> c)) $ \ bC -> - (el' c $ bC <@> x <@> - (cl primConId <#> a <#> bA <#> x <#> x <@> cl primIOne - <@> lam "i" (\ _ -> x))) --> - (hPi' "y" (el' a bA) $ \ y -> - nPi' "p" (el' a $ cl primId <#> a <#> bA <@> x <@> y) $ \ p -> - el' c $ bC <@> y <@> p) - conidn <- getBuiltinName builtinConId - conid <- primConId - -- TODO make a kit - return $ PrimImpl t $ primFun __IMPOSSIBLE__ 8 $ \ ts -> do - unview <- intervalUnview' - let imax x y = do x' <- x; y' <- y; pure $ unview (IMax (argN x') (argN y')) - imin x y = do x' <- x; y' <- y; pure $ unview (IMin (argN x') (argN y')) - ineg x = unview . INeg . argN <$> x - mcomp <- getTerm' "primComp" - case ts of - [la,lc,a,x,c,d,y,eq] -> do - seq <- reduceB' eq - case unArg $ ignoreBlocking $ seq of - (Def q [Apply la,Apply a,Apply x,Apply y,Apply phi,Apply p]) - | Just q == conidn, Just comp <- mcomp -> do - redReturn $ runNames [] $ do - [lc,c,d,la,a,x,y,phi,p] <- mapM (open . unArg) [lc,c,d,la,a,x,y,phi,p] - let w i = do - [x,y,p,i] <- sequence [x,y,p,i] - pure $ p `applyE` [IApply x y i] - pure comp <#> (lam "i" $ \ _ -> lc) - <@> (lam "i" $ \ i -> - c <@> (w i) - <@> (pure conid <#> la <#> a <#> x <#> (w i) - <@> (phi `imax` ineg i) - <@> (lam "j" $ \ j -> w $ imin i j))) - <@> phi - <@> (lam "i" $ \ _ -> nolam <$> d) -- TODO block - <@> d - _ -> return $ NoReduction $ map notReduced [la,lc,a,x,c,d,y] ++ [reduced seq] - _ -> __IMPOSSIBLE__ - -primIdElim' :: TCM PrimitiveImpl -primIdElim' = do - requireCubical - t <- runNamesT [] $ - hPi' "a" (el $ cl primLevel) $ \ a -> - hPi' "c" (el $ cl primLevel) $ \ c -> - hPi' "A" (sort . tmSort <$> a) $ \ bA -> - hPi' "x" (el' a bA) $ \ x -> - nPi' "C" (nPi' "y" (el' a bA) $ \ y -> - (el' a $ cl primId <#> a <#> bA <@> x <@> y) --> (sort . tmSort <$> c)) $ \ bC -> - (nPi' "φ" (elInf $ cl primInterval) $ \ phi -> - nPi' "y" (elInf $ cl primSub <#> a <@> bA <@> phi <@> (lam "o" $ const x)) $ \ y -> - let pathxy = (cl primPath <#> a <@> bA <@> x <@> oucy) - oucy = (cl primSubOut <#> a <#> bA <#> phi <#> (lam "o" $ const x) <@> y) - reflx = (lam "o" $ \ _ -> lam "i" $ \ _ -> x) -- TODO Andrea, should block on o - in - nPi' "w" (elInf $ cl primSub <#> a <@> pathxy <@> phi <@> reflx) $ \ w -> - let oucw = (cl primSubOut <#> a <#> pathxy <#> phi <#> reflx <@> w) in - el' c $ bC <@> oucy <@> (cl primConId <#> a <#> bA <#> x <#> oucy <@> phi <@> oucw)) - --> - (hPi' "y" (el' a bA) $ \ y -> - nPi' "p" (el' a $ cl primId <#> a <#> bA <@> x <@> y) $ \ p -> - el' c $ bC <@> y <@> p) - conid <- primConId - sin <- primSubIn - path <- primPath - return $ PrimImpl t $ primFun __IMPOSSIBLE__ 8 $ \ ts -> do - case ts of - [a,c,bA,x,bC,f,y,p] -> do - sp <- reduceB' p - case unArg $ ignoreBlocking sp of - Def q [Apply _a, Apply _bA, Apply _x, Apply _y, Apply phi , Apply w] -> do - y' <- return $ sin `apply` [a,bA ,phi,argN $ unArg y] - w' <- return $ sin `apply` [a,argN $ path `apply` [a,bA,x,y],phi,argN $ unArg w] - redReturn $ unArg f `apply` [phi, defaultArg y', defaultArg w'] - _ -> return $ NoReduction $ map notReduced [a,c,bA,x,bC,f,y] ++ [reduced sp] - _ -> __IMPOSSIBLE__ - - -primPOr :: TCM PrimitiveImpl -primPOr = do - requireCubical - t <- runNamesT [] $ - hPi' "a" (el $ cl primLevel) $ \ a -> - nPi' "i" (elInf $ cl primInterval) $ \ i -> - nPi' "j" (elInf $ cl primInterval) $ \ j -> - hPi' "A" (pPi' "o" (imax i j) $ \o -> el' (cl primLevelSuc <@> a) (Sort . tmSort <$> a)) $ \ bA -> - ((pPi' "i1" i $ \ i1 -> el' a $ bA <..> (cl primIsOne1 <@> i <@> j <@> i1))) --> - ((pPi' "j1" j $ \ j1 -> el' a $ bA <..> (cl primIsOne2 <@> i <@> j <@> j1))) --> - (pPi' "o" (imax i j) $ \ o -> el' a $ bA <..> o) - return $ PrimImpl t $ primFun __IMPOSSIBLE__ 6 $ \ ts -> do - case ts of - [l,i,j,a,u,v] -> do - si <- reduceB' i - vi <- intervalView $ unArg $ ignoreBlocking si - case vi of - IOne -> redReturn (unArg u) - IZero -> redReturn (unArg v) - _ -> do - sj <- reduceB' j - vj <- intervalView $ unArg $ ignoreBlocking sj - case vj of - IOne -> redReturn (unArg v) - IZero -> redReturn (unArg u) - _ -> return $ NoReduction [notReduced l,reduced si,reduced sj,notReduced a,notReduced u,notReduced v] - - - _ -> __IMPOSSIBLE__ - -primPartial' :: TCM PrimitiveImpl -primPartial' = do - requireCubical - t <- runNamesT [] $ - (hPi' "a" (el $ cl primLevel) $ \ a -> - nPi' "φ" (elInf (cl primInterval)) $ \ _ -> - nPi' "A" (sort . tmSort <$> a) $ \ bA -> - return (sort $ Inf)) - isOne <- primIsOne - return $ PrimImpl t $ primFun __IMPOSSIBLE__ 3 $ \ ts -> do - case ts of - [l,phi,a] -> do - (El s (Pi d b)) <- runNamesT [] $ do - [l,a,phi] <- mapM (open . unArg) [l,a,phi] - (elInf $ pure isOne <@> phi) --> el' l a - redReturn $ Pi (setRelevance Irrelevant $ d { domFinite = True }) b - _ -> __IMPOSSIBLE__ - -primPartialP' :: TCM PrimitiveImpl -primPartialP' = do - requireCubical - t <- runNamesT [] $ - (hPi' "a" (el $ cl primLevel) $ \ a -> - nPi' "φ" (elInf (cl primInterval)) $ \ phi -> - nPi' "A" (pPi' "o" phi $ \ _ -> el' (cl primLevelSuc <@> a) (Sort . tmSort <$> a)) $ \ bA -> - return (sort $ Inf)) - let toFinitePi :: Type -> Term - toFinitePi (El _ (Pi d b)) = Pi (setRelevance Irrelevant $ d { domFinite = True }) b - toFinitePi _ = __IMPOSSIBLE__ - v <- runNamesT [] $ - lam "a" $ \ l -> - lam "φ" $ \ phi -> - lam "A" $ \ a -> - toFinitePi <$> nPi' "p" (elInf $ cl primIsOne <@> phi) (\ p -> el' l (a <@> p)) - return $ PrimImpl t $ primFun __IMPOSSIBLE__ 0 $ \ _ -> redReturn v - -primSubOut' :: TCM PrimitiveImpl -primSubOut' = do - requireCubical - t <- runNamesT [] $ - hPi' "a" (el $ cl primLevel) $ \ a -> - hPi' "A" (el' (cl primLevelSuc <@> a) (Sort . tmSort <$> a)) $ \ bA -> - hPi' "φ" (elInf $ cl primInterval) $ \ phi -> - hPi' "u" (elInf $ cl primPartial <#> a <@> phi <@> bA) $ \ u -> - elInf (cl primSub <#> a <@> bA <@> phi <@> u) --> el' (Sort . tmSort <$> a) bA - return $ PrimImpl t $ primFun __IMPOSSIBLE__ 5 $ \ ts -> do - case ts of - [a,bA,phi,u,x] -> do - view <- intervalView' - sphi <- reduceB' phi - case view $ unArg $ ignoreBlocking sphi of - IOne -> redReturn =<< (return (unArg u) <..> (getTerm builtinSubOut builtinItIsOne)) - _ -> do - sx <- reduceB' x - mSubIn <- getBuiltinName' builtinSubIn - case unArg $ ignoreBlocking $ sx of - Def q [_,_,_, Apply t] | Just q == mSubIn -> redReturn (unArg t) - _ -> return $ NoReduction $ map notReduced [a,bA] ++ [reduced sphi, notReduced u, reduced sx] - _ -> __IMPOSSIBLE__ - -primIdFace' :: TCM PrimitiveImpl -primIdFace' = do - requireCubical - t <- runNamesT [] $ - hPi' "a" (el $ cl primLevel) $ \ a -> - hPi' "A" (sort . tmSort <$> a) $ \ bA -> - hPi' "x" (el' a bA) $ \ x -> - hPi' "y" (el' a bA) $ \ y -> - (el' a $ cl primId <#> a <#> bA <@> x <@> y) - --> elInf (cl primInterval) - return $ PrimImpl t $ primFun __IMPOSSIBLE__ 5 $ \ ts -> do - case ts of - [l,bA,x,y,t] -> do - st <- reduceB' t - mConId <- getName' builtinConId - case unArg (ignoreBlocking st) of - Def q [_,_,_,_, Apply phi,_] | Just q == mConId -> redReturn (unArg phi) - _ -> return $ NoReduction $ map notReduced [l,bA,x,y] ++ [reduced st] - _ -> __IMPOSSIBLE__ - -primIdPath' :: TCM PrimitiveImpl -primIdPath' = do - requireCubical - t <- runNamesT [] $ - hPi' "a" (el $ cl primLevel) $ \ a -> - hPi' "A" (sort . tmSort <$> a) $ \ bA -> - hPi' "x" (el' a bA) $ \ x -> - hPi' "y" (el' a bA) $ \ y -> - (el' a $ cl primId <#> a <#> bA <@> x <@> y) - --> (el' a $ cl primPath <#> a <#> bA <@> x <@> y) - return $ PrimImpl t $ primFun __IMPOSSIBLE__ 5 $ \ ts -> do - case ts of - [l,bA,x,y,t] -> do - st <- reduceB' t - mConId <- getName' builtinConId - case unArg (ignoreBlocking st) of - Def q [_,_,_,_,_,Apply w] | Just q == mConId -> redReturn (unArg w) - _ -> return $ NoReduction $ map notReduced [l,bA,x,y] ++ [reduced st] - _ -> __IMPOSSIBLE__ - - -primTrans' :: TCM PrimitiveImpl -primTrans' = do - requireCubical - t <- runNamesT [] $ - hPi' "a" (elInf (cl primInterval) --> (el $ cl primLevel)) $ \ a -> - nPi' "A" (nPi' "i" (elInf (cl primInterval)) $ \ i -> (sort . tmSort <$> (a <@> i))) $ \ bA -> - nPi' "φ" (elInf $ cl primInterval) $ \ phi -> - (el' (a <@> cl primIZero) (bA <@> cl primIZero) --> el' (a <@> cl primIOne) (bA <@> cl primIOne)) - return $ PrimImpl t $ PrimFun __IMPOSSIBLE__ 4 $ \ ts nelims -> do - primTransHComp DoTransp ts nelims - -primHComp' :: TCM PrimitiveImpl -primHComp' = do - requireCubical - t <- runNamesT [] $ - hPi' "a" (el $ cl primLevel) $ \ a -> - hPi' "A" (sort . tmSort <$> a) $ \ bA -> - hPi' "φ" (elInf $ cl primInterval) $ \ phi -> - (nPi' "i" (elInf $ cl primInterval) $ \ i -> pPi' "o" phi $ \ _ -> el' a bA) --> - (el' a bA --> el' a bA) - return $ PrimImpl t $ PrimFun __IMPOSSIBLE__ 5 $ \ ts nelims -> do - primTransHComp DoHComp ts nelims - -data TranspOrHComp = DoTransp | DoHComp deriving (Eq,Show) - -cmdToName :: TranspOrHComp -> String -cmdToName DoTransp = builtinTrans -cmdToName DoHComp = builtinHComp - -data FamilyOrNot a = IsFam {famThing :: a} | IsNot {famThing :: a} deriving (Eq,Show,Functor,Foldable,Traversable) - -instance Reduce a => Reduce (FamilyOrNot a) where - reduceB' x = traverse id <$> traverse reduceB' x - reduce' x = traverse reduce' x - -primTransHComp :: TranspOrHComp -> [Arg Term] -> Int -> ReduceM (Reduced MaybeReducedArgs Term) -primTransHComp cmd ts nelims = do - (l,bA,phi,u,u0) <- case (cmd,ts) of - (DoTransp, [l,bA,phi, u0]) -> do - -- u <- runNamesT [] $ do - -- u0 <- open $ unArg u0 - -- defaultArg <$> (ilam "o" $ \ _ -> u0) - return $ (IsFam l,IsFam bA,phi,Nothing,u0) - (DoHComp, [l,bA,phi,u,u0]) -> do - -- [l,bA] <- runNamesT [] $ do - -- forM [l,bA] $ \ a -> do - -- let info = argInfo a - -- a <- open $ unArg a - -- Arg info <$> (lam "i" $ \ _ -> a) - return $ (IsNot l,IsNot bA,phi,Just u,u0) - _ -> __IMPOSSIBLE__ - sphi <- reduceB' phi - vphi <- intervalView $ unArg $ ignoreBlocking sphi - let clP s = getTerm (cmdToName cmd) s - - -- WORK - case vphi of - IOne -> redReturn =<< case u of - -- cmd == DoComp - Just u -> runNamesT [] $ do - u <- open (unArg u) - u <@> clP builtinIOne <..> clP builtinItIsOne - -- cmd == DoTransp - Nothing -> return $ unArg u0 - _ -> do - let fallback' sc = do - u' <- case u of - -- cmd == DoComp - Just u -> - (:[]) <$> case vphi of - IZero -> fmap (reduced . notBlocked . argN) . runNamesT [] $ do - [l,c] <- mapM (open . unArg) [famThing l, ignoreBlocking sc] - lam "i" $ \ i -> clP builtinIsOneEmpty <#> l - <#> (ilam "o" $ \ _ -> c) - _ -> return (notReduced u) - -- cmd == DoTransp - Nothing -> return [] - return $ NoReduction $ [notReduced (famThing l), reduced sc, reduced sphi] ++ u' ++ [notReduced u0] - sbA <- reduceB' bA - t <- case unArg <$> ignoreBlocking sbA of - IsFam (Lam _info t) -> Just . fmap IsFam <$> reduceB' (absBody t) - IsFam _ -> return Nothing - IsNot t -> return . Just . fmap IsNot $ (t <$ sbA) - case t of - Nothing -> fallback' (famThing <$> sbA) - Just st -> do - let - fallback = fallback' (fmap famThing $ st *> sbA) - t = ignoreBlocking st - mGlue <- getPrimitiveName' builtinGlue - mId <- getBuiltinName' builtinId - pathV <- pathView' - case famThing t of - MetaV m _ -> fallback' (fmap famThing $ Blocked m () *> sbA) - -- absName t instead of "i" - Pi a b | nelims > 0 -> maybe fallback redReturn =<< compPi cmd "i" ((a,b) <$ t) (ignoreBlocking sphi) u u0 - | otherwise -> fallback - - Sort (Type l) -> compSort cmd fallback phi u u0 (l <$ t) - - Def q [Apply la, Apply lb, Apply bA, Apply phi', Apply bT, Apply e] | Just q == mGlue -> do - compGlue cmd phi u u0 ((la, lb, bA, phi', bT, e) <$ t) - - -- Path/PathP - d | PathType _ _ _ bA x y <- pathV (El __DUMMY_SORT__ d) -> do - if nelims > 0 then compPathP cmd sphi u u0 l ((bA, x, y) <$ t) else fallback - - Def q [Apply _ , Apply bA , Apply x , Apply y] | Just q == mId -> do - maybe fallback return =<< compId cmd sphi u u0 l ((bA, x, y) <$ t) - - Def q es -> do - info <- getConstInfo q - let lam_i = Lam defaultArgInfo . Abs "i" - - case theDef info of - r@Record{recComp = kit} | nelims > 0, Just as <- allApplyElims es, DoTransp <- cmd, Just transpR <- nameOfTransp kit - -> if recPars r == 0 - then redReturn $ unArg u0 - else redReturn $ (Def transpR []) `apply` - (map (fmap lam_i) as ++ [ignoreBlocking sphi,u0]) - | nelims > 0, Just as <- allApplyElims es, DoHComp <- cmd, Just hCompR <- nameOfHComp kit - -> redReturn $ (Def hCompR []) `apply` - (as ++ [ignoreBlocking sphi,fromMaybe __IMPOSSIBLE__ u,u0]) - - | Just as <- allApplyElims es, [] <- recFields r -> compData False (recPars r) cmd l (as <$ t) sbA sphi u u0 - Datatype{dataPars = pars, dataIxs = ixs, dataPathCons = pcons} - | and [null pcons | DoHComp <- [cmd]], Just as <- allApplyElims es -> compData (not $ null $ pcons) (pars+ixs) cmd l (as <$ t) sbA sphi u u0 - -- postulates with no arguments do not need to transport. - Axiom{} | [] <- es, DoTransp <- cmd -> redReturn $ unArg u0 - _ -> fallback - - _ -> fallback - where - compSort DoTransp fallback phi Nothing u0 (IsFam l) = do - -- TODO should check l is constant - redReturn $ unArg u0 - compSort DoHComp fallback phi (Just u) u0 (IsNot l) = do - let getTermLocal = getTerm (builtinHComp ++ " for Set") - checkPrims <- all isJust <$> sequence [getTerm' builtinPathToEquiv, getTerm' builtinGlue] - if not checkPrims then fallback else (redReturn =<<) . runNamesT [] $ do - p2equiv <- getTermLocal builtinPathToEquiv - tGlue <- getTermLocal builtinGlue - tINeg <- getTermLocal builtinINeg - io <- getTermLocal builtinIOne - l <- open $ Level l - [phi,e,u0] <- mapM (open . unArg) [phi,u,u0] - let - ineg r = pure tINeg <@> r - pure tGlue <#> l <#> l - <@> u0 <#> phi <@> (e <@> pure io) - <@> ilam "o" (\ o -> pure p2equiv <#> (lam "i" $ \ i -> l) <@> (ilam "i" $ \ i -> e <@> ineg i <@> o)) - compSort _ fallback phi u u0 _ = __IMPOSSIBLE__ - compGlue DoHComp psi (Just u) u0 (IsNot (la, lb, bA, phi, bT, e)) = do - let getTermLocal = getTerm $ (builtinHComp ++ " for " ++ builtinGlue) - tPOr <- getTermLocal "primPOr" - tIMax <- getTermLocal builtinIMax - tIMin <- getTermLocal builtinIMin - tINeg <- getTermLocal builtinINeg - tHComp <- getTermLocal builtinHComp - tEFun <- getTermLocal builtinEquivFun - tglue <- getTermLocal builtin_glue - tunglue <- getTermLocal builtin_unglue - io <- getTermLocal builtinIOne - (redReturn =<<) . runNamesT [] $ do - [psi, u, u0] <- mapM (open . unArg) [psi, u, u0] - [la, lb, bA, phi, bT, e] <- mapM (open . unArg) [la, lb, bA, phi, bT, e] - let - hfill la bA phi u u0 i = pure tHComp <#> la - <#> bA - <#> (pure tIMax <@> phi <@> (pure tINeg <@> i)) - <@> (lam "j" $ \ j -> pure tPOr <#> la <@> phi <@> (pure tINeg <@> i) <@> (ilam "o" $ \ a -> bA) - <@> (ilam "o" $ \ o -> u <@> (pure tIMin <@> i <@> j) <..> o) - <@> (ilam "o" $ \ _ -> u0) - ) - <@> u0 - tf i o = hfill lb (bT <..> o) psi u u0 i - unglue g = pure tunglue <#> la <#> lb <#> bA <#> phi <#> bT <#> e <@> g - a1 = pure tHComp <#> la <#> bA <#> (pure tIMax <@> psi <@> phi) - <@> (lam "i" $ \ i -> pure tPOr <#> la <@> psi <@> phi <@> (ilam "_" $ \ _ -> bA) - <@> (ilam "o" $ \ o -> unglue (u <@> i <..> o)) - <@> (ilam "o" $ \ o -> pure tEFun <#> lb <#> la <#> (bT <..> o) <#> bA <@> (e <..> o) <@> tf i o) - ) - <@> (unglue u0) - t1 = tf (pure io) - pure tglue <#> la <#> lb <#> bA <#> phi <#> bT <#> e <@> (ilam "o" $ \ o -> t1 o) <@> a1 - compGlue DoTransp psi Nothing u0 (IsFam (la, lb, bA, phi, bT, e)) = do - let getTermLocal = getTerm $ (builtinTrans ++ " for " ++ builtinGlue) - tPOr <- getTermLocal "primPOr" - tIMax <- getTermLocal builtinIMax - tIMin <- getTermLocal builtinIMin - tINeg <- getTermLocal builtinINeg - tHComp <- getTermLocal builtinHComp - tTrans <- getTermLocal builtinTrans - tForall <- getTermLocal builtinFaceForall - tEFun <- getTermLocal builtinEquivFun - tEProof <- getTermLocal builtinEquivProof - tglue <- getTermLocal builtin_glue - tunglue <- getTermLocal builtin_unglue - io <- getTermLocal builtinIOne - iz <- getTermLocal builtinIZero - tLMax <- getTermLocal builtinLevelMax - tPath <- getTermLocal builtinPath - kit <- fromMaybe __IMPOSSIBLE__ <$> getSigmaKit - (redReturn =<<) . runNamesT [] $ do - let ineg j = pure tINeg <@> j - imax i j = pure tIMax <@> i <@> j - imin i j = pure tIMin <@> i <@> j - - -- First define a "ghcomp" version of gcomp. Normal comp looks like: - -- - -- comp^i A [ phi -> u ] u0 = hcomp^i A(1/i) [ phi -> forward A i u ] (forward A 0 u0) - -- - -- So for "gcomp" we compute: - -- - -- gcomp^i A [ phi -> u ] u0 = hcomp^i A(1/i) [ phi -> forward A i u, ~ phi -> forward A 0 u0 ] (forward A 0 u0) - -- - -- The point of this is that gcomp does not produce any empty - -- systems (if phi = 0 it will reduce to "forward A 0 u". - gcomp <- do - let forward la bA r u = pure tTrans <#> (lam "i" $ \ i -> la <@> (i `imax` r)) - <@> (lam "i" $ \ i -> bA <@> (i `imax` r)) - <@> r - <@> u - return $ \ la bA phi u u0 -> - pure tHComp <#> (la <@> pure io) - <#> (bA <@> pure io) - <#> imax phi (ineg phi) - <@> (lam "i" $ \ i -> - pure tPOr <#> (la <@> i) - <@> phi - <@> ineg phi - <@> (ilam "o" $ \ a -> bA <@> i) - <@> (ilam "o" $ \ o -> forward la bA i (u <@> i <..> o)) - <@> (ilam "o" $ \ o -> forward la bA (pure iz) u0)) - <@> forward la bA (pure iz) u0 - - let transpFill la bA phi u0 i = - pure tTrans <#> (ilam "j" $ \ j -> la <@> imin i j) - <@> (ilam "j" $ \ j -> bA <@> imin i j) - <@> (imax phi (ineg i)) - <@> u0 - [psi,u0] <- mapM (open . unArg) [psi,u0] - glue1 <- do - g <- open $ (tglue `apply`) . map (setHiding Hidden) . map (subst 0 io) $ [la, lb, bA, phi, bT, e] - return $ \ t a -> g <@> t <@> a - unglue0 <- do - ug <- open $ (tunglue `apply`) . map (setHiding Hidden) . map (subst 0 iz) $ [la, lb, bA, phi, bT, e] - return $ \ a -> ug <@> a - [la, lb, bA, phi, bT, e] <- mapM (\ a -> open . runNames [] $ (lam "i" $ const (pure $ unArg a))) [la, lb, bA, phi, bT, e] - let - tf i o = transpFill lb (lam "i" $ \ i -> bT <@> i <..> o) psi u0 i - t1 o = tf (pure io) o - a0 = unglue0 u0 - - -- compute "forall. phi" - forallphi = pure tForall <@> phi - - -- a1 with gcomp - a1 = gcomp la bA - (imax psi forallphi) - (lam "i" $ \ i -> pure tPOr <#> (la <@> i) - <@> psi - <@> forallphi - <@> (ilam "o" $ \ a -> bA <@> i) - <@> (ilam "o" $ \ _ -> a0) - <@> (ilam "o" $ \ o -> pure tEFun <#> (lb <@> i) - <#> (la <@> i) - <#> (bT <@> i <..> o) - <#> (bA <@> i) - <@> (e <@> i <..> o) - <@> (tf i o))) - a0 - - max l l' = pure tLMax <@> l <@> l' - sigCon x y = pure (Con (sigmaCon kit) ConOSystem []) <@> x <@> y - w i o = pure tEFun <#> (lb <@> i) - <#> (la <@> i) - <#> (bT <@> i <..> o) - <#> (bA <@> i) - <@> (e <@> i <..> o) - fiber la lb bA bB f b = - (pure (Def (sigmaName kit) []) <#> la - <#> lb - <@> bA - <@> (lam "a" $ \ a -> pure tPath <#> lb <#> bB <@> (f <@> a) <@> b)) - - -- We don't have to do anything special for "~ forall. phi" - -- here (to implement "ghcomp") as it is taken care off by - -- tEProof in t1'alpha below - pe o = -- o : [ φ 1 ] - pure tPOr <#> max (la <@> pure io) (lb <@> pure io) - <@> psi - <@> forallphi - <@> (ilam "o" $ \ _ -> - fiber (lb <@> pure io) (la <@> pure io) - (bT <@> (pure io) <..> o) (bA <@> pure io) - (w (pure io) o) a1) - <@> (ilam "o" $ \ o -> sigCon u0 (lam "_" $ \ _ -> a1)) - <@> (ilam "o" $ \ o -> sigCon (t1 o) (lam "_" $ \ _ -> a1)) - - -- "ghcomp" is implemented in the proof of tEProof - -- (see src/data/lib/prim/Agda/Builtin/Cubical/Glue.agda) - t1'alpha o = -- o : [ φ 1 ] - pure tEProof <#> (lb <@> pure io) - <#> (la <@> pure io) - <@> (bT <@> pure io <..> o) - <@> (bA <@> pure io) - <@> (e <@> pure io <..> o) - <@> a1 - <@> forallphi - <@> pe o - - -- TODO: optimize? - t1' o = t1'alpha o <&> (`applyE` [Proj ProjSystem (sigmaFst kit)]) - alpha o = t1'alpha o <&> (`applyE` [Proj ProjSystem (sigmaSnd kit)]) - a1' = pure tHComp - <#> (la <@> pure io) - <#> (bA <@> pure io) - <#> (imax (phi <@> pure io) psi) - <@> (lam "j" $ \ j -> - pure tPOr <#> (la <@> pure io) <@> (phi <@> pure io) <@> psi <@> (ilam "o" $ \ _ -> bA <@> pure io) - <@> (ilam "o" $ \ o -> alpha o <@@> (w (pure io) o <@> t1' o,a1,j)) - <@> (ilam "o" $ \ _ -> a1) - ) - <@> a1 - glue1 (ilam "o" t1') a1' - compGlue cmd phi u u0 _ = __IMPOSSIBLE__ - compPi :: TranspOrHComp -> ArgName -> FamilyOrNot (Dom Type, Abs Type) -- Γ , i : I - -> Arg Term -- Γ - -> Maybe (Arg Term) -- Γ - -> Arg Term -- Γ - -> ReduceM (Maybe Term) - compPi cmd t ab phi u u0 = do - let getTermLocal = getTerm $ cmdToName cmd ++ " for function types" - - tTrans <- getTermLocal builtinTrans - tHComp <- getTermLocal builtinHComp - tINeg <- getTermLocal builtinINeg - tIMax <- getTermLocal builtinIMax - iz <- getTermLocal builtinIZero - let - toLevel' t = do - s <- reduce $ getSort t - case s of - (Type l) -> return (Just l) - _ -> return Nothing - toLevel t = fromMaybe __IMPOSSIBLE__ <$> toLevel' t - -- make sure the codomain has a level. - caseMaybeM (toLevel' . absBody . snd . famThing $ ab) (return Nothing) $ \ _ -> do - runNamesT [] $ do - labA <- do - let (x,f) = case ab of - IsFam (a,_) -> (a, \ a -> runNames [] $ (lam "i" $ const (pure a))) - IsNot (a,_) -> (a, id) - lx <- toLevel' x - caseMaybe lx (return Nothing) $ \ lx -> Just <$> - mapM (open . f) [Level lx, unEl . unDom $ x] - caseMaybe labA (return Nothing) $ \ [la,bA] -> Just <$> do - [phi, u0] <- mapM (open . unArg) [phi, u0] - u <- traverse open (unArg <$> u) - - glam (getArgInfo (fst $ famThing ab)) (absName $ snd $ famThing ab) $ \ u1 -> do - case (cmd, ab, u) of - (DoHComp, IsNot (a , b), Just u) -> do - bT <- (raise 1 b `absApp`) <$> u1 - let v = u1 - pure tHComp <#> (Level <$> toLevel bT) - <#> (pure $ unEl $ bT) - <#> phi - <@> (lam "i" $ \ i -> ilam "o" $ \ o -> gApply (getHiding a) (u <@> i <..> o) v) - <@> (gApply (getHiding a) u0 v) - (DoTransp, IsFam (a , b), Nothing) -> do - let v i = do - let - iOrNot j = pure tIMax <@> i <@> (pure tINeg <@> j) - pure tTrans <#> (lam "j" $ \ j -> la <@> iOrNot j) - <@> (lam "j" $ \ j -> bA <@> iOrNot j) - <@> (pure tIMax <@> phi <@> i) - <@> u1 - -- Γ , u1 : A[i1] , i : I - bB v = (consS v $ liftS 1 $ raiseS 1) `applySubst` (absBody b {- Γ , i : I , x : A[i] -}) - tLam = Lam defaultArgInfo - bT <- bind "i" $ \ i -> bB <$> v i - -- Γ , u1 : A[i1] - (pure tTrans <#> (tLam <$> traverse (fmap Level . toLevel) bT) - <@> (pure . tLam $ unEl <$> bT) - <@> phi - <@> gApply (getHiding a) u0 (v (pure iz))) - (_,_,_) -> __IMPOSSIBLE__ - compPathP cmd@DoHComp sphi (Just u) u0 (IsNot l) (IsNot (bA,x,y)) = do - let getTermLocal = getTerm $ cmdToName cmd ++ " for path types" - tHComp <- getTermLocal builtinHComp - tINeg <- getTermLocal builtinINeg - tIMax <- getTermLocal builtinIMax - tOr <- getTermLocal "primPOr" - let - ineg j = pure tINeg <@> j - imax i j = pure tIMax <@> i <@> j - - redReturn . runNames [] $ do - [l,u,u0] <- mapM (open . unArg) [l,u,u0] - phi <- open . unArg . ignoreBlocking $ sphi - [bA, x, y] <- mapM (open . unArg) [bA, x, y] - lam "j" $ \ j -> - pure tHComp <#> l - <#> (bA <@> j) - <#> (phi `imax` (ineg j `imax` j)) - <@> (lam "i'" $ \ i -> - let or f1 f2 = pure tOr <#> l <@> f1 <@> f2 <#> (lam "_" $ \ _ -> bA <@> i) - in or phi (ineg j `imax` j) - <@> (ilam "o" $ \ o -> u <@> i <..> o <@@> (x, y, j)) -- a0 <@@> (x <@> i, y <@> i, j) - <@> (or (ineg j) j <@> (ilam "_" $ const x) - <@> (ilam "_" $ const y))) - <@> (u0 <@@> (x, y, j)) - compPathP cmd@DoTransp sphi Nothing u0 (IsFam l) (IsFam (bA,x,y)) = do - -- Γ ⊢ l - -- Γ, i ⊢ bA, x, y - let getTermLocal = getTerm $ cmdToName cmd ++ " for path types" - tINeg <- getTermLocal builtinINeg - tIMax <- getTermLocal builtinIMax - tOr <- getTermLocal "primPOr" - iz <- getTermLocal builtinIZero - io <- getTermLocal builtinIOne - let - ineg j = pure tINeg <@> j - imax i j = pure tIMax <@> i <@> j - comp <- do - tHComp <- getTermLocal builtinHComp - tTrans <- getTermLocal builtinTrans - let forward la bA r u = pure tTrans <#> (lam "i" $ \ i -> la <@> (i `imax` r)) - <@> (lam "i" $ \ i -> bA <@> (i `imax` r)) - <@> r - <@> u - return $ \ la bA phi u u0 -> - pure tHComp <#> (la <@> pure io) - <#> (bA <@> pure io) - <#> phi - <@> (lam "i" $ \ i -> ilam "o" $ \ o -> - forward la bA i (u <@> i <..> o)) - <@> forward la bA (pure iz) u0 - redReturn . runNames [] $ do - [l,u0] <- mapM (open . unArg) [l,u0] - phi <- open . unArg . ignoreBlocking $ sphi - [bA, x, y] <- mapM (\ a -> open . runNames [] $ (lam "i" $ const (pure $ unArg a))) [bA, x, y] - lam "j" $ \ j -> - comp l (lam "i" $ \ i -> bA <@> i <@> j) (phi `imax` (ineg j `imax` j)) - (lam "i'" $ \ i -> - let or f1 f2 = pure tOr <#> l <@> f1 <@> f2 <#> (lam "_" $ \ _ -> bA <@> i <@> j) in - or phi (ineg j `imax` j) - <@> (ilam "o" $ \ o -> u0 <@@> (x <@> pure iz, y <@> pure iz, j)) - <@> (or (ineg j) j <@> (ilam "_" $ const (x <@> i)) - <@> (ilam "_" $ const (y <@> i)))) - (u0 <@@> (x <@> pure iz, y <@> pure iz, j)) - compPathP _ sphi u a0 _ _ = __IMPOSSIBLE__ - compId cmd sphi u a0 l bA_x_y = do - let getTermLocal = getTerm $ cmdToName cmd ++ " for " ++ builtinId - unview <- intervalUnview' - mConId <- getBuiltinName' builtinConId - let isConId (Def q _) = Just q == mConId - isConId _ = False - sa0 <- reduceB' a0 - -- wasteful to compute b even when cheaper checks might fail - b <- case u of - Nothing -> return True - Just u -> allComponents unview (unArg . ignoreBlocking $ sphi) (unArg u) isConId - case mConId of - Just conid | isConId (unArg . ignoreBlocking $ sa0) , b -> (Just <$>) . (redReturn =<<) $ do - tHComp <- getTermLocal builtinHComp - tTrans <- getTermLocal builtinTrans - tIMin <- getTermLocal "primDepIMin" - tFace <- getTermLocal "primIdFace" - tPath <- getTermLocal "primIdPath" - tPathType <- getTermLocal builtinPath - runNamesT [] $ do - let irrInfo = setRelevance Irrelevant defaultArgInfo - let io = pure $ unview IOne - iz = pure $ unview IZero - conId = pure $ Def conid [] - l <- case l of - IsFam l -> open . unArg $ l - IsNot l -> do - open (Lam defaultArgInfo $ NoAbs "_" $ unArg l) - [p0] <- mapM (open . unArg) [a0] - p <- case u of - Just u -> do - u <- open . unArg $ u - return $ \ i o -> u <@> i <..> o - Nothing -> do - return $ \ i o -> p0 - phi <- open . unArg . ignoreBlocking $ sphi - [bA, x, y] <- - case bA_x_y of - IsFam (bA,x,y) -> mapM (\ a -> open . runNames [] $ (lam "i" $ const (pure $ unArg a))) [bA, x, y] - IsNot (bA,x,y) -> forM [bA,x,y] $ \ a -> open (Lam defaultArgInfo $ NoAbs "_" $ unArg a) - let - eval DoTransp l bA phi _ u0 = pure tTrans <#> l <@> bA <@> phi <@> u0 - eval DoHComp l bA phi u u0 = pure tHComp <#> (l <@> io) <#> (bA <@> io) <#> phi - <@> u <@> u0 - conId <#> (l <@> io) <#> (bA <@> io) <#> (x <@> io) <#> (y <@> io) - <@> (pure tIMin <@> phi - <@> (ilam "o" $ \ o -> pure tFace <#> (l <@> io) <#> (bA <@> io) <#> (x <@> io) <#> (y <@> io) - <@> (p io o))) - <@> (eval cmd l - (lam "i" $ \ i -> pure tPathType <#> (l <@> i) <#> (bA <@> i) <@> (x <@> i) <@> (y <@> i)) - phi - (lam "i" $ \ i -> ilam "o" $ \ o -> pure tPath <#> (l <@> i) <#> (bA <@> i) - <#> (x <@> i) <#> (y <@> i) - <@> (p i o) - ) - (pure tPath <#> (l <@> iz) <#> (bA <@> iz) <#> (x <@> iz) <#> (y <@> iz) - <@> p0) - ) - _ -> return $ Nothing - allComponents unview phi u p = do - let - boolToI b = if b then unview IOne else unview IZero - as <- decomposeInterval phi - (and <$>) . forM as $ \ (bs,ts) -> do -- OPTIMIZE: stop at the first False - let u' = listS (Map.toAscList $ Map.map boolToI bs) `applySubst` u - t <- reduce2Lam u' - return $! p t - where - reduce2Lam t = do - t <- reduce' t - case lam2Abs t of - t -> Reduce.underAbstraction_ t $ \ t -> do - t <- reduce' t - case lam2Abs t of - t -> Reduce.underAbstraction_ t reduce' - where - lam2Abs (Lam _ t) = t - lam2Abs t = Abs "y" (raise 1 t `apply` [argN $ var 0]) - - compData False _ cmd@DoHComp (IsNot l) (IsNot ps) fsc sphi (Just u) a0 = do - let getTermLocal = getTerm $ cmdToName cmd ++ " for data types" - - let sc = famThing <$> fsc - tEmpty <- getTermLocal builtinIsOneEmpty - constrForm <- do - mz <- getTerm' builtinZero - ms <- getTerm' builtinSuc - return $ \ t -> fromMaybe t (constructorForm' mz ms t) - su <- reduceB' u - sa0 <- reduceB' a0 - view <- intervalView' - unview <- intervalUnview' - let f = unArg . ignoreBlocking - phi = f sphi - u = f su - a0 = f sa0 - noRed = return $ NoReduction [notReduced l,reduced sc, reduced sphi, reduced su', reduced sa0] - where - su' = case view phi of - IZero -> notBlocked $ argN $ runNames [] $ do - [l,c] <- mapM (open . unArg) [l,ignoreBlocking sc] - lam "i" $ \ i -> pure tEmpty <#> l - <#> (ilam "o" $ \ _ -> c) - _ -> su - sameConHead h u = allComponents unview phi u $ \ t -> - case constrForm t of - Con h' _ _ -> h == h' - _ -> False - - case constrForm a0 of - Con h _ args -> do - ifM (not <$> sameConHead h u) noRed $ do - Constructor{ conComp = (cm,_) } <- theDef <$> getConstInfo (conName h) - case nameOfHComp cm of - Just hcompD -> redReturn $ Def hcompD [] `apply` - (ps ++ map argN [phi,u,a0]) - Nothing -> noRed - _ -> noRed - compData _ 0 DoTransp (IsFam l) (IsFam ps) fsc sphi Nothing a0 = redReturn $ unArg a0 - compData isHIT _ cmd@DoTransp (IsFam l) (IsFam ps) fsc sphi Nothing a0 = do - let getTermLocal = getTerm $ cmdToName cmd ++ " for data types" - let sc = famThing <$> fsc - mhcompName <- getName' builtinHComp - constrForm <- do - mz <- getTerm' builtinZero - ms <- getTerm' builtinSuc - return $ \ t -> fromMaybe t (constructorForm' mz ms t) - sa0 <- reduceB' a0 - let f = unArg . ignoreBlocking - phi = f sphi - a0 = f sa0 - noRed = return $ NoReduction [notReduced l,reduced sc, reduced sphi, reduced sa0] - let lam_i = Lam defaultArgInfo . Abs "i" - case constrForm a0 of - Con h _ args -> do - Constructor{ conComp = (cm,_) } <- theDef <$> getConstInfo (conName h) - case nameOfTransp cm of - Just transpD -> redReturn $ Def transpD [] `apply` - (map (fmap lam_i) ps ++ map argN [phi,a0]) - Nothing -> noRed - Def q es | isHIT, Just q == mhcompName, Just [_l0,_c0,psi,u,u0] <- allApplyElims es -> do - let bC = ignoreBlocking sc - hcomp <- getTermLocal builtinHComp - transp <- getTermLocal builtinTrans - io <- getTermLocal builtinIOne - iz <- getTermLocal builtinIZero - (redReturn =<<) . runNamesT [] $ do - [l,bC,phi,psi,u,u0] <- mapM (open . unArg) [l,bC,ignoreBlocking sphi,psi,u,u0] - -- hcomp (sc 1) [psi |-> transp sc phi u] (transp sc phi u0) - pure hcomp <#> (l <@> pure io) <#> (bC <@> pure io) <#> psi - <@> (lam "j" $ \ j -> ilam "o" $ \ o -> - pure transp <#> l <@> bC <@> phi <@> (u <@> j <..> o)) - <@> (pure transp <#> l <@> bC <@> phi <@> u0) - _ -> noRed - compData _ _ _ _ _ _ _ _ _ = __IMPOSSIBLE__ - compPO = __IMPOSSIBLE__ - -primComp :: TCM PrimitiveImpl -primComp = do - requireCubical - t <- runNamesT [] $ - hPi' "a" (elInf (cl primInterval) --> (el $ cl primLevel)) $ \ a -> - nPi' "A" (nPi' "i" (elInf (cl primInterval)) $ \ i -> (sort . tmSort <$> (a <@> i))) $ \ bA -> - nPi' "φ" (elInf $ cl primInterval) $ \ phi -> - (nPi' "i" (elInf $ cl primInterval) $ \ i -> pPi' "o" phi $ \ _ -> el' (a <@> i) (bA <@> i)) --> - (el' (a <@> cl primIZero) (bA <@> cl primIZero) --> el' (a <@> cl primIOne) (bA <@> cl primIOne)) - one <- primItIsOne - io <- primIOne - return $ PrimImpl t $ PrimFun __IMPOSSIBLE__ 5 $ \ ts nelims -> do - case ts of - [l,c,phi,u,a0] -> do - sphi <- reduceB' phi - vphi <- intervalView $ unArg $ ignoreBlocking sphi - case vphi of - IOne -> redReturn (unArg u `apply` [argN io, argN one]) - _ -> do - let getTermLocal = getTerm $ builtinComp - tIMax <- getTermLocal builtinIMax - tINeg <- getTermLocal builtinINeg - tHComp <- getTermLocal builtinHComp - tTrans <- getTermLocal builtinTrans - iz <- getTermLocal builtinIZero - (redReturn =<<) . runNamesT [] $ do - comp <- do - let - ineg j = pure tINeg <@> j - imax i j = pure tIMax <@> i <@> j - let forward la bA r u = pure tTrans <#> (lam "i" $ \ i -> la <@> (i `imax` r)) - <@> (lam "i" $ \ i -> bA <@> (i `imax` r)) - <@> r - <@> u - return $ \ la bA phi u u0 -> - pure tHComp <#> (la <@> pure io) <#> (bA <@> pure io) <#> phi - <@> (lam "i" $ \ i -> ilam "o" $ \ o -> - forward la bA i (u <@> i <..> o)) - <@> forward la bA (pure iz) u0 - - [l,c,phi,u,a0] <- mapM (open . unArg) [l,c,phi,u,a0] - comp l c phi u a0 - - _ -> __IMPOSSIBLE__ - --- lookupS (listS [(x0,t0)..(xn,tn)]) xi = ti, assuming x0 < .. < xn. -listS :: [(Int,Term)] -> Substitution -listS ((i,t):ts) = singletonS i t `composeS` listS ts -listS [] = IdS - - -primGlue' :: TCM PrimitiveImpl -primGlue' = do - requireCubical - -- Glue' : ∀ {l} (A : Set l) → ∀ φ → (T : Partial (Set a) φ) (f : (PartialP φ \ o → (T o) -> A)) - -- ([f] : PartialP φ \ o → isEquiv (T o) A (f o)) → Set l - t <- runNamesT [] $ - (hPi' "la" (el $ cl primLevel) $ \ la -> - hPi' "lb" (el $ cl primLevel) $ \ lb -> - nPi' "A" (sort . tmSort <$> la) $ \ a -> - hPi' "φ" (elInf $ cl primInterval) $ \ φ -> - nPi' "T" (pPi' "o" φ $ \ o -> el' (cl primLevelSuc <@> lb) (Sort . tmSort <$> lb)) $ \ t -> - (pPi' "o" φ $ \ o -> el' (cl primLevelMax <@> la <@> lb) $ cl primEquiv <#> lb <#> la <@> (t <@> o) <@> a) - --> (sort . tmSort <$> lb)) - view <- intervalView' - one <- primItIsOne - return $ PrimImpl t $ primFun __IMPOSSIBLE__ 6 $ \ts -> - case ts of - [la,lb,a,phi,t,e] -> do - sphi <- reduceB' phi - case view $ unArg $ ignoreBlocking $ sphi of - IOne -> redReturn $ unArg t `apply` [argN one] - _ -> return (NoReduction $ map notReduced [la,lb,a] ++ [reduced sphi] ++ map notReduced [t,e]) - _ -> __IMPOSSIBLE__ - -prim_glue' :: TCM PrimitiveImpl -prim_glue' = do - requireCubical - t <- runNamesT [] $ - (hPi' "la" (el $ cl primLevel) $ \ la -> - hPi' "lb" (el $ cl primLevel) $ \ lb -> - hPi' "A" (sort . tmSort <$> la) $ \ a -> - hPi' "φ" (elInf $ cl primInterval) $ \ φ -> - hPi' "T" (pPi' "o" φ $ \ o -> el' (cl primLevelSuc <@> lb) (Sort . tmSort <$> lb)) $ \ t -> - hPi' "e" (pPi' "o" φ $ \ o -> el' (cl primLevelMax <@> la <@> lb) $ cl primEquiv <#> lb <#> la <@> (t <@> o) <@> a) $ \ e -> - (pPi' "o" φ $ \ o -> el' lb (t <@> o)) --> (el' la a --> el' lb (cl primGlue <#> la <#> lb <@> a <#> φ <@> t <@> e))) - view <- intervalView' - one <- primItIsOne - return $ PrimImpl t $ primFun __IMPOSSIBLE__ 8 $ \ts -> - case ts of - [la,lb,bA,phi,bT,e,t,a] -> do - sphi <- reduceB' phi - case view $ unArg $ ignoreBlocking $ sphi of - IOne -> redReturn $ unArg t `apply` [argN one] - _ -> return (NoReduction $ map notReduced [la,lb,bA] ++ [reduced sphi] ++ map notReduced [bT,e,t,a]) - _ -> __IMPOSSIBLE__ - -prim_unglue' :: TCM PrimitiveImpl -prim_unglue' = do - requireCubical - t <- runNamesT [] $ - (hPi' "la" (el $ cl primLevel) $ \ la -> - hPi' "lb" (el $ cl primLevel) $ \ lb -> - hPi' "A" (sort . tmSort <$> la) $ \ a -> - hPi' "φ" (elInf $ cl primInterval) $ \ φ -> - hPi' "T" (pPi' "o" φ $ \ o -> el' (cl primLevelSuc <@> lb) (Sort . tmSort <$> lb)) $ \ t -> - hPi' "e" (pPi' "o" φ $ \ o -> el' (cl primLevelMax <@> la <@> lb) $ cl primEquiv <#> lb <#> la <@> (t <@> o) <@> a) $ \ e -> - (el' lb (cl primGlue <#> la <#> lb <@> a <#> φ <@> t <@> e)) --> el' la a) - view <- intervalView' - one <- primItIsOne - mglue <- getPrimitiveName' builtin_glue - return $ PrimImpl t $ primFun __IMPOSSIBLE__ 7 $ \ts -> - case ts of - [la,lb,bA,phi,bT,e,b] -> do - sphi <- reduceB' phi - case view $ unArg $ ignoreBlocking $ sphi of - IOne -> do - let argOne = setRelevance Irrelevant $ argN one - tEFun <- getTerm builtin_unglue builtinEquivFun - redReturn $ tEFun `apply` [lb,la,argH $ unArg bT `apply` [argOne],bA, argN $ unArg e `apply` [argOne],b] - _ -> do - sb <- reduceB' b - case unArg $ ignoreBlocking $ sb of - Def q [Apply _,Apply _,Apply _,Apply _,Apply _,Apply _,Apply _,Apply a] - | Just q == mglue -> redReturn $ unArg a - _ -> return (NoReduction $ map notReduced [la,lb,bA] ++ [reduced sphi] ++ map notReduced [bT,e] ++ [reduced sb]) - _ -> __IMPOSSIBLE__ - - --- TODO Andrea: keep reductions that happen under foralls? -primFaceForall' :: TCM PrimitiveImpl -primFaceForall' = do - requireCubical - t <- (elInf primInterval --> elInf primInterval) --> elInf primInterval - return $ PrimImpl t $ primFun __IMPOSSIBLE__ 1 $ \ts -> - case ts of - [phi] -> do - sphi <- reduceB' phi - case unArg $ ignoreBlocking $ sphi of - Lam _ t -> do - t <- reduce' t - case t of - NoAbs _ t -> redReturn t - Abs _ t -> maybe (return $ NoReduction [reduced sphi]) redReturn =<< toFaceMapsPrim t - _ -> return (NoReduction [reduced sphi]) - _ -> __IMPOSSIBLE__ - where - toFaceMapsPrim t = do - view <- intervalView' - unview <- intervalUnview' - us' <- decomposeInterval t - fr <- getTerm builtinFaceForall builtinFaceForall - let - v = view t - us = [ map Left (Map.toList bsm) ++ map Right ts - | (bsm,ts) <- us' - , 0 `Map.notMember` bsm - ] - fm (i,b) = if b then var (i-1) else unview (INeg (argN (var $ i-1))) - ffr t = fr `apply` [argN $ Lam defaultArgInfo $ Abs "i" t] - r = Just $ foldr (\ x r -> unview (IMax (argN x) (argN r))) (unview IZero) - (map (foldr (\ x r -> unview (IMin (argN (either fm ffr x)) (argN r))) (unview IOne)) us) - -- traceSLn "cube.forall" 20 (unlines [show v, show us', show us, show r]) $ - return $ - case us' of - [(m,[_])] | Map.null m -> Nothing - v -> r - -decomposeInterval :: HasBuiltins m => Term -> m [(Map Int Bool,[Term])] -decomposeInterval t = do - xs <- decomposeInterval' t - let isConsistent xs = all (\ xs -> Set.size xs == 1) . Map.elems $ xs -- optimize by not doing generate + filter - return [ (Map.map (head . Set.toList) bsm,ts) - | (bsm,ts) <- xs - , isConsistent bsm - ] - -decomposeInterval' :: HasBuiltins m => Term -> m [(Map Int (Set Bool),[Term])] -decomposeInterval' t = do - view <- intervalView' - unview <- intervalUnview' - let f :: IntervalView -> [[Either (Int,Bool) Term]] - -- TODO handle primIMinDep - -- TODO? handle forall - f IZero = mzero - f IOne = return [] - f (IMin x y) = do xs <- (f . view . unArg) x; ys <- (f . view . unArg) y; return (xs ++ ys) - f (IMax x y) = msum $ map (f . view . unArg) [x,y] - f (INeg x) = map (either (\ (x,y) -> Left (x,not y)) (Right . unview . INeg . argN)) <$> (f . view . unArg) x - f (OTerm (Var i [])) = return [Left (i,True)] - f (OTerm t) = return [Right t] - v = view t - return [ (bsm,ts) - | xs <- f v - , let (bs,ts) = partitionEithers xs - , let bsm = (Map.fromListWith Set.union . map (id -*- Set.singleton)) bs - ] - --- | @mkPrimInjective@ takes two Set0 @a@ and @b@ and a function @f@ of type --- @a -> b@ and outputs a primitive internalizing the fact that @f@ is injective. -mkPrimInjective :: Type -> Type -> QName -> TCM PrimitiveImpl -mkPrimInjective a b qn = do - -- Define the type - eqName <- primEqualityName - let lvl0 = Max [] - let eq a t u = El (Type lvl0) <$> pure (Def eqName []) <#> pure (Level lvl0) - <#> pure (unEl a) <@> t <@> u - let f = pure (Def qn []) - ty <- nPi "t" (pure a) $ nPi "u" (pure a) $ - (eq b (f <@> varM 1) (f <@> varM 0)) - --> (eq a ( varM 1) ( varM 0)) - - -- Get the constructor corresponding to BUILTIN REFL - refl <- getRefl - - -- Implementation: when the equality argument reduces to refl so does the primitive. - -- If the user want the primitive to reduce whenever the two values are equal (no - -- matter whether the equality is refl), they can combine it with @eraseEquality@. - return $ PrimImpl ty $ primFun __IMPOSSIBLE__ 3 $ \ ts -> do - let t = fromMaybe __IMPOSSIBLE__ $ headMaybe ts - let eq = unArg $ fromMaybe __IMPOSSIBLE__ $ lastMaybe ts - eq' <- normalise' eq - case eq' of - Con{} -> redReturn $ refl t - _ -> return $ NoReduction $ map notReduced ts - -primCharToNatInjective :: TCM PrimitiveImpl -primCharToNatInjective = do - char <- primType (undefined :: Char) - nat <- primType (undefined :: Nat) - toNat <- primFunName <$> getPrimitive "primCharToNat" - mkPrimInjective char nat toNat - -primStringToListInjective :: TCM PrimitiveImpl -primStringToListInjective = do - string <- primType (undefined :: Str) - chars <- primType (undefined :: String) - toList <- primFunName <$> getPrimitive "primStringToList" - mkPrimInjective string chars toList - -primWord64ToNatInjective :: TCM PrimitiveImpl -primWord64ToNatInjective = do - word <- primType (undefined :: Word64) - nat <- primType (undefined :: Nat) - toNat <- primFunName <$> getPrimitive "primWord64ToNat" - mkPrimInjective word nat toNat - -getRefl :: TCM (Arg Term -> Term) -getRefl = do - -- BUILTIN REFL maybe a constructor with one (the principal) argument or only parameters. - -- Get the ArgInfo of the principal argument of refl. - con@(Con rf ci []) <- primRefl - minfo <- fmap (setOrigin Inserted) <$> getReflArgInfo rf - pure $ case minfo of - Just ai -> Con rf ci . (:[]) . Apply . setArgInfo ai - Nothing -> const con - --- | @primEraseEquality : {a : Level} {A : Set a} {x y : A} -> x ≡ y -> x ≡ y@ -primEraseEquality :: TCM PrimitiveImpl -primEraseEquality = do - -- primEraseEquality is incompatible with --without-K - -- We raise an error warning if --safe is set and a mere warning otherwise - whenM withoutKOption $ - ifM (Lens.getSafeMode <$> commandLineOptions) - {- then -} (warning SafeFlagWithoutKFlagPrimEraseEquality) - {- else -} (warning WithoutKFlagPrimEraseEquality) - -- Get the name and type of BUILTIN EQUALITY - eq <- primEqualityName - eqTy <- defType <$> getConstInfo eq - -- E.g. @eqTy = eqTel → Set a@ where @eqTel = {a : Level} {A : Set a} (x y : A)@. - TelV eqTel eqCore <- telView eqTy - let eqSort = case unEl eqCore of - Sort s -> s - _ -> __IMPOSSIBLE__ - - -- Construct the type of primEraseEquality, e.g. - -- @{a : Level} {A : Set a} {x y : A} → eq {a} {A} x y -> eq {a} {A} x y@. - t <- let xeqy = pure $ El eqSort $ Def eq $ map Apply $ teleArgs eqTel in - telePi_ (fmap hide eqTel) <$> (xeqy --> xeqy) - - -- Get the constructor corresponding to BUILTIN REFL - refl <- getRefl - - -- The implementation of primEraseEquality: - return $ PrimImpl t $ primFun __IMPOSSIBLE__ (1 + size eqTel) $ \ ts -> do - let (u, v) = fromMaybe __IMPOSSIBLE__ $ last2 =<< initMaybe ts - -- Andreas, 2013-07-22. - -- Note that we cannot call the conversion checker here, - -- because 'reduce' might be called in a context where - -- some bound variables do not have a type (just __DUMMY_TYPE__), - -- and the conversion checker for eliminations does not - -- like this. - -- We can only do untyped equality, e.g., by normalisation. - (u', v') <- normalise' (u, v) - if u' == v' then redReturn $ refl u else - return $ NoReduction $ map notReduced ts - --- | Get the 'ArgInfo' of the principal argument of BUILTIN REFL. --- --- Returns @Nothing@ for e.g. --- @ --- data Eq {a} {A : Set a} (x : A) : A → Set a where --- refl : Eq x x --- @ --- --- Returns @Just ...@ for e.g. --- @ --- data Eq {a} {A : Set a} : (x y : A) → Set a where --- refl : ∀ x → Eq x x --- @ - -getReflArgInfo :: ConHead -> TCM (Maybe ArgInfo) -getReflArgInfo rf = do - def <- getConInfo rf - TelV reflTel _ <- telView $ defType def - return $ fmap getArgInfo $ headMaybe $ drop (conPars $ theDef def) $ telToList reflTel - - --- | Used for both @primForce@ and @primForceLemma@. -genPrimForce :: TCM Type -> (Term -> Arg Term -> Term) -> TCM PrimitiveImpl -genPrimForce b ret = do - let varEl s a = El (varSort s) <$> a - varT s a = varEl s (varM a) - varS s = pure $ sort $ varSort s - t <- hPi "a" (el primLevel) $ - hPi "b" (el primLevel) $ - hPi "A" (varS 1) $ - hPi "B" (varT 2 0 --> varS 1) b - return $ PrimImpl t $ primFun __IMPOSSIBLE__ 6 $ \ ts -> - case ts of - [a, b, s, t, u, f] -> do - u <- reduceB' u - let isWHNF Blocked{} = return False - isWHNF (NotBlocked _ u) = - case unArg u of - Lit{} -> return True - Con{} -> return True - Lam{} -> return True - Pi{} -> return True - Sort{} -> return True -- sorts and levels are considered whnf - Level{} -> return True - DontCare{} -> return True - Def q _ -> do - def <- theDef <$> getConstInfo q - return $ case def of - Datatype{} -> True - Record{} -> True - _ -> False - MetaV{} -> return False - Var{} -> return False - Dummy s -> __IMPOSSIBLE_VERBOSE__ s - ifM (isWHNF u) - (redReturn $ ret (unArg f) (ignoreBlocking u)) - (return $ NoReduction $ map notReduced [a, b, s, t] ++ [reduced u, notReduced f]) - _ -> __IMPOSSIBLE__ - -primForce :: TCM PrimitiveImpl -primForce = do - let varEl s a = El (varSort s) <$> a - varT s a = varEl s (varM a) - varS s = pure $ sort $ varSort s - genPrimForce (nPi "x" (varT 3 1) $ - (nPi "y" (varT 4 2) $ varEl 4 $ varM 2 <@> varM 0) --> - varEl 3 (varM 1 <@> varM 0)) $ - \ f u -> apply f [u] - -primForceLemma :: TCM PrimitiveImpl -primForceLemma = do - let varEl s a = El (varSort s) <$> a - varT s a = varEl s (varM a) - varS s = pure $ sort $ varSort s - refl <- primRefl - force <- primFunName <$> getPrimitive "primForce" - genPrimForce (nPi "x" (varT 3 1) $ - nPi "f" (nPi "y" (varT 4 2) $ varEl 4 $ varM 2 <@> varM 0) $ - varEl 4 $ primEquality <#> varM 4 <#> (varM 2 <@> varM 1) - <@> (pure (Def force []) <#> varM 5 <#> varM 4 <#> varM 3 <#> varM 2 <@> varM 1 <@> varM 0) - <@> (varM 0 <@> varM 1) - ) $ \ _ _ -> refl - -mkPrimLevelZero :: TCM PrimitiveImpl -mkPrimLevelZero = do - t <- primType (undefined :: Lvl) - return $ PrimImpl t $ primFun __IMPOSSIBLE__ 0 $ \_ -> redReturn $ Level $ Max [] - -mkPrimLevelSuc :: TCM PrimitiveImpl -mkPrimLevelSuc = do - t <- primType (id :: Lvl -> Lvl) - return $ PrimImpl t $ primFun __IMPOSSIBLE__ 1 $ \ ~[a] -> do - l <- levelView' $ unArg a - redReturn $ Level $ levelSuc l - -mkPrimLevelMax :: TCM PrimitiveImpl -mkPrimLevelMax = do - t <- primType (max :: Op Lvl) - return $ PrimImpl t $ primFun __IMPOSSIBLE__ 2 $ \ ~[a, b] -> do - Max as <- levelView' $ unArg a - Max bs <- levelView' $ unArg b - redReturn $ Level $ levelMax $ as ++ bs - -mkPrimSetOmega :: TCM PrimitiveImpl -mkPrimSetOmega = do - let t = sort $ UnivSort Inf - return $ PrimImpl t $ primFun __IMPOSSIBLE__ 0 $ \_ -> redReturn $ Sort Inf - -mkPrimFun1TCM :: (FromTerm a, ToTerm b, TermLike b) => - TCM Type -> (a -> ReduceM b) -> TCM PrimitiveImpl -mkPrimFun1TCM mt f = do - toA <- fromTerm - fromB <- toTermR - t <- mt - return $ PrimImpl t $ primFun __IMPOSSIBLE__ 1 $ \ts -> - case ts of - [v] -> - redBind (toA v) singleton $ \ x -> do - b <- f x - case firstMeta b of - Just m -> return $ NoReduction [reduced (Blocked m v)] - Nothing -> redReturn =<< fromB b - _ -> __IMPOSSIBLE__ - --- Tying the knot -mkPrimFun1 :: (PrimType a, FromTerm a, PrimType b, ToTerm b) => - (a -> b) -> TCM PrimitiveImpl -mkPrimFun1 f = do - toA <- fromTerm - fromB <- toTerm - t <- primType f - return $ PrimImpl t $ primFun __IMPOSSIBLE__ 1 $ \ts -> - case ts of - [v] -> - redBind (toA v) singleton $ \ x -> - redReturn $ fromB $ f x - _ -> __IMPOSSIBLE__ - -mkPrimFun2 :: ( PrimType a, FromTerm a, ToTerm a - , PrimType b, FromTerm b - , PrimType c, ToTerm c ) => - (a -> b -> c) -> TCM PrimitiveImpl -mkPrimFun2 f = do - toA <- fromTerm - fromA <- toTerm - toB <- fromTerm - fromC <- toTerm - t <- primType f - return $ PrimImpl t $ primFun __IMPOSSIBLE__ 2 $ \ts -> - case ts of - [v,w] -> - redBind (toA v) - (\v' -> [v', notReduced w]) $ \x -> - redBind (toB w) - (\w' -> [ reduced $ notBlocked $ Arg (argInfo v) (fromA x) - , w']) $ \y -> - redReturn $ fromC $ f x y - _ -> __IMPOSSIBLE__ - -mkPrimFun4 :: ( PrimType a, FromTerm a, ToTerm a - , PrimType b, FromTerm b, ToTerm b - , PrimType c, FromTerm c, ToTerm c - , PrimType d, FromTerm d - , PrimType e, ToTerm e ) => - (a -> b -> c -> d -> e) -> TCM PrimitiveImpl -mkPrimFun4 f = do - (toA, fromA) <- (,) <$> fromTerm <*> toTerm - (toB, fromB) <- (,) <$> fromTerm <*> toTerm - (toC, fromC) <- (,) <$> fromTerm <*> toTerm - toD <- fromTerm - fromE <- toTerm - t <- primType f - return $ PrimImpl t $ primFun __IMPOSSIBLE__ 4 $ \ts -> - let argFrom fromX a x = - reduced $ notBlocked $ Arg (argInfo a) (fromX x) - in case ts of - [a,b,c,d] -> - redBind (toA a) - (\a' -> a' : map notReduced [b,c,d]) $ \x -> - redBind (toB b) - (\b' -> [argFrom fromA a x, b', notReduced c, notReduced d]) $ \y -> - redBind (toC c) - (\c' -> [ argFrom fromA a x - , argFrom fromB b y - , c', notReduced d]) $ \z -> - redBind (toD d) - (\d' -> [ argFrom fromA a x - , argFrom fromB b y - , argFrom fromC c z - , d']) $ \w -> - - redReturn $ fromE $ f x y z w - _ -> __IMPOSSIBLE__ - --- Type combinators - -infixr 4 --> -infixr 4 .--> -infixr 4 ..--> - -(-->), (.-->), (..-->) :: Monad tcm => tcm Type -> tcm Type -> tcm Type -a --> b = garr id a b -a .--> b = garr (const $ Irrelevant) a b -a ..--> b = garr (const $ NonStrict) a b - -garr :: Monad tcm => (Relevance -> Relevance) -> tcm Type -> tcm Type -> tcm Type -garr f a b = do - a' <- a - b' <- b - return $ El (funSort (getSort a') (getSort b')) $ - Pi (mapRelevance f $ defaultDom a') (NoAbs "_" b') - -gpi :: (MonadTCM tcm, MonadDebug tcm) - => ArgInfo -> String -> tcm Type -> tcm Type -> tcm Type -gpi info name a b = do - a <- a - let dom = defaultNamedArgDom info name a - b <- addContext (name, dom) b - let y = stringToArgName name - return $ El (piSort (getSort a) (Abs y (getSort b))) - (Pi dom (Abs y b)) - -hPi, nPi :: (MonadTCM tcm, MonadDebug tcm) - => String -> tcm Type -> tcm Type -> tcm Type -hPi = gpi $ setHiding Hidden defaultArgInfo -nPi = gpi defaultArgInfo - -hPi', nPi' :: (MonadTCM tcm, MonadDebug tcm) - => String -> NamesT tcm Type -> (NamesT tcm Term -> NamesT tcm Type) -> NamesT tcm Type -hPi' s a b = hPi s a (bind' s b) -nPi' s a b = nPi s a (bind' s b) - -pPi' :: (MonadTCM tcm, MonadDebug tcm) - => String -> NamesT tcm Term -> (NamesT tcm Term -> NamesT tcm Type) -> NamesT tcm Type -pPi' n phi b = toFinitePi <$> nPi' n (elInf $ cl (liftTCM primIsOne) <@> phi) b - where - toFinitePi :: Type -> Type - toFinitePi (El s (Pi d b)) = El s $ Pi (setRelevance Irrelevant $ d { domFinite = True }) b - toFinitePi _ = __IMPOSSIBLE__ - -el' :: Monad m => m Term -> m Term -> m Type -el' l a = El <$> (tmSort <$> l) <*> a - -elInf :: Functor m => m Term -> m Type -elInf t = (El Inf <$> t) - -nolam :: Term -> Term -nolam = Lam defaultArgInfo . NoAbs "_" - -varM :: Monad tcm => Int -> tcm Term -varM = return . var - -infixl 9 <@>, <#> - -gApply :: Monad tcm => Hiding -> tcm Term -> tcm Term -> tcm Term -gApply h a b = gApply' (setHiding h defaultArgInfo) a b - -gApply' :: Monad tcm => ArgInfo -> tcm Term -> tcm Term -> tcm Term -gApply' info a b = do - x <- a - y <- b - return $ x `apply` [Arg info y] - -(<@>),(<#>),(<..>) :: Monad tcm => tcm Term -> tcm Term -> tcm Term -(<@>) = gApply NotHidden -(<#>) = gApply Hidden -(<..>) = gApply' (setRelevance Irrelevant defaultArgInfo) - -(<@@>) :: Monad tcm => tcm Term -> (tcm Term,tcm Term,tcm Term) -> tcm Term -t <@@> (x,y,r) = do - t <- t - x <- x - y <- y - r <- r - return $ t `applyE` [IApply x y r] - -list :: TCM Term -> TCM Term -list t = primList <@> t - -io :: TCM Term -> TCM Term -io t = primIO <@> t - -path :: TCM Term -> TCM Term -path t = primPath <@> t - -el :: Functor tcm => tcm Term -> tcm Type -el t = El (mkType 0) <$> t - -tset :: Monad tcm => tcm Type -tset = return $ sort (mkType 0) - -sSizeUniv :: Sort -sSizeUniv = mkType 0 --- Andreas, 2016-04-14 switching off SizeUniv, unfixing issue #1428 --- sSizeUniv = SizeUniv - -tSizeUniv :: Monad tcm => tcm Type -tSizeUniv = tset --- Andreas, 2016-04-14 switching off SizeUniv, unfixing issue #1428 --- tSizeUniv = return $ El sSizeUniv $ Sort sSizeUniv --- Andreas, 2015-03-16 Since equality checking for types --- includes equality checking for sorts, we cannot put --- SizeUniv in Setω. (SizeUniv : Setω) == (_0 : suc _0) --- will first instantiate _0 := Setω, which is wrong. --- tSizeUniv = return $ El Inf $ Sort SizeUniv - --- | Abbreviation: @argN = 'Arg' 'defaultArgInfo'@. -argN :: e -> Arg e -argN = Arg defaultArgInfo - -domN :: e -> Dom e -domN = defaultDom - --- | Abbreviation: @argH = 'hide' 'Arg' 'defaultArgInfo'@. -argH :: e -> Arg e -argH = Arg $ setHiding Hidden defaultArgInfo - -domH :: e -> Dom e -domH = setHiding Hidden . defaultDom - ---------------------------------------------------------------------------- --- * The actual primitive functions ---------------------------------------------------------------------------- - -type Op a = a -> a -> a -type Fun a = a -> a -type Rel a = a -> a -> Bool -type Pred a = a -> Bool - -primitiveFunctions :: Map String (TCM PrimitiveImpl) -primitiveFunctions = Map.fromList - - -- Ulf, 2015-10-28: Builtin integers now map to a datatype, and since you - -- can define these functions (reasonably) efficiently using the primitive - -- functions on natural numbers there's no need for them anymore. Keeping the - -- show function around for convenience, and as a test case for a primitive - -- function taking an integer. - -- -- Integer functions - -- [ "primIntegerPlus" |-> mkPrimFun2 ((+) :: Op Integer) - -- , "primIntegerMinus" |-> mkPrimFun2 ((-) :: Op Integer) - -- , "primIntegerTimes" |-> mkPrimFun2 ((*) :: Op Integer) - -- , "primIntegerDiv" |-> mkPrimFun2 (div :: Op Integer) -- partial - -- , "primIntegerMod" |-> mkPrimFun2 (mod :: Op Integer) -- partial - -- , "primIntegerEquality" |-> mkPrimFun2 ((==) :: Rel Integer) - -- , "primIntegerLess" |-> mkPrimFun2 ((<) :: Rel Integer) - -- , "primIntegerAbs" |-> mkPrimFun1 (Nat . abs :: Integer -> Nat) - -- , "primNatToInteger" |-> mkPrimFun1 (toInteger :: Nat -> Integer) - [ "primShowInteger" |-> mkPrimFun1 (Str . show :: Integer -> Str) - - -- Natural number functions - , "primNatPlus" |-> mkPrimFun2 ((+) :: Op Nat) - , "primNatMinus" |-> mkPrimFun2 ((\x y -> max 0 (x - y)) :: Op Nat) - , "primNatTimes" |-> mkPrimFun2 ((*) :: Op Nat) - , "primNatDivSucAux" |-> mkPrimFun4 ((\k m n j -> k + div (max 0 $ n + m - j) (m + 1)) :: Nat -> Nat -> Nat -> Nat -> Nat) - , "primNatModSucAux" |-> - let aux :: Nat -> Nat -> Nat -> Nat -> Nat - aux k m n j | n > j = mod (n - j - 1) (m + 1) - | otherwise = k + n - in mkPrimFun4 aux - , "primNatEquality" |-> mkPrimFun2 ((==) :: Rel Nat) - , "primNatLess" |-> mkPrimFun2 ((<) :: Rel Nat) - - -- Machine words - , "primWord64ToNat" |-> mkPrimFun1 (fromIntegral :: Word64 -> Nat) - , "primWord64FromNat" |-> mkPrimFun1 (fromIntegral :: Nat -> Word64) - , "primWord64ToNatInjective" |-> primWord64ToNatInjective - - -- Level functions - , "primLevelZero" |-> mkPrimLevelZero - , "primLevelSuc" |-> mkPrimLevelSuc - , "primLevelMax" |-> mkPrimLevelMax - - -- Sorts - , "primSetOmega" |-> mkPrimSetOmega - - -- Floating point functions - , "primNatToFloat" |-> mkPrimFun1 (fromIntegral :: Nat -> Double) - , "primFloatPlus" |-> mkPrimFun2 ((+) :: Op Double) - , "primFloatMinus" |-> mkPrimFun2 ((-) :: Op Double) - , "primFloatTimes" |-> mkPrimFun2 ((*) :: Op Double) - , "primFloatNegate" |-> mkPrimFun1 (negate :: Fun Double) - , "primFloatDiv" |-> mkPrimFun2 ((/) :: Op Double) - -- ASR (2016-09-29). We use bitwise equality for comparing Double - -- because Haskell's Eq, which equates 0.0 and -0.0, allows to prove - -- a contradiction (see Issue #2169). - , "primFloatEquality" |-> mkPrimFun2 (floatEq :: Rel Double) - , "primFloatLess" |-> mkPrimFun2 (floatLt :: Rel Double) - , "primFloatNumericalEquality" |-> mkPrimFun2 ((==) :: Rel Double) - , "primFloatNumericalLess" |-> mkPrimFun2 ((<) :: Rel Double) - , "primFloatSqrt" |-> mkPrimFun1 (sqrt :: Double -> Double) - , "primRound" |-> mkPrimFun1 (round :: Double -> Integer) - , "primFloor" |-> mkPrimFun1 (floor :: Double -> Integer) - , "primCeiling" |-> mkPrimFun1 (ceiling :: Double -> Integer) - , "primExp" |-> mkPrimFun1 (exp :: Fun Double) - , "primLog" |-> mkPrimFun1 (log :: Fun Double) - , "primSin" |-> mkPrimFun1 (sin :: Fun Double) - , "primCos" |-> mkPrimFun1 (cos :: Fun Double) - , "primTan" |-> mkPrimFun1 (tan :: Fun Double) - , "primASin" |-> mkPrimFun1 (asin :: Fun Double) - , "primACos" |-> mkPrimFun1 (acos :: Fun Double) - , "primATan" |-> mkPrimFun1 (atan :: Fun Double) - , "primATan2" |-> mkPrimFun2 (atan2 :: Double -> Double -> Double) - , "primShowFloat" |-> mkPrimFun1 (Str . show :: Double -> Str) - - -- Character functions - , "primCharEquality" |-> mkPrimFun2 ((==) :: Rel Char) - , "primIsLower" |-> mkPrimFun1 isLower - , "primIsDigit" |-> mkPrimFun1 isDigit - , "primIsAlpha" |-> mkPrimFun1 isAlpha - , "primIsSpace" |-> mkPrimFun1 isSpace - , "primIsAscii" |-> mkPrimFun1 isAscii - , "primIsLatin1" |-> mkPrimFun1 isLatin1 - , "primIsPrint" |-> mkPrimFun1 isPrint - , "primIsHexDigit" |-> mkPrimFun1 isHexDigit - , "primToUpper" |-> mkPrimFun1 toUpper - , "primToLower" |-> mkPrimFun1 toLower - , "primCharToNat" |-> mkPrimFun1 (fromIntegral . fromEnum :: Char -> Nat) - , "primCharToNatInjective" |-> primCharToNatInjective - , "primNatToChar" |-> mkPrimFun1 (toEnum . fromIntegral . (`mod` 0x110000) :: Nat -> Char) - , "primShowChar" |-> mkPrimFun1 (Str . show . pretty . LitChar noRange) - - -- String functions - , "primStringToList" |-> mkPrimFun1 unStr - , "primStringToListInjective" |-> primStringToListInjective - , "primStringFromList" |-> mkPrimFun1 Str - , "primStringAppend" |-> mkPrimFun2 (\s1 s2 -> Str $ unStr s1 ++ unStr s2) - , "primStringEquality" |-> mkPrimFun2 ((==) :: Rel Str) - , "primShowString" |-> mkPrimFun1 (Str . show . pretty . LitString noRange . unStr) - - -- Other stuff - , "primEraseEquality" |-> primEraseEquality - -- This needs to be force : A → ((x : A) → B x) → B x rather than seq because of call-by-name. - , "primForce" |-> primForce - , "primForceLemma" |-> primForceLemma - , "primQNameEquality" |-> mkPrimFun2 ((==) :: Rel QName) - , "primQNameLess" |-> mkPrimFun2 ((<) :: Rel QName) - , "primShowQName" |-> mkPrimFun1 (Str . prettyShow :: QName -> Str) - , "primQNameFixity" |-> mkPrimFun1 (nameFixity . qnameName) - , "primMetaEquality" |-> mkPrimFun2 ((==) :: Rel MetaId) - , "primMetaLess" |-> mkPrimFun2 ((<) :: Rel MetaId) - , "primShowMeta" |-> mkPrimFun1 (Str . prettyShow :: MetaId -> Str) - , "primIMin" |-> primIMin' - , "primIMax" |-> primIMax' - , "primINeg" |-> primINeg' - , "primPOr" |-> primPOr - , "primComp" |-> primComp - , builtinTrans |-> primTrans' - , builtinHComp |-> primHComp' - , "primIdJ" |-> primIdJ - , "primPartial" |-> primPartial' - , "primPartialP" |-> primPartialP' - , builtinGlue |-> primGlue' - , builtin_glue |-> prim_glue' - , builtin_unglue |-> prim_unglue' - , builtinFaceForall |-> primFaceForall' - , "primDepIMin" |-> primDepIMin' - , "primIdFace" |-> primIdFace' - , "primIdPath" |-> primIdPath' - , builtinIdElim |-> primIdElim' - , builtinSubOut |-> primSubOut' - ] - where - (|->) = (,) - -lookupPrimitiveFunction :: String -> TCM PrimitiveImpl -lookupPrimitiveFunction x = - fromMaybe (typeError $ NoSuchPrimitiveFunction x) - (Map.lookup x primitiveFunctions) - -lookupPrimitiveFunctionQ :: QName -> TCM (String, PrimitiveImpl) -lookupPrimitiveFunctionQ q = do - let s = case qnameName q of - Name _ x _ _ _ -> prettyShow x - PrimImpl t pf <- lookupPrimitiveFunction s - return (s, PrimImpl t $ pf { primFunName = q }) - -getBuiltinName :: String -> TCM (Maybe QName) -getBuiltinName b = do - caseMaybeM (getBuiltin' b) (return Nothing) (Just <.> getName) - where - getName v = do - v <- reduce v - case unSpine $ v of - Def x _ -> return x - Con x _ _ -> return $ conName x - Lam _ b -> getName $ unAbs b - _ -> __IMPOSSIBLE__ - - -isBuiltin :: QName -> String -> TCM Bool -isBuiltin q b = (Just q ==) <$> getBuiltinName b +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +{-# LANGUAGE UndecidableInstances #-} +{-# LANGUAGE NondecreasingIndentation #-} +{-# LANGUAGE MonoLocalBinds #-} + +{-| Primitive functions, such as addition on builtin integers. +-} +module Agda.TypeChecking.Primitive + ( module Agda.TypeChecking.Primitive.Base + , module Agda.TypeChecking.Primitive.Cubical + , module Agda.TypeChecking.Primitive + ) where + +import Data.Char +import Data.Map (Map) +import qualified Data.Map as Map +import Data.Maybe +import Data.Word + +import qualified Agda.Interaction.Options.Lenses as Lens + +import Agda.Syntax.Position +import Agda.Syntax.Common hiding (Nat) +import Agda.Syntax.Internal +import Agda.Syntax.Internal.Generic (TermLike(..)) +import Agda.Syntax.Internal.MetaVars +import Agda.Syntax.Literal +import Agda.Syntax.Fixity + +import Agda.TypeChecking.Monad hiding (getConstInfo, typeOfConst) +import Agda.TypeChecking.Monad.Builtin +import Agda.TypeChecking.Reduce +import Agda.TypeChecking.Reduce.Monad as Reduce +import Agda.TypeChecking.Substitute +import Agda.TypeChecking.Telescope +import Agda.TypeChecking.Level + +import Agda.TypeChecking.Quote (quoteTermWithKit, quoteTypeWithKit, quotingKit) +import Agda.TypeChecking.Primitive.Base +import Agda.TypeChecking.Primitive.Cubical +import Agda.TypeChecking.Warnings + +import Agda.Utils.Float +import Agda.Utils.List +import Agda.Utils.Monad +import Agda.Utils.Pretty (prettyShow) +import Agda.Utils.Singleton +import Agda.Utils.Size +import Agda.Utils.String ( Str(Str), unStr ) + +import Agda.Utils.Impossible + +-- Haskell type to Agda type + +newtype Nat = Nat { unNat :: Integer } + deriving (Eq, Ord, Num, Enum, Real) + +-- In GHC > 7.8 deriving Integral causes an unnecessary toInteger +-- warning. +instance Integral Nat where + toInteger = unNat + quotRem (Nat a) (Nat b) = (Nat q, Nat r) + where (q, r) = quotRem a b + +instance TermLike Nat where + traverseTermM _ = pure + foldTerm _ = mempty + +instance Show Nat where + show = show . toInteger + +newtype Lvl = Lvl { unLvl :: Integer } + deriving (Eq, Ord) + +instance Show Lvl where + show = show . unLvl + +class PrimType a where + primType :: a -> TCM Type + +instance (PrimType a, PrimType b) => PrimTerm (a -> b) where + primTerm _ = unEl <$> (primType (undefined :: a) --> primType (undefined :: b)) + +instance (PrimType a, PrimType b) => PrimTerm (a, b) where + primTerm _ = do + sigKit <- fromMaybe __IMPOSSIBLE__ <$> getSigmaKit + let sig = Def (sigmaName sigKit) [] + a' <- primType (undefined :: a) + b' <- primType (undefined :: b) + Type la <- pure $ getSort a' + Type lb <- pure $ getSort b' + pure sig <#> pure (Level la) + <#> pure (Level lb) + <@> pure (unEl a') + <@> pure (nolam $ unEl b') + +instance PrimTerm a => PrimType a where + primType _ = el $ primTerm (undefined :: a) + +class PrimTerm a where primTerm :: a -> TCM Term +instance PrimTerm Integer where primTerm _ = primInteger +instance PrimTerm Word64 where primTerm _ = primWord64 +instance PrimTerm Bool where primTerm _ = primBool +instance PrimTerm Char where primTerm _ = primChar +instance PrimTerm Double where primTerm _ = primFloat +instance PrimTerm Str where primTerm _ = primString +instance PrimTerm Nat where primTerm _ = primNat +instance PrimTerm Lvl where primTerm _ = primLevel +instance PrimTerm QName where primTerm _ = primQName +instance PrimTerm MetaId where primTerm _ = primAgdaMeta +instance PrimTerm Type where primTerm _ = primAgdaTerm + +instance PrimTerm Fixity' where primTerm _ = primFixity + +instance PrimTerm a => PrimTerm [a] where + primTerm _ = list (primTerm (undefined :: a)) + +instance PrimTerm a => PrimTerm (IO a) where + primTerm _ = io (primTerm (undefined :: a)) + +-- From Agda term to Haskell value + +class ToTerm a where + toTerm :: TCM (a -> Term) + toTermR :: TCM (a -> ReduceM Term) + + toTermR = (pure .) <$> toTerm + +instance ToTerm Nat where toTerm = return $ Lit . LitNat noRange . toInteger +instance ToTerm Word64 where toTerm = return $ Lit . LitWord64 noRange +instance ToTerm Lvl where toTerm = return $ Level . ClosedLevel . unLvl +instance ToTerm Double where toTerm = return $ Lit . LitFloat noRange +instance ToTerm Char where toTerm = return $ Lit . LitChar noRange +instance ToTerm Str where toTerm = return $ Lit . LitString noRange . unStr +instance ToTerm QName where toTerm = return $ Lit . LitQName noRange +instance ToTerm MetaId where + toTerm = do + file <- getCurrentPath + return $ Lit . LitMeta noRange file + +instance ToTerm Integer where + toTerm = do + pos <- primIntegerPos + negsuc <- primIntegerNegSuc + fromNat <- toTerm :: TCM (Nat -> Term) + let intToTerm = fromNat . fromIntegral :: Integer -> Term + let fromInt n | n >= 0 = apply pos [defaultArg $ intToTerm n] + | otherwise = apply negsuc [defaultArg $ intToTerm (-n - 1)] + return fromInt + +instance ToTerm Bool where + toTerm = do + true <- primTrue + false <- primFalse + return $ \b -> if b then true else false + +instance ToTerm Term where + toTerm = do kit <- quotingKit; runReduceF (quoteTermWithKit kit) + toTermR = do kit <- quotingKit; return (quoteTermWithKit kit) + +instance ToTerm Type where + toTerm = do kit <- quotingKit; runReduceF (quoteTypeWithKit kit) + toTermR = do kit <- quotingKit; return (quoteTypeWithKit kit) + +instance ToTerm ArgInfo where + toTerm = do + info <- primArgArgInfo + vis <- primVisible + hid <- primHidden + ins <- primInstance + rel <- primRelevant + irr <- primIrrelevant + return $ \ i -> info `applys` + [ case getHiding i of + NotHidden -> vis + Hidden -> hid + Instance{} -> ins + , case getRelevance i of + Relevant -> rel + Irrelevant -> irr + NonStrict -> rel + ] + +instance ToTerm Fixity' where + toTerm = (. theFixity) <$> toTerm + +instance ToTerm Fixity where + toTerm = do + lToTm <- toTerm + aToTm <- toTerm + fixity <- primFixityFixity + return $ \ Fixity{fixityAssoc = a, fixityLevel = l} -> + fixity `apply` [defaultArg (aToTm a), defaultArg (lToTm l)] + +instance ToTerm Associativity where + toTerm = do + lassoc <- primAssocLeft + rassoc <- primAssocRight + nassoc <- primAssocNon + return $ \ a -> + case a of + NonAssoc -> nassoc + LeftAssoc -> lassoc + RightAssoc -> rassoc + +instance ToTerm FixityLevel where + toTerm = do + (iToTm :: PrecedenceLevel -> Term) <- toTerm + related <- primPrecRelated + unrelated <- primPrecUnrelated + return $ \ p -> + case p of + Unrelated -> unrelated + Related n -> related `apply` [defaultArg $ iToTm n] + +instance (ToTerm a, ToTerm b) => ToTerm (a, b) where + toTerm = do + sigKit <- fromMaybe __IMPOSSIBLE__ <$> getSigmaKit + let con = Con (sigmaCon sigKit) ConOSystem [] + fromA <- toTerm + fromB <- toTerm + pure $ \ (a, b) -> con `apply` map defaultArg [fromA a, fromB b] + +-- | @buildList A ts@ builds a list of type @List A@. Assumes that the terms +-- @ts@ all have type @A@. +buildList :: TCM ([Term] -> Term) +buildList = do + nil' <- primNil + cons' <- primCons + let nil = nil' + cons x xs = cons' `applys` [x, xs] + return $ foldr cons nil + +instance ToTerm a => ToTerm [a] where + toTerm = do + mkList <- buildList + fromA <- toTerm + return $ mkList . map fromA + +-- From Haskell value to Agda term + +type FromTermFunction a = Arg Term -> + ReduceM (Reduced (MaybeReduced (Arg Term)) a) + +class FromTerm a where + fromTerm :: TCM (FromTermFunction a) + +instance FromTerm Integer where + fromTerm = do + Con pos _ [] <- primIntegerPos + Con negsuc _ [] <- primIntegerNegSuc + toNat <- fromTerm :: TCM (FromTermFunction Nat) + return $ \ v -> do + b <- reduceB' v + let v' = ignoreBlocking b + arg = (<$ v') + case unArg (ignoreBlocking b) of + Con c ci [Apply u] + | c == pos -> + redBind (toNat u) + (\ u' -> notReduced $ arg $ Con c ci [Apply $ ignoreReduced u']) $ \ n -> + redReturn $ fromIntegral n + | c == negsuc -> + redBind (toNat u) + (\ u' -> notReduced $ arg $ Con c ci [Apply $ ignoreReduced u']) $ \ n -> + redReturn $ fromIntegral $ -n - 1 + _ -> return $ NoReduction (reduced b) + +instance FromTerm Nat where + fromTerm = fromLiteral $ \l -> case l of + LitNat _ n -> Just $ fromInteger n + _ -> Nothing + +instance FromTerm Word64 where + fromTerm = fromLiteral $ \ case + LitWord64 _ n -> Just n + _ -> Nothing + +instance FromTerm Lvl where + fromTerm = fromReducedTerm $ \l -> case l of + Level (ClosedLevel n) -> Just $ Lvl n + _ -> Nothing + +instance FromTerm Double where + fromTerm = fromLiteral $ \l -> case l of + LitFloat _ x -> Just x + _ -> Nothing + +instance FromTerm Char where + fromTerm = fromLiteral $ \l -> case l of + LitChar _ c -> Just c + _ -> Nothing + +instance FromTerm Str where + fromTerm = fromLiteral $ \l -> case l of + LitString _ s -> Just $ Str s + _ -> Nothing + +instance FromTerm QName where + fromTerm = fromLiteral $ \l -> case l of + LitQName _ x -> Just x + _ -> Nothing + +instance FromTerm MetaId where + fromTerm = fromLiteral $ \l -> case l of + LitMeta _ _ x -> Just x + _ -> Nothing + +instance FromTerm Bool where + fromTerm = do + true <- primTrue + false <- primFalse + fromReducedTerm $ \t -> case t of + _ | t =?= true -> Just True + | t =?= false -> Just False + | otherwise -> Nothing + where + a =?= b = a === b + Def x [] === Def y [] = x == y + Con x _ [] === Con y _ [] = x == y + Var n [] === Var m [] = n == m + _ === _ = False + +instance (ToTerm a, FromTerm a) => FromTerm [a] where + fromTerm = do + nil' <- primNil + cons' <- primCons + nil <- isCon nil' + cons <- isCon cons' + toA <- fromTerm + fromA <- toTerm + return $ mkList nil cons toA fromA + where + isCon (Lam _ b) = isCon $ absBody b + isCon (Con c _ _)= return c + isCon v = __IMPOSSIBLE__ + + mkList nil cons toA fromA t = do + b <- reduceB' t + let t = ignoreBlocking b + let arg = (<$ t) + case unArg t of + Con c ci [] + | c == nil -> return $ YesReduction NoSimplification [] + Con c ci es + | c == cons, Just [x,xs] <- allApplyElims es -> + redBind (toA x) + (\x' -> notReduced $ arg $ Con c ci (map Apply [ignoreReduced x',xs])) $ \y -> + redBind + (mkList nil cons toA fromA xs) + (fmap $ \xs' -> arg $ Con c ci (map Apply [defaultArg $ fromA y, xs'])) $ \ys -> + redReturn (y : ys) + _ -> return $ NoReduction (reduced b) + +fromReducedTerm :: (Term -> Maybe a) -> TCM (FromTermFunction a) +fromReducedTerm f = return $ \t -> do + b <- reduceB' t + case f $ unArg (ignoreBlocking b) of + Just x -> return $ YesReduction NoSimplification x + Nothing -> return $ NoReduction (reduced b) + +fromLiteral :: (Literal -> Maybe a) -> TCM (FromTermFunction a) +fromLiteral f = fromReducedTerm $ \t -> case t of + Lit lit -> f lit + _ -> Nothing + +-- | @mkPrimInjective@ takes two Set0 @a@ and @b@ and a function @f@ of type +-- @a -> b@ and outputs a primitive internalizing the fact that @f@ is injective. +mkPrimInjective :: Type -> Type -> QName -> TCM PrimitiveImpl +mkPrimInjective a b qn = do + -- Define the type + eqName <- primEqualityName + let lvl0 = ClosedLevel 0 + let eq a t u = El (Type lvl0) <$> pure (Def eqName []) <#> pure (Level lvl0) + <#> pure (unEl a) <@> t <@> u + let f = pure (Def qn []) + ty <- nPi "t" (pure a) $ nPi "u" (pure a) $ + (eq b (f <@> varM 1) (f <@> varM 0)) + --> (eq a ( varM 1) ( varM 0)) + + -- Get the constructor corresponding to BUILTIN REFL + refl <- getRefl + + -- Implementation: when the equality argument reduces to refl so does the primitive. + -- If the user want the primitive to reduce whenever the two values are equal (no + -- matter whether the equality is refl), they can combine it with @eraseEquality@. + return $ PrimImpl ty $ primFun __IMPOSSIBLE__ 3 $ \ ts -> do + let t = headWithDefault __IMPOSSIBLE__ ts + let eq = unArg $ fromMaybe __IMPOSSIBLE__ $ lastMaybe ts + eq' <- normalise' eq + case eq' of + Con{} -> redReturn $ refl t + _ -> return $ NoReduction $ map notReduced ts + +primMetaToNatInjective :: TCM PrimitiveImpl +primMetaToNatInjective = do + meta <- primType (undefined :: MetaId) + nat <- primType (undefined :: Nat) + toNat <- primFunName <$> getPrimitive "primMetaToNat" + mkPrimInjective meta nat toNat + +primCharToNatInjective :: TCM PrimitiveImpl +primCharToNatInjective = do + char <- primType (undefined :: Char) + nat <- primType (undefined :: Nat) + toNat <- primFunName <$> getPrimitive "primCharToNat" + mkPrimInjective char nat toNat + +primStringToListInjective :: TCM PrimitiveImpl +primStringToListInjective = do + string <- primType (undefined :: Str) + chars <- primType (undefined :: String) + toList <- primFunName <$> getPrimitive "primStringToList" + mkPrimInjective string chars toList + +primWord64ToNatInjective :: TCM PrimitiveImpl +primWord64ToNatInjective = do + word <- primType (undefined :: Word64) + nat <- primType (undefined :: Nat) + toNat <- primFunName <$> getPrimitive "primWord64ToNat" + mkPrimInjective word nat toNat + +primFloatToWord64Injective :: TCM PrimitiveImpl +primFloatToWord64Injective = do + float <- primType (undefined :: Double) + word <- primType (undefined :: Word64) + toWord <- primFunName <$> getPrimitive "primFloatToWord64" + mkPrimInjective float word toWord + +primQNameToWord64sInjective :: TCM PrimitiveImpl +primQNameToWord64sInjective = do + name <- primType (undefined :: QName) + words <- primType (undefined :: (Word64, Word64)) + toWords <- primFunName <$> getPrimitive "primQNameToWord64s" + mkPrimInjective name words toWords + +getRefl :: TCM (Arg Term -> Term) +getRefl = do + -- BUILTIN REFL maybe a constructor with one (the principal) argument or only parameters. + -- Get the ArgInfo of the principal argument of refl. + con@(Con rf ci []) <- primRefl + minfo <- fmap (setOrigin Inserted) <$> getReflArgInfo rf + pure $ case minfo of + Just ai -> Con rf ci . (:[]) . Apply . setArgInfo ai + Nothing -> const con + +-- | @primEraseEquality : {a : Level} {A : Set a} {x y : A} -> x ≡ y -> x ≡ y@ +primEraseEquality :: TCM PrimitiveImpl +primEraseEquality = do + -- primEraseEquality is incompatible with --without-K + -- We raise an error warning if --safe is set and a mere warning otherwise + whenM withoutKOption $ + ifM (Lens.getSafeMode <$> commandLineOptions) + {- then -} (warning SafeFlagWithoutKFlagPrimEraseEquality) + {- else -} (warning WithoutKFlagPrimEraseEquality) + -- Get the name and type of BUILTIN EQUALITY + eq <- primEqualityName + eqTy <- defType <$> getConstInfo eq + -- E.g. @eqTy = eqTel → Set a@ where @eqTel = {a : Level} {A : Set a} (x y : A)@. + TelV eqTel eqCore <- telView eqTy + let eqSort = case unEl eqCore of + Sort s -> s + _ -> __IMPOSSIBLE__ + + -- Construct the type of primEraseEquality, e.g. + -- @{a : Level} {A : Set a} {x y : A} → eq {a} {A} x y -> eq {a} {A} x y@. + t <- let xeqy = pure $ El eqSort $ Def eq $ map Apply $ teleArgs eqTel in + telePi_ (fmap hide eqTel) <$> (xeqy --> xeqy) + + -- Get the constructor corresponding to BUILTIN REFL + refl <- getRefl + + -- The implementation of primEraseEquality: + return $ PrimImpl t $ primFun __IMPOSSIBLE__ (1 + size eqTel) $ \ ts -> do + let (u, v) = fromMaybe __IMPOSSIBLE__ $ last2 =<< initMaybe ts + -- Andreas, 2013-07-22. + -- Note that we cannot call the conversion checker here, + -- because 'reduce' might be called in a context where + -- some bound variables do not have a type (just __DUMMY_TYPE__), + -- and the conversion checker for eliminations does not + -- like this. + -- We can only do untyped equality, e.g., by normalisation. + (u', v') <- normalise' (u, v) + if u' == v' then redReturn $ refl u else + return $ NoReduction $ map notReduced ts + +-- | Get the 'ArgInfo' of the principal argument of BUILTIN REFL. +-- +-- Returns @Nothing@ for e.g. +-- @ +-- data Eq {a} {A : Set a} (x : A) : A → Set a where +-- refl : Eq x x +-- @ +-- +-- Returns @Just ...@ for e.g. +-- @ +-- data Eq {a} {A : Set a} : (x y : A) → Set a where +-- refl : ∀ x → Eq x x +-- @ + +getReflArgInfo :: ConHead -> TCM (Maybe ArgInfo) +getReflArgInfo rf = do + def <- getConInfo rf + TelV reflTel _ <- telView $ defType def + return $ fmap getArgInfo $ listToMaybe $ drop (conPars $ theDef def) $ telToList reflTel + + +-- | Used for both @primForce@ and @primForceLemma@. +genPrimForce :: TCM Type -> (Term -> Arg Term -> Term) -> TCM PrimitiveImpl +genPrimForce b ret = do + let varEl s a = El (varSort s) <$> a + varT s a = varEl s (varM a) + varS s = pure $ sort $ varSort s + t <- hPi "a" (el primLevel) $ + hPi "b" (el primLevel) $ + hPi "A" (varS 1) $ + hPi "B" (varT 2 0 --> varS 1) b + return $ PrimImpl t $ primFun __IMPOSSIBLE__ 6 $ \ ts -> + case ts of + [a, b, s, t, u, f] -> do + u <- reduceB' u + let isWHNF Blocked{} = return False + isWHNF (NotBlocked _ u) = + case unArg u of + Lit{} -> return True + Con{} -> return True + Lam{} -> return True + Pi{} -> return True + Sort{} -> return True -- sorts and levels are considered whnf + Level{} -> return True + DontCare{} -> return True + Def q _ -> do + def <- theDef <$> getConstInfo q + return $ case def of + Datatype{} -> True + Record{} -> True + _ -> False + MetaV{} -> return False + Var{} -> return False + Dummy s _ -> __IMPOSSIBLE_VERBOSE__ s + ifM (isWHNF u) + (redReturn $ ret (unArg f) (ignoreBlocking u)) + (return $ NoReduction $ map notReduced [a, b, s, t] ++ [reduced u, notReduced f]) + _ -> __IMPOSSIBLE__ + +primForce :: TCM PrimitiveImpl +primForce = do + let varEl s a = El (varSort s) <$> a + varT s a = varEl s (varM a) + varS s = pure $ sort $ varSort s + genPrimForce (nPi "x" (varT 3 1) $ + (nPi "y" (varT 4 2) $ varEl 4 $ varM 2 <@> varM 0) --> + varEl 3 (varM 1 <@> varM 0)) $ + \ f u -> apply f [u] + +primForceLemma :: TCM PrimitiveImpl +primForceLemma = do + let varEl s a = El (varSort s) <$> a + varT s a = varEl s (varM a) + varS s = pure $ sort $ varSort s + refl <- primRefl + force <- primFunName <$> getPrimitive "primForce" + genPrimForce (nPi "x" (varT 3 1) $ + nPi "f" (nPi "y" (varT 4 2) $ varEl 4 $ varM 2 <@> varM 0) $ + varEl 4 $ primEquality <#> varM 4 <#> (varM 2 <@> varM 1) + <@> (pure (Def force []) <#> varM 5 <#> varM 4 <#> varM 3 <#> varM 2 <@> varM 1 <@> varM 0) + <@> (varM 0 <@> varM 1) + ) $ \ _ _ -> refl + +mkPrimLevelZero :: TCM PrimitiveImpl +mkPrimLevelZero = do + t <- primType (undefined :: Lvl) + return $ PrimImpl t $ primFun __IMPOSSIBLE__ 0 $ \_ -> redReturn $ Level $ ClosedLevel 0 + +mkPrimLevelSuc :: TCM PrimitiveImpl +mkPrimLevelSuc = do + t <- primType (id :: Lvl -> Lvl) + return $ PrimImpl t $ primFun __IMPOSSIBLE__ 1 $ \ ~[a] -> do + l <- levelView' $ unArg a + redReturn $ Level $ levelSuc l + +mkPrimLevelMax :: TCM PrimitiveImpl +mkPrimLevelMax = do + t <- primType (max :: Op Lvl) + return $ PrimImpl t $ primFun __IMPOSSIBLE__ 2 $ \ ~[a, b] -> do + a' <- levelView' $ unArg a + b' <- levelView' $ unArg b + redReturn $ Level $ levelLub a' b' + +mkPrimSetOmega :: TCM PrimitiveImpl +mkPrimSetOmega = do + let t = sort $ UnivSort Inf + return $ PrimImpl t $ primFun __IMPOSSIBLE__ 0 $ \_ -> redReturn $ Sort Inf + +mkPrimFun1TCM :: (FromTerm a, ToTerm b, TermLike b) => + TCM Type -> (a -> ReduceM b) -> TCM PrimitiveImpl +mkPrimFun1TCM mt f = do + toA <- fromTerm + fromB <- toTermR + t <- mt + return $ PrimImpl t $ primFun __IMPOSSIBLE__ 1 $ \ts -> + case ts of + [v] -> + redBind (toA v) singleton $ \ x -> do + b <- f x + case firstMeta b of + Just m -> return $ NoReduction [reduced (Blocked m v)] + Nothing -> redReturn =<< fromB b + _ -> __IMPOSSIBLE__ + +-- Tying the knot +mkPrimFun1 :: (PrimType a, FromTerm a, PrimType b, ToTerm b) => + (a -> b) -> TCM PrimitiveImpl +mkPrimFun1 f = do + toA <- fromTerm + fromB <- toTerm + t <- primType f + return $ PrimImpl t $ primFun __IMPOSSIBLE__ 1 $ \ts -> + case ts of + [v] -> + redBind (toA v) singleton $ \ x -> + redReturn $ fromB $ f x + _ -> __IMPOSSIBLE__ + +mkPrimFun2 :: ( PrimType a, FromTerm a, ToTerm a + , PrimType b, FromTerm b + , PrimType c, ToTerm c ) => + (a -> b -> c) -> TCM PrimitiveImpl +mkPrimFun2 f = do + toA <- fromTerm + fromA <- toTerm + toB <- fromTerm + fromC <- toTerm + t <- primType f + return $ PrimImpl t $ primFun __IMPOSSIBLE__ 2 $ \ts -> + case ts of + [v,w] -> + redBind (toA v) + (\v' -> [v', notReduced w]) $ \x -> + redBind (toB w) + (\w' -> [ reduced $ notBlocked $ Arg (argInfo v) (fromA x) + , w']) $ \y -> + redReturn $ fromC $ f x y + _ -> __IMPOSSIBLE__ + +mkPrimFun4 :: ( PrimType a, FromTerm a, ToTerm a + , PrimType b, FromTerm b, ToTerm b + , PrimType c, FromTerm c, ToTerm c + , PrimType d, FromTerm d + , PrimType e, ToTerm e ) => + (a -> b -> c -> d -> e) -> TCM PrimitiveImpl +mkPrimFun4 f = do + (toA, fromA) <- (,) <$> fromTerm <*> toTerm + (toB, fromB) <- (,) <$> fromTerm <*> toTerm + (toC, fromC) <- (,) <$> fromTerm <*> toTerm + toD <- fromTerm + fromE <- toTerm + t <- primType f + return $ PrimImpl t $ primFun __IMPOSSIBLE__ 4 $ \ts -> + let argFrom fromX a x = + reduced $ notBlocked $ Arg (argInfo a) (fromX x) + in case ts of + [a,b,c,d] -> + redBind (toA a) + (\a' -> a' : map notReduced [b,c,d]) $ \x -> + redBind (toB b) + (\b' -> [argFrom fromA a x, b', notReduced c, notReduced d]) $ \y -> + redBind (toC c) + (\c' -> [ argFrom fromA a x + , argFrom fromB b y + , c', notReduced d]) $ \z -> + redBind (toD d) + (\d' -> [ argFrom fromA a x + , argFrom fromB b y + , argFrom fromC c z + , d']) $ \w -> + + redReturn $ fromE $ f x y z w + _ -> __IMPOSSIBLE__ + + +--------------------------------------------------------------------------- +-- * The actual primitive functions +--------------------------------------------------------------------------- + +type Op a = a -> a -> a +type Fun a = a -> a +type Rel a = a -> a -> Bool +type Pred a = a -> Bool + +primitiveFunctions :: Map String (TCM PrimitiveImpl) +primitiveFunctions = fmap localTCStateSavingWarnings $ Map.fromList + -- Issue #4375 ^^^^^^^^^^^^^^^^^^^^^^^^^^ + -- Without this the next fresh checkpoint id gets changed building the primitive functions. This + -- is bad for caching since it happens when scope checking import declarations (rebinding + -- primitives). During type checking, the caching machinery might then load a cached state with + -- out-of-date checkpoint ids. Make sure to preserve warnings though, since they include things + -- like using unsafe things primitives with `--safe`. + + -- Ulf, 2015-10-28: Builtin integers now map to a datatype, and since you + -- can define these functions (reasonably) efficiently using the primitive + -- functions on natural numbers there's no need for them anymore. Keeping the + -- show function around for convenience, and as a test case for a primitive + -- function taking an integer. + -- -- Integer functions + -- [ "primIntegerPlus" |-> mkPrimFun2 ((+) :: Op Integer) + -- , "primIntegerMinus" |-> mkPrimFun2 ((-) :: Op Integer) + -- , "primIntegerTimes" |-> mkPrimFun2 ((*) :: Op Integer) + -- , "primIntegerDiv" |-> mkPrimFun2 (div :: Op Integer) -- partial + -- , "primIntegerMod" |-> mkPrimFun2 (mod :: Op Integer) -- partial + -- , "primIntegerEquality" |-> mkPrimFun2 ((==) :: Rel Integer) + -- , "primIntegerLess" |-> mkPrimFun2 ((<) :: Rel Integer) + -- , "primIntegerAbs" |-> mkPrimFun1 (Nat . abs :: Integer -> Nat) + -- , "primNatToInteger" |-> mkPrimFun1 (toInteger :: Nat -> Integer) + [ "primShowInteger" |-> mkPrimFun1 (Str . show :: Integer -> Str) + + -- Natural number functions + , "primNatPlus" |-> mkPrimFun2 ((+) :: Op Nat) + , "primNatMinus" |-> mkPrimFun2 ((\x y -> max 0 (x - y)) :: Op Nat) + , "primNatTimes" |-> mkPrimFun2 ((*) :: Op Nat) + , "primNatDivSucAux" |-> mkPrimFun4 ((\k m n j -> k + div (max 0 $ n + m - j) (m + 1)) :: Nat -> Nat -> Op Nat) + , "primNatModSucAux" |-> + let aux :: Nat -> Nat -> Op Nat + aux k m n j | n > j = mod (n - j - 1) (m + 1) + | otherwise = k + n + in mkPrimFun4 aux + , "primNatEquality" |-> mkPrimFun2 ((==) :: Rel Nat) + , "primNatLess" |-> mkPrimFun2 ((<) :: Rel Nat) + , "primShowNat" |-> mkPrimFun1 (Str . show :: Nat -> Str) + + -- Machine words + , "primWord64ToNat" |-> mkPrimFun1 (fromIntegral :: Word64 -> Nat) + , "primWord64FromNat" |-> mkPrimFun1 (fromIntegral :: Nat -> Word64) + , "primWord64ToNatInjective" |-> primWord64ToNatInjective + + -- Level functions + , "primLevelZero" |-> mkPrimLevelZero + , "primLevelSuc" |-> mkPrimLevelSuc + , "primLevelMax" |-> mkPrimLevelMax + + -- Sorts + , "primSetOmega" |-> mkPrimSetOmega + + -- Floating point functions + , "primNatToFloat" |-> mkPrimFun1 (fromIntegral :: Nat -> Double) + , "primFloatPlus" |-> mkPrimFun2 ((+) :: Op Double) + , "primFloatMinus" |-> mkPrimFun2 ((-) :: Op Double) + , "primFloatTimes" |-> mkPrimFun2 ((*) :: Op Double) + , "primFloatNegate" |-> mkPrimFun1 (negate :: Fun Double) + , "primFloatDiv" |-> mkPrimFun2 ((/) :: Op Double) + -- ASR (2016-09-29). We use bitwise equality for comparing Double + -- because Haskell's Eq, which equates 0.0 and -0.0, allows to prove + -- a contradiction (see Issue #2169). + , "primFloatEquality" |-> mkPrimFun2 (floatEq :: Rel Double) + , "primFloatLess" |-> mkPrimFun2 (floatLt :: Rel Double) + , "primFloatNumericalEquality" |-> mkPrimFun2 ((==) :: Rel Double) + , "primFloatNumericalLess" |-> mkPrimFun2 ((<) :: Rel Double) + , "primFloatSqrt" |-> mkPrimFun1 (sqrt :: Double -> Double) + , "primRound" |-> mkPrimFun1 (round . normaliseNaN :: Double -> Integer) + , "primFloor" |-> mkPrimFun1 (floor . normaliseNaN :: Double -> Integer) + , "primCeiling" |-> mkPrimFun1 (ceiling . normaliseNaN :: Double -> Integer) + , "primExp" |-> mkPrimFun1 (exp :: Fun Double) + , "primLog" |-> mkPrimFun1 (log :: Fun Double) + , "primSin" |-> mkPrimFun1 (sin :: Fun Double) + , "primCos" |-> mkPrimFun1 (cos :: Fun Double) + , "primTan" |-> mkPrimFun1 (tan :: Fun Double) + , "primASin" |-> mkPrimFun1 (asin :: Fun Double) + , "primACos" |-> mkPrimFun1 (acos :: Fun Double) + , "primATan" |-> mkPrimFun1 (atan :: Fun Double) + , "primATan2" |-> mkPrimFun2 (atan2 :: Op Double) + , "primShowFloat" |-> mkPrimFun1 (Str . show :: Double -> Str) + , "primFloatToWord64" |-> mkPrimFun1 doubleToWord64 + , "primFloatToWord64Injective" |-> primFloatToWord64Injective + + -- Character functions + , "primCharEquality" |-> mkPrimFun2 ((==) :: Rel Char) + , "primIsLower" |-> mkPrimFun1 isLower + , "primIsDigit" |-> mkPrimFun1 isDigit + , "primIsAlpha" |-> mkPrimFun1 isAlpha + , "primIsSpace" |-> mkPrimFun1 isSpace + , "primIsAscii" |-> mkPrimFun1 isAscii + , "primIsLatin1" |-> mkPrimFun1 isLatin1 + , "primIsPrint" |-> mkPrimFun1 isPrint + , "primIsHexDigit" |-> mkPrimFun1 isHexDigit + , "primToUpper" |-> mkPrimFun1 toUpper + , "primToLower" |-> mkPrimFun1 toLower + , "primCharToNat" |-> mkPrimFun1 (fromIntegral . fromEnum :: Char -> Nat) + , "primCharToNatInjective" |-> primCharToNatInjective + , "primNatToChar" |-> mkPrimFun1 (toEnum . fromIntegral . (`mod` 0x110000) :: Nat -> Char) + , "primShowChar" |-> mkPrimFun1 (Str . prettyShow . LitChar noRange) + + -- String functions + , "primStringToList" |-> mkPrimFun1 unStr + , "primStringToListInjective" |-> primStringToListInjective + , "primStringFromList" |-> mkPrimFun1 Str + , "primStringAppend" |-> mkPrimFun2 (\s1 s2 -> Str $ unStr s1 ++ unStr s2) + , "primStringEquality" |-> mkPrimFun2 ((==) :: Rel Str) + , "primShowString" |-> mkPrimFun1 (Str . prettyShow . LitString noRange . unStr) + + -- Other stuff + , "primEraseEquality" |-> primEraseEquality + -- This needs to be force : A → ((x : A) → B x) → B x rather than seq because of call-by-name. + , "primForce" |-> primForce + , "primForceLemma" |-> primForceLemma + , "primQNameEquality" |-> mkPrimFun2 ((==) :: Rel QName) + , "primQNameLess" |-> mkPrimFun2 ((<) :: Rel QName) + , "primShowQName" |-> mkPrimFun1 (Str . prettyShow :: QName -> Str) + , "primQNameFixity" |-> mkPrimFun1 (nameFixity . qnameName) + , "primQNameToWord64s" |-> mkPrimFun1 ((\ (NameId x y) -> (x, y)) . nameId . qnameName + :: QName -> (Word64, Word64)) + , "primQNameToWord64sInjective" |-> primQNameToWord64sInjective + , "primMetaEquality" |-> mkPrimFun2 ((==) :: Rel MetaId) + , "primMetaLess" |-> mkPrimFun2 ((<) :: Rel MetaId) + , "primShowMeta" |-> mkPrimFun1 (Str . prettyShow :: MetaId -> Str) + , "primMetaToNat" |-> mkPrimFun1 (fromIntegral . metaId :: MetaId -> Nat) + , "primMetaToNatInjective" |-> primMetaToNatInjective + , "primIMin" |-> primIMin' + , "primIMax" |-> primIMax' + , "primINeg" |-> primINeg' + , "primPOr" |-> primPOr + , "primComp" |-> primComp + , builtinTrans |-> primTrans' + , builtinHComp |-> primHComp' + , "primIdJ" |-> primIdJ + , "primPartial" |-> primPartial' + , "primPartialP" |-> primPartialP' + , builtinGlue |-> primGlue' + , builtin_glue |-> prim_glue' + , builtin_unglue |-> prim_unglue' + , builtinFaceForall |-> primFaceForall' + , "primDepIMin" |-> primDepIMin' + , "primIdFace" |-> primIdFace' + , "primIdPath" |-> primIdPath' + , builtinIdElim |-> primIdElim' + , builtinSubOut |-> primSubOut' + , builtin_glueU |-> prim_glueU' + , builtin_unglueU |-> prim_unglueU' + ] + where + (|->) = (,) diff --git a/src/full/Agda/TypeChecking/Primitive.hs-boot b/src/full/Agda/TypeChecking/Primitive.hs-boot new file mode 100644 --- /dev/null +++ b/src/full/Agda/TypeChecking/Primitive.hs-boot @@ -0,0 +1,6 @@ +module Agda.TypeChecking.Primitive where + +import Data.Map (Map) +import Agda.TypeChecking.Monad.Base + +primitiveFunctions :: Map String (TCM PrimitiveImpl) diff --git a/src/full/Agda/TypeChecking/Primitive/Base.hs b/src/full/Agda/TypeChecking/Primitive/Base.hs new file mode 100644 --- /dev/null +++ b/src/full/Agda/TypeChecking/Primitive/Base.hs @@ -0,0 +1,211 @@ +module Agda.TypeChecking.Primitive.Base where + +import Control.Monad.Fail (MonadFail) +import qualified Data.Map as Map + +import Agda.Syntax.Common +import Agda.Syntax.Internal + +import Agda.TypeChecking.Monad.Base +import Agda.TypeChecking.Monad.Builtin +import Agda.TypeChecking.Monad.Context +import Agda.TypeChecking.Monad.Debug +import Agda.TypeChecking.Names +import {-# SOURCE #-} Agda.TypeChecking.Primitive +import Agda.TypeChecking.Reduce ( reduce ) +import Agda.TypeChecking.Monad.Signature +import Agda.TypeChecking.Substitute + +import Agda.Utils.Functor +import Agda.Utils.Impossible +import Agda.Utils.Maybe +import Agda.Utils.Pretty ( prettyShow ) + +-- Type combinators + +infixr 4 --> +infixr 4 .--> +infixr 4 ..--> + +(-->), (.-->), (..-->) :: Monad tcm => tcm Type -> tcm Type -> tcm Type +a --> b = garr id a b +a .--> b = garr (const $ Irrelevant) a b +a ..--> b = garr (const $ NonStrict) a b + +garr :: Monad m => (Relevance -> Relevance) -> m Type -> m Type -> m Type +garr f a b = do + a' <- a + b' <- b + return $ El (funSort (getSort a') (getSort b')) $ + Pi (mapRelevance f $ defaultDom a') (NoAbs "_" b') + +gpi :: (MonadAddContext m, MonadDebug m) + => ArgInfo -> String -> m Type -> m Type -> m Type +gpi info name a b = do + a <- a + let dom :: Dom Type + dom = defaultNamedArgDom info name a + b <- addContext (name, dom) b + let y = stringToArgName name + return $ El (piSort dom (Abs y (getSort b))) + (Pi dom (Abs y b)) + +hPi, nPi :: (MonadAddContext m, MonadDebug m) + => String -> m Type -> m Type -> m Type +hPi = gpi $ setHiding Hidden defaultArgInfo +nPi = gpi defaultArgInfo + +hPi', nPi' :: (MonadFail m, MonadAddContext m, MonadDebug m) + => String -> NamesT m Type -> (NamesT m Term -> NamesT m Type) -> NamesT m Type +hPi' s a b = hPi s a (bind' s b) +nPi' s a b = nPi s a (bind' s b) + +pPi' :: (MonadAddContext m, HasBuiltins m, MonadDebug m) + => String -> NamesT m Term -> (NamesT m Term -> NamesT m Type) -> NamesT m Type +pPi' n phi b = toFinitePi <$> nPi' n (elInf $ cl isOne <@> phi) b + where + toFinitePi :: Type -> Type + toFinitePi (El s (Pi d b)) = El s $ Pi (setRelevance Irrelevant $ d { domFinite = True }) b + toFinitePi _ = __IMPOSSIBLE__ + + isOne = fromMaybe __IMPOSSIBLE__ <$> getBuiltin' builtinIsOne + +el' :: Monad m => m Term -> m Term -> m Type +el' l a = El <$> (tmSort <$> l) <*> a + +elInf :: Functor m => m Term -> m Type +elInf t = (El Inf <$> t) + +nolam :: Term -> Term +nolam = Lam defaultArgInfo . NoAbs "_" + +varM :: Monad tcm => Int -> tcm Term +varM = return . var + +infixl 9 <@>, <#> + +gApply :: Monad tcm => Hiding -> tcm Term -> tcm Term -> tcm Term +gApply h a b = gApply' (setHiding h defaultArgInfo) a b + +gApply' :: Monad tcm => ArgInfo -> tcm Term -> tcm Term -> tcm Term +gApply' info a b = do + x <- a + y <- b + return $ x `apply` [Arg info y] + +(<@>),(<#>),(<..>) :: Monad tcm => tcm Term -> tcm Term -> tcm Term +(<@>) = gApply NotHidden +(<#>) = gApply Hidden +(<..>) = gApply' (setRelevance Irrelevant defaultArgInfo) + +(<@@>) :: Monad tcm => tcm Term -> (tcm Term,tcm Term,tcm Term) -> tcm Term +t <@@> (x,y,r) = do + t <- t + x <- x + y <- y + r <- r + return $ t `applyE` [IApply x y r] + +list :: TCM Term -> TCM Term +list t = primList <@> t + +io :: TCM Term -> TCM Term +io t = primIO <@> t + +path :: TCM Term -> TCM Term +path t = primPath <@> t + +el :: Functor tcm => tcm Term -> tcm Type +el t = El (mkType 0) <$> t + +tset :: Monad tcm => tcm Type +tset = return $ sort (mkType 0) + +sSizeUniv :: Sort +sSizeUniv = mkType 0 +-- Andreas, 2016-04-14 switching off SizeUniv, unfixing issue #1428 +-- sSizeUniv = SizeUniv + +tSizeUniv :: Monad tcm => tcm Type +tSizeUniv = tset +-- Andreas, 2016-04-14 switching off SizeUniv, unfixing issue #1428 +-- tSizeUniv = return $ El sSizeUniv $ Sort sSizeUniv +-- Andreas, 2015-03-16 Since equality checking for types +-- includes equality checking for sorts, we cannot put +-- SizeUniv in Setω. (SizeUniv : Setω) == (_0 : suc _0) +-- will first instantiate _0 := Setω, which is wrong. +-- tSizeUniv = return $ El Inf $ Sort SizeUniv + +-- | Abbreviation: @argN = 'Arg' 'defaultArgInfo'@. +argN :: e -> Arg e +argN = Arg defaultArgInfo + +domN :: e -> Dom e +domN = defaultDom + +-- | Abbreviation: @argH = 'hide' 'Arg' 'defaultArgInfo'@. +argH :: e -> Arg e +argH = Arg $ setHiding Hidden defaultArgInfo + +domH :: e -> Dom e +domH = setHiding Hidden . defaultDom + +--------------------------------------------------------------------------- +-- * Accessing the primitive functions +--------------------------------------------------------------------------- + +lookupPrimitiveFunction :: String -> TCM PrimitiveImpl +lookupPrimitiveFunction x = + fromMaybe (typeError $ NoSuchPrimitiveFunction x) + (Map.lookup x primitiveFunctions) + +lookupPrimitiveFunctionQ :: QName -> TCM (String, PrimitiveImpl) +lookupPrimitiveFunctionQ q = do + let s = case qnameName q of + Name _ x _ _ _ -> prettyShow x + PrimImpl t pf <- lookupPrimitiveFunction s + return (s, PrimImpl t $ pf { primFunName = q }) + +getBuiltinName :: String -> TCM (Maybe QName) +getBuiltinName b = do + caseMaybeM (getBuiltin' b) (return Nothing) (Just <.> getName) + where + getName v = do + v <- reduce v + case unSpine $ v of + Def x _ -> return x + Con x _ _ -> return $ conName x + Lam _ b -> getName $ unAbs b + _ -> __IMPOSSIBLE__ + +isBuiltin :: QName -> String -> TCM Bool +isBuiltin q b = (Just q ==) <$> getBuiltinName b + +------------------------------------------------------------------------ +-- * Builtin Sigma +------------------------------------------------------------------------ + +data SigmaKit = SigmaKit + { sigmaName :: QName + , sigmaCon :: ConHead + , sigmaFst :: QName + , sigmaSnd :: QName + } + deriving (Eq,Show) + +getSigmaKit :: (HasBuiltins m, HasConstInfo m) => m (Maybe SigmaKit) +getSigmaKit = do + ms <- getBuiltinName' builtinSigma + case ms of + Nothing -> return Nothing + Just sigma -> do + def <- theDef <$> getConstInfo sigma + case def of + Record { recFields = [fst,snd], recConHead = con } -> do + return . Just $ SigmaKit + { sigmaName = sigma + , sigmaCon = con + , sigmaFst = unDom fst + , sigmaSnd = unDom snd + } + _ -> __IMPOSSIBLE__ diff --git a/src/full/Agda/TypeChecking/Primitive/Cubical.hs b/src/full/Agda/TypeChecking/Primitive/Cubical.hs --- a/src/full/Agda/TypeChecking/Primitive/Cubical.hs +++ b/src/full/Agda/TypeChecking/Primitive/Cubical.hs @@ -1,124 +1,1772 @@ -{-# LANGUAGE CPP #-} -{-# LANGUAGE NondecreasingIndentation #-} - -module Agda.TypeChecking.Primitive.Cubical where -import Prelude hiding (null, (!!)) - -import Agda.Syntax.Common -import Agda.Syntax.Position -import Agda.Syntax.Literal -import Agda.Syntax.Internal - -import Control.Monad -import Control.Monad.Reader -import Control.Monad.Trans ( lift ) - -import Agda.TypeChecking.Names -import Agda.TypeChecking.Primitive hiding (Nat) -import Agda.TypeChecking.Monad -import Agda.TypeChecking.Monad.Builtin - - -import Agda.TypeChecking.Free -import Agda.TypeChecking.Substitute -import Agda.TypeChecking.Reduce -import Agda.TypeChecking.Telescope - -import Agda.Utils.Except - -#include "undefined.h" -import Agda.Utils.Impossible - - --- | Tries to @primTransp@ a whole telescope of arguments, following the rule for Σ types. --- If a type in the telescope does not support transp, @transpTel@ throws it as an exception. -transpTel :: Abs Telescope -- Γ ⊢ i.Δ - -> Term -- Γ ⊢ φ : F -- i.Δ const on φ - -> Args -- Γ ⊢ δ : Δ[0] - -> ExceptT (Closure (Abs Type)) TCM Args -- Γ ⊢ Δ[1] -transpTel delta phi args = do - tTransp <- liftTCM primTrans - imin <- liftTCM primIMin - imax <- liftTCM primIMax - ineg <- liftTCM primINeg - let - noTranspError t = lift . throwError =<< liftTCM (buildClosure t) - bapp :: (Applicative m, Subst t a) => m (Abs a) -> m t -> m a - bapp t u = lazyAbsApp <$> t <*> u - gTransp (Just l) t phi a = pure tTransp <#> l <@> (Lam defaultArgInfo . fmap unEl <$> t) <@> phi <@> a - gTransp Nothing t phi a = do - -- Γ ⊢ i.Ξ - xi <- (open =<<) $ do - bind "i" $ \ i -> do - TelV xi _ <- (liftTCM . telView =<<) $ t `bapp` i - return xi - argnames <- do - teleArgNames . unAbs <$> xi - glamN argnames $ \ xi_args -> do - b' <- bind "i" $ \ i -> do - ti <- t `bapp` i - xin <- bind "i" $ \ i -> xi `bapp` (pure ineg <@> i) - xi_args <- xi_args - ni <- pure ineg <@> i - phi <- phi - lift $ piApplyM ti =<< trFillTel xin phi xi_args ni - axi <- do - a <- a - xif <- bind "i" $ \ i -> xi `bapp` (pure ineg <@> i) - phi <- phi - xi_args <- xi_args - lift $ apply a <$> transpTel xif phi xi_args - s <- reduce $ getSort (absBody b') - case s of - Type l -> do - l <- open $ lam_i (Level l) - b' <- open b' - axi <- open axi - gTransp (Just l) b' phi axi - Inf -> - case 0 `freeIn` (raise 1 b' `lazyAbsApp` var 0) of - False -> return axi - True -> noTranspError b' - _ -> noTranspError b' - lam_i = Lam defaultArgInfo . Abs "i" - go :: Telescope -> Term -> Args -> ExceptT (Closure (Abs Type)) TCM Args - go EmptyTel _ [] = return [] - go (ExtendTel t delta) phi (a:args) = do - -- Γ,i ⊢ t - -- Γ,i ⊢ (x : t). delta - -- Γ ⊢ a : t[0] - s <- reduce $ getSort t - -- Γ ⊢ b : t[1], Γ,i ⊢ b : t[i] - (b,bf) <- runNamesT [] $ do - l <- case s of - Inf -> return Nothing - Type l -> Just <$> open (lam_i (Level l)) - _ -> noTranspError (Abs "i" (unDom t)) - t <- open $ Abs "i" (unDom t) - [phi,a] <- mapM open [phi, unArg a] - b <- gTransp l t phi a - bf <- bind "i" $ \ i -> do - gTransp ((<$> l) $ \ l -> lam "j" $ \ j -> l <@> (pure imin <@> i <@> j)) - (bind "j" $ \ j -> t `bapp` (pure imin <@> i <@> j)) - (pure imax <@> (pure ineg <@> i) <@> phi) - a - return (b, absBody bf) - (:) (b <$ a) <$> go (lazyAbsApp delta bf) phi args - go (ExtendTel t delta) phi [] = __IMPOSSIBLE__ - go EmptyTel _ (_:_) = __IMPOSSIBLE__ - go (absBody delta) phi args - --- | Like @transpTel@ but performing a transpFill. -trFillTel :: Abs Telescope -- Γ ⊢ i.Δ - -> Term - -> Args -- Γ ⊢ δ : Δ[0] - -> Term -- Γ ⊢ r : I - -> ExceptT (Closure (Abs Type)) TCM Args -- Γ ⊢ Δ[r] -trFillTel delta phi args r = do - imin <- liftTCM primIMin - imax <- liftTCM primIMax - ineg <- liftTCM primINeg - transpTel (Abs "j" $ raise 1 delta `lazyAbsApp` (imin `apply` (map argN [var 0, raise 1 r]))) - (imax `apply` [argN $ ineg `apply` [argN r], argN phi]) - args - +{-# LANGUAGE NondecreasingIndentation #-} + +module Agda.TypeChecking.Primitive.Cubical where + +import Prelude hiding (null, (!!)) + +import Control.Monad +import Control.Monad.Trans ( lift ) + +import Data.Either ( partitionEithers ) +import Data.Map (Map) +import qualified Data.Map as Map +import Data.Set (Set) +import qualified Data.Set as Set +import Data.Foldable hiding (null) + +import Agda.Interaction.Options ( optCubical ) + +import Agda.Syntax.Common +import Agda.Syntax.Internal + +import Agda.TypeChecking.Names +import Agda.TypeChecking.Primitive.Base +import Agda.TypeChecking.Monad +import Agda.TypeChecking.Monad.Builtin + +import Agda.TypeChecking.Free +import Agda.TypeChecking.Substitute +import Agda.TypeChecking.Reduce +import Agda.TypeChecking.Telescope + +import Agda.Utils.Except +import Agda.Utils.Functor +import Agda.Utils.Impossible +import Agda.Utils.Maybe +import Agda.Utils.Monad +import Agda.Utils.Null +import Agda.Utils.Tuple + +requireCubical :: TCM () +requireCubical = do + cubical <- optCubical <$> pragmaOptions + unless cubical $ + typeError $ GenericError "Missing option --cubical" + +primINeg' :: TCM PrimitiveImpl +primINeg' = do + requireCubical + t <- elInf primInterval --> elInf primInterval + return $ PrimImpl t $ primFun __IMPOSSIBLE__ 1 $ \ ts -> do + case ts of + [x] -> do + unview <- intervalUnview' + view <- intervalView' + sx <- reduceB' x + ix <- intervalView (unArg $ ignoreBlocking sx) + let + ineg :: Arg Term -> Arg Term + ineg = fmap (unview . f . view) + f ix = case ix of + IZero -> IOne + IOne -> IZero + IMin x y -> IMax (ineg x) (ineg y) + IMax x y -> IMin (ineg x) (ineg y) + INeg x -> OTerm (unArg x) + OTerm t -> INeg (Arg defaultArgInfo t) + case ix of + OTerm t -> return $ NoReduction [reduced sx] + _ -> redReturn (unview $ f ix) + _ -> __IMPOSSIBLE__ + +primDepIMin' :: TCM PrimitiveImpl +primDepIMin' = do + requireCubical + t <- runNamesT [] $ + nPi' "φ" (elInf $ cl primInterval) $ \ φ -> + (pPi' "o" φ $ \ o -> elInf $ cl primInterval) --> elInf (cl primInterval) + return $ PrimImpl t $ primFun __IMPOSSIBLE__ 2 $ \ ts -> do + case ts of + [x,y] -> do + sx <- reduceB' x + ix <- intervalView (unArg $ ignoreBlocking sx) + itisone <- getTerm "primDepIMin" builtinItIsOne + case ix of + IZero -> redReturn =<< intervalUnview IZero + IOne -> redReturn =<< (pure (unArg y) <@> pure itisone) + _ -> do + sy <- reduceB' y + iy <- intervalView =<< reduce' =<< (pure (unArg $ ignoreBlocking sy) <@> pure itisone) + case iy of + IZero -> redReturn =<< intervalUnview IZero + IOne -> redReturn (unArg $ ignoreBlocking sx) + _ -> return $ NoReduction [reduced sx, reduced sy] + _ -> __IMPOSSIBLE__ + +primIBin :: IntervalView -> IntervalView -> TCM PrimitiveImpl +primIBin unit absorber = do + requireCubical + t <- elInf primInterval --> elInf primInterval --> elInf primInterval + return $ PrimImpl t $ primFun __IMPOSSIBLE__ 2 $ \ ts -> do + case ts of + [x,y] -> do + sx <- reduceB' x + ix <- intervalView (unArg $ ignoreBlocking sx) + case ix of + ix | ix ==% absorber -> redReturn =<< intervalUnview absorber + ix | ix ==% unit -> return $ YesReduction YesSimplification (unArg y) + _ -> do + sy <- reduceB' y + iy <- intervalView (unArg $ ignoreBlocking sy) + case iy of + iy | iy ==% absorber -> redReturn =<< intervalUnview absorber + iy | iy ==% unit -> return $ YesReduction YesSimplification (unArg x) + _ -> return $ NoReduction [reduced sx,reduced sy] + _ -> __IMPOSSIBLE__ + where + (==%) IZero IZero = True + (==%) IOne IOne = True + (==%) _ _ = False + + +primIMin' :: TCM PrimitiveImpl +primIMin' = do + requireCubical + primIBin IOne IZero + +primIMax' :: TCM PrimitiveImpl +primIMax' = do + requireCubical + primIBin IZero IOne + +imax :: HasBuiltins m => m Term -> m Term -> m Term +imax x y = do + x' <- x + y' <- y + intervalUnview (IMax (argN x') (argN y')) + +imin :: HasBuiltins m => m Term -> m Term -> m Term +imin x y = do + x' <- x + y' <- y + intervalUnview (IMin (argN x') (argN y')) + +-- ∀ {a}{c}{A : Set a}{x : A}(C : ∀ y → Id x y → Set c) → C x (conid i1 (\ i → x)) → ∀ {y} (p : Id x y) → C y p +primIdJ :: TCM PrimitiveImpl +primIdJ = do + requireCubical + t <- runNamesT [] $ + hPi' "a" (el $ cl primLevel) $ \ a -> + hPi' "c" (el $ cl primLevel) $ \ c -> + hPi' "A" (sort . tmSort <$> a) $ \ bA -> + hPi' "x" (el' a bA) $ \ x -> + nPi' "C" (nPi' "y" (el' a bA) $ \ y -> + (el' a $ cl primId <#> a <#> bA <@> x <@> y) --> (sort . tmSort <$> c)) $ \ bC -> + (el' c $ bC <@> x <@> + (cl primConId <#> a <#> bA <#> x <#> x <@> cl primIOne + <@> lam "i" (\ _ -> x))) --> + (hPi' "y" (el' a bA) $ \ y -> + nPi' "p" (el' a $ cl primId <#> a <#> bA <@> x <@> y) $ \ p -> + el' c $ bC <@> y <@> p) + conidn <- getBuiltinName builtinConId + conid <- primConId + -- TODO make a kit + return $ PrimImpl t $ primFun __IMPOSSIBLE__ 8 $ \ ts -> do + unview <- intervalUnview' + let imax x y = do x' <- x; y' <- y; pure $ unview (IMax (argN x') (argN y')) + imin x y = do x' <- x; y' <- y; pure $ unview (IMin (argN x') (argN y')) + ineg x = unview . INeg . argN <$> x + mcomp <- getTerm' "primComp" + case ts of + [la,lc,a,x,c,d,y,eq] -> do + seq <- reduceB' eq + case unArg $ ignoreBlocking $ seq of + (Def q [Apply la,Apply a,Apply x,Apply y,Apply phi,Apply p]) + | Just q == conidn, Just comp <- mcomp -> do + redReturn $ runNames [] $ do + [lc,c,d,la,a,x,y,phi,p] <- mapM (open . unArg) [lc,c,d,la,a,x,y,phi,p] + let w i = do + [x,y,p,i] <- sequence [x,y,p,i] + pure $ p `applyE` [IApply x y i] + pure comp <#> (lam "i" $ \ _ -> lc) + <@> (lam "i" $ \ i -> + c <@> (w i) + <@> (pure conid <#> la <#> a <#> x <#> (w i) + <@> (phi `imax` ineg i) + <@> (lam "j" $ \ j -> w $ imin i j))) + <#> phi + <@> (lam "i" $ \ _ -> nolam <$> d) -- TODO block + <@> d + _ -> return $ NoReduction $ map notReduced [la,lc,a,x,c,d,y] ++ [reduced seq] + _ -> __IMPOSSIBLE__ + +primIdElim' :: TCM PrimitiveImpl +primIdElim' = do + requireCubical + t <- runNamesT [] $ + hPi' "a" (el $ cl primLevel) $ \ a -> + hPi' "c" (el $ cl primLevel) $ \ c -> + hPi' "A" (sort . tmSort <$> a) $ \ bA -> + hPi' "x" (el' a bA) $ \ x -> + nPi' "C" (nPi' "y" (el' a bA) $ \ y -> + (el' a $ cl primId <#> a <#> bA <@> x <@> y) --> (sort . tmSort <$> c)) $ \ bC -> + (nPi' "φ" (elInf $ cl primInterval) $ \ phi -> + nPi' "y" (elInf $ cl primSub <#> a <@> bA <@> phi <@> (lam "o" $ const x)) $ \ y -> + let pathxy = (cl primPath <#> a <@> bA <@> x <@> oucy) + oucy = (cl primSubOut <#> a <#> bA <#> phi <#> (lam "o" $ const x) <@> y) + reflx = (lam "o" $ \ _ -> lam "i" $ \ _ -> x) -- TODO Andrea, should block on o + in + nPi' "w" (elInf $ cl primSub <#> a <@> pathxy <@> phi <@> reflx) $ \ w -> + let oucw = (cl primSubOut <#> a <#> pathxy <#> phi <#> reflx <@> w) in + el' c $ bC <@> oucy <@> (cl primConId <#> a <#> bA <#> x <#> oucy <@> phi <@> oucw)) + --> + (hPi' "y" (el' a bA) $ \ y -> + nPi' "p" (el' a $ cl primId <#> a <#> bA <@> x <@> y) $ \ p -> + el' c $ bC <@> y <@> p) + conid <- primConId + sin <- primSubIn + path <- primPath + return $ PrimImpl t $ primFun __IMPOSSIBLE__ 8 $ \ ts -> do + case ts of + [a,c,bA,x,bC,f,y,p] -> do + sp <- reduceB' p + case unArg $ ignoreBlocking sp of + Def q [Apply _a, Apply _bA, Apply _x, Apply _y, Apply phi , Apply w] -> do + y' <- return $ sin `apply` [a,bA ,phi,argN $ unArg y] + w' <- return $ sin `apply` [a,argN $ path `apply` [a,bA,x,y],phi,argN $ unArg w] + redReturn $ unArg f `apply` [phi, defaultArg y', defaultArg w'] + _ -> return $ NoReduction $ map notReduced [a,c,bA,x,bC,f,y] ++ [reduced sp] + _ -> __IMPOSSIBLE__ + + +primPOr :: TCM PrimitiveImpl +primPOr = do + requireCubical + t <- runNamesT [] $ + hPi' "a" (el $ cl primLevel) $ \ a -> + nPi' "i" (elInf $ cl primInterval) $ \ i -> + nPi' "j" (elInf $ cl primInterval) $ \ j -> + hPi' "A" (pPi' "o" (imax i j) $ \o -> el' (cl primLevelSuc <@> a) (Sort . tmSort <$> a)) $ \ bA -> + ((pPi' "i1" i $ \ i1 -> el' a $ bA <..> (cl primIsOne1 <@> i <@> j <@> i1))) --> + ((pPi' "j1" j $ \ j1 -> el' a $ bA <..> (cl primIsOne2 <@> i <@> j <@> j1))) --> + (pPi' "o" (imax i j) $ \ o -> el' a $ bA <..> o) + return $ PrimImpl t $ primFun __IMPOSSIBLE__ 6 $ \ ts -> do + case ts of + [l,i,j,a,u,v] -> do + si <- reduceB' i + vi <- intervalView $ unArg $ ignoreBlocking si + case vi of + IOne -> redReturn (unArg u) + IZero -> redReturn (unArg v) + _ -> do + sj <- reduceB' j + vj <- intervalView $ unArg $ ignoreBlocking sj + case vj of + IOne -> redReturn (unArg v) + IZero -> redReturn (unArg u) + _ -> return $ NoReduction [notReduced l,reduced si,reduced sj,notReduced a,notReduced u,notReduced v] + + + _ -> __IMPOSSIBLE__ + +primPartial' :: TCM PrimitiveImpl +primPartial' = do + requireCubical + t <- runNamesT [] $ + (hPi' "a" (el $ cl primLevel) $ \ a -> + nPi' "φ" (elInf (cl primInterval)) $ \ _ -> + nPi' "A" (sort . tmSort <$> a) $ \ bA -> + return (sort $ Inf)) + isOne <- primIsOne + return $ PrimImpl t $ primFun __IMPOSSIBLE__ 3 $ \ ts -> do + case ts of + [l,phi,a] -> do + (El s (Pi d b)) <- runNamesT [] $ do + [l,a,phi] <- mapM (open . unArg) [l,a,phi] + (elInf $ pure isOne <@> phi) --> el' l a + redReturn $ Pi (setRelevance Irrelevant $ d { domFinite = True }) b + _ -> __IMPOSSIBLE__ + +primPartialP' :: TCM PrimitiveImpl +primPartialP' = do + requireCubical + t <- runNamesT [] $ + (hPi' "a" (el $ cl primLevel) $ \ a -> + nPi' "φ" (elInf (cl primInterval)) $ \ phi -> + nPi' "A" (pPi' "o" phi $ \ _ -> el' (cl primLevelSuc <@> a) (Sort . tmSort <$> a)) $ \ bA -> + return (sort $ Inf)) + let toFinitePi :: Type -> Term + toFinitePi (El _ (Pi d b)) = Pi (setRelevance Irrelevant $ d { domFinite = True }) b + toFinitePi _ = __IMPOSSIBLE__ + v <- runNamesT [] $ + lam "a" $ \ l -> + lam "φ" $ \ phi -> + lam "A" $ \ a -> + toFinitePi <$> nPi' "p" (elInf $ cl primIsOne <@> phi) (\ p -> el' l (a <@> p)) + return $ PrimImpl t $ primFun __IMPOSSIBLE__ 0 $ \ _ -> redReturn v + +primSubOut' :: TCM PrimitiveImpl +primSubOut' = do + requireCubical + t <- runNamesT [] $ + hPi' "a" (el $ cl primLevel) $ \ a -> + hPi' "A" (el' (cl primLevelSuc <@> a) (Sort . tmSort <$> a)) $ \ bA -> + hPi' "φ" (elInf $ cl primInterval) $ \ phi -> + hPi' "u" (elInf $ cl primPartial <#> a <@> phi <@> bA) $ \ u -> + elInf (cl primSub <#> a <@> bA <@> phi <@> u) --> el' (Sort . tmSort <$> a) bA + return $ PrimImpl t $ primFun __IMPOSSIBLE__ 5 $ \ ts -> do + case ts of + [a,bA,phi,u,x] -> do + view <- intervalView' + sphi <- reduceB' phi + case view $ unArg $ ignoreBlocking sphi of + IOne -> redReturn =<< (return (unArg u) <..> (getTerm builtinSubOut builtinItIsOne)) + _ -> do + sx <- reduceB' x + mSubIn <- getBuiltinName' builtinSubIn + case unArg $ ignoreBlocking $ sx of + Def q [_,_,_, Apply t] | Just q == mSubIn -> redReturn (unArg t) + _ -> return $ NoReduction $ map notReduced [a,bA] ++ [reduced sphi, notReduced u, reduced sx] + _ -> __IMPOSSIBLE__ + +primIdFace' :: TCM PrimitiveImpl +primIdFace' = do + requireCubical + t <- runNamesT [] $ + hPi' "a" (el $ cl primLevel) $ \ a -> + hPi' "A" (sort . tmSort <$> a) $ \ bA -> + hPi' "x" (el' a bA) $ \ x -> + hPi' "y" (el' a bA) $ \ y -> + (el' a $ cl primId <#> a <#> bA <@> x <@> y) + --> elInf (cl primInterval) + return $ PrimImpl t $ primFun __IMPOSSIBLE__ 5 $ \ ts -> do + case ts of + [l,bA,x,y,t] -> do + st <- reduceB' t + mConId <- getName' builtinConId + case unArg (ignoreBlocking st) of + Def q [_,_,_,_, Apply phi,_] | Just q == mConId -> redReturn (unArg phi) + _ -> return $ NoReduction $ map notReduced [l,bA,x,y] ++ [reduced st] + _ -> __IMPOSSIBLE__ + +primIdPath' :: TCM PrimitiveImpl +primIdPath' = do + requireCubical + t <- runNamesT [] $ + hPi' "a" (el $ cl primLevel) $ \ a -> + hPi' "A" (sort . tmSort <$> a) $ \ bA -> + hPi' "x" (el' a bA) $ \ x -> + hPi' "y" (el' a bA) $ \ y -> + (el' a $ cl primId <#> a <#> bA <@> x <@> y) + --> (el' a $ cl primPath <#> a <#> bA <@> x <@> y) + return $ PrimImpl t $ primFun __IMPOSSIBLE__ 5 $ \ ts -> do + case ts of + [l,bA,x,y,t] -> do + st <- reduceB' t + mConId <- getName' builtinConId + case unArg (ignoreBlocking st) of + Def q [_,_,_,_,_,Apply w] | Just q == mConId -> redReturn (unArg w) + _ -> return $ NoReduction $ map notReduced [l,bA,x,y] ++ [reduced st] + _ -> __IMPOSSIBLE__ + + +primTrans' :: TCM PrimitiveImpl +primTrans' = do + requireCubical + t <- runNamesT [] $ + hPi' "a" (elInf (cl primInterval) --> (el $ cl primLevel)) $ \ a -> + nPi' "A" (nPi' "i" (elInf (cl primInterval)) $ \ i -> (sort . tmSort <$> (a <@> i))) $ \ bA -> + nPi' "φ" (elInf $ cl primInterval) $ \ phi -> + (el' (a <@> cl primIZero) (bA <@> cl primIZero) --> el' (a <@> cl primIOne) (bA <@> cl primIOne)) + return $ PrimImpl t $ PrimFun __IMPOSSIBLE__ 4 $ \ ts nelims -> do + primTransHComp DoTransp ts nelims + +primHComp' :: TCM PrimitiveImpl +primHComp' = do + requireCubical + t <- runNamesT [] $ + hPi' "a" (el $ cl primLevel) $ \ a -> + hPi' "A" (sort . tmSort <$> a) $ \ bA -> + hPi' "φ" (elInf $ cl primInterval) $ \ phi -> + (nPi' "i" (elInf $ cl primInterval) $ \ i -> pPi' "o" phi $ \ _ -> el' a bA) --> + (el' a bA --> el' a bA) + return $ PrimImpl t $ PrimFun __IMPOSSIBLE__ 5 $ \ ts nelims -> do + primTransHComp DoHComp ts nelims + +data TranspOrHComp = DoTransp | DoHComp deriving (Eq,Show) + +cmdToName :: TranspOrHComp -> String +cmdToName DoTransp = builtinTrans +cmdToName DoHComp = builtinHComp + +data FamilyOrNot a + = IsFam { famThing :: a } + | IsNot { famThing :: a } + deriving (Eq,Show,Functor,Foldable,Traversable) + +instance Reduce a => Reduce (FamilyOrNot a) where + reduceB' x = traverse id <$> traverse reduceB' x + reduce' x = traverse reduce' x + + +-- | Define a "ghcomp" version of gcomp. Normal comp looks like: +-- +-- comp^i A [ phi -> u ] u0 = hcomp^i A(1/i) [ phi -> forward A i u ] (forward A 0 u0) +-- +-- So for "gcomp" we compute: +-- +-- gcomp^i A [ phi -> u ] u0 = hcomp^i A(1/i) [ phi -> forward A i u, ~ phi -> forward A 0 u0 ] (forward A 0 u0) +-- +-- The point of this is that gcomp does not produce any empty +-- systems (if phi = 0 it will reduce to "forward A 0 u". +mkGComp :: HasBuiltins m => String -> NamesT m (NamesT m Term -> NamesT m Term -> NamesT m Term -> NamesT m Term -> NamesT m Term -> NamesT m Term) +mkGComp s = do + let getTermLocal = getTerm s + tPOr <- getTermLocal "primPOr" + tIMax <- getTermLocal builtinIMax + tIMin <- getTermLocal builtinIMin + tINeg <- getTermLocal builtinINeg + tHComp <- getTermLocal builtinHComp + tTrans <- getTermLocal builtinTrans + io <- getTermLocal builtinIOne + iz <- getTermLocal builtinIZero + let ineg j = pure tINeg <@> j + imax i j = pure tIMax <@> i <@> j + imin i j = pure tIMin <@> i <@> j + let forward la bA r u = pure tTrans <#> (lam "i" $ \ i -> la <@> (i `imax` r)) + <@> (lam "i" $ \ i -> bA <@> (i `imax` r)) + <@> r + <@> u + return $ \ la bA phi u u0 -> + pure tHComp <#> (la <@> pure io) + <#> (bA <@> pure io) + <#> imax phi (ineg phi) + <@> (lam "i" $ \ i -> + pure tPOr <#> (la <@> i) + <@> phi + <@> ineg phi + <@> (ilam "o" $ \ a -> bA <@> i) + <@> (ilam "o" $ \ o -> forward la bA i (u <@> i <..> o)) + <@> (ilam "o" $ \ o -> forward la bA (pure iz) u0)) + <@> forward la bA (pure iz) u0 + + +unglueTranspGlue :: (HasConstInfo m, MonadReduce m, HasBuiltins m) => + Arg Term + -> Arg Term + -> FamilyOrNot + (Arg Term, Arg Term, Arg Term, Arg Term, Arg Term, Arg Term) + -> m Term +unglueTranspGlue psi u0 (IsFam (la, lb, bA, phi, bT, e)) = do + let + localUse = builtinTrans ++ " for " ++ builtinGlue + getTermLocal = getTerm localUse + tPOr <- getTermLocal "primPOr" + tIMax <- getTermLocal builtinIMax + tIMin <- getTermLocal builtinIMin + tINeg <- getTermLocal builtinINeg + tHComp <- getTermLocal builtinHComp + tTrans <- getTermLocal builtinTrans + tForall <- getTermLocal builtinFaceForall + tEFun <- getTermLocal builtinEquivFun + tEProof <- getTermLocal builtinEquivProof + tglue <- getTermLocal builtin_glue + tunglue <- getTermLocal builtin_unglue + io <- getTermLocal builtinIOne + iz <- getTermLocal builtinIZero + tLMax <- getTermLocal builtinLevelMax + tPath <- getTermLocal builtinPath + tTransp <- getTermLocal builtinTranspProof + tItIsOne <- getTermLocal builtinItIsOne + kit <- fromMaybe __IMPOSSIBLE__ <$> getSigmaKit + runNamesT [] $ do + let ineg j = pure tINeg <@> j + imax i j = pure tIMax <@> i <@> j + imin i j = pure tIMin <@> i <@> j + + gcomp <- mkGComp localUse + + let transpFill la bA phi u0 i = + pure tTrans <#> (ilam "j" $ \ j -> la <@> imin i j) + <@> (ilam "j" $ \ j -> bA <@> imin i j) + <@> (imax phi (ineg i)) + <@> u0 + [psi,u0] <- mapM (open . unArg) [psi,u0] + glue1 <- do + g <- open $ (tglue `apply`) . map (setHiding Hidden) . map (subst 0 io) $ [la, lb, bA, phi, bT, e] + return $ \ t a -> g <@> t <@> a + unglue0 <- do + ug <- open $ (tunglue `apply`) . map (setHiding Hidden) . map (subst 0 iz) $ [la, lb, bA, phi, bT, e] + return $ \ a -> ug <@> a + [la, lb, bA, phi, bT, e] <- mapM (\ a -> open . runNames [] $ (lam "i" $ const (pure $ unArg a))) [la, lb, bA, phi, bT, e] + view <- intervalView' + + -- phi1 <- view <$> (reduce =<< (phi <@> pure io)) + -- if not $ (isIOne phi1) then return Nothing else Just <$> do + let + tf i o = transpFill lb (lam "i" $ \ i -> bT <@> i <..> o) psi u0 i + t1 o = tf (pure io) o + a0 = unglue0 u0 + + -- compute "forall. phi" + forallphi = pure tForall <@> phi + + -- a1 with gcomp + a1 = gcomp la bA + (imax psi forallphi) + (lam "i" $ \ i -> pure tPOr <#> (la <@> i) + <@> psi + <@> forallphi + <@> (ilam "o" $ \ a -> bA <@> i) + <@> (ilam "o" $ \ _ -> a0) + <@> (ilam "o" $ \ o -> pure tEFun <#> (lb <@> i) + <#> (la <@> i) + <#> (bT <@> i <..> o) + <#> (bA <@> i) + <@> (e <@> i <..> o) + <@> (tf i o))) + a0 + + max l l' = pure tLMax <@> l <@> l' + sigCon x y = pure (Con (sigmaCon kit) ConOSystem []) <@> x <@> y + w i o = pure tEFun <#> (lb <@> i) + <#> (la <@> i) + <#> (bT <@> i <..> o) + <#> (bA <@> i) + <@> (e <@> i <..> o) + fiber la lb bA bB f b = + (pure (Def (sigmaName kit) []) <#> la + <#> lb + <@> bA + <@> (lam "a" $ \ a -> pure tPath <#> lb <#> bB <@> (f <@> a) <@> b)) + + -- We don't have to do anything special for "~ forall. phi" + -- here (to implement "ghcomp") as it is taken care off by + -- tEProof in t1'alpha below + pe o = -- o : [ φ 1 ] + pure tPOr <#> max (la <@> pure io) (lb <@> pure io) + <@> psi + <@> forallphi + <@> (ilam "o" $ \ _ -> + fiber (lb <@> pure io) (la <@> pure io) + (bT <@> (pure io) <..> o) (bA <@> pure io) + (w (pure io) o) a1) + <@> (ilam "o" $ \ o -> sigCon u0 (lam "_" $ \ _ -> a1)) + <@> (ilam "o" $ \ o -> sigCon (t1 o) (lam "_" $ \ _ -> a1)) + + -- "ghcomp" is implemented in the proof of tEProof + -- (see src/data/lib/prim/Agda/Builtin/Cubical/Glue.agda) + t1'alpha o = -- o : [ φ 1 ] + pure tEProof <#> (lb <@> pure io) + <#> (la <@> pure io) + <@> (bT <@> pure io <..> o) + <@> (bA <@> pure io) + <@> (e <@> pure io <..> o) + <@> a1 + <@> (imax psi forallphi) + <@> pe o + + -- TODO: optimize? + t1' o = t1'alpha o <&> (`applyE` [Proj ProjSystem (sigmaFst kit)]) + alpha o = t1'alpha o <&> (`applyE` [Proj ProjSystem (sigmaSnd kit)]) + a1' = pure tHComp + <#> (la <@> pure io) + <#> (bA <@> pure io) + <#> (imax (phi <@> pure io) psi) + <@> (lam "j" $ \ j -> + pure tPOr <#> (la <@> pure io) <@> (phi <@> pure io) <@> psi <@> (ilam "o" $ \ _ -> bA <@> pure io) + <@> (ilam "o" $ \ o -> alpha o <@@> (w (pure io) o <@> t1' o,a1,j)) + <@> (ilam "o" $ \ _ -> a1) + ) + <@> a1 + -- glue1 (ilam "o" t1') a1' + a1' +unglueTranspGlue _ _ _ = __IMPOSSIBLE__ + +data TermPosition = Head | Eliminated deriving (Eq,Show) + +headStop :: (HasBuiltins m, MonadReduce m) => + TermPosition -> m Term -> m Bool +headStop tpos phi + | Head <- tpos = do + phi <- intervalView =<< (reduce =<< phi) + return $ not $ isIOne phi + | otherwise = return False + +compGlue :: (MonadReduce m, HasConstInfo m, HasBuiltins m) => + TranspOrHComp + -> Arg Term + -> Maybe (Arg Term) + -> Arg Term + -> FamilyOrNot + (Arg Term, Arg Term, Arg Term, Arg Term, Arg Term, Arg Term) + -> TermPosition + -> m (Maybe Term) +compGlue DoHComp psi (Just u) u0 (IsNot (la, lb, bA, phi, bT, e)) tpos = do + let getTermLocal = getTerm $ (builtinHComp ++ " for " ++ builtinGlue) + tPOr <- getTermLocal "primPOr" + tIMax <- getTermLocal builtinIMax + tIMin <- getTermLocal builtinIMin + tINeg <- getTermLocal builtinINeg + tHComp <- getTermLocal builtinHComp + tEFun <- getTermLocal builtinEquivFun + tglue <- getTermLocal builtin_glue + tunglue <- getTermLocal builtin_unglue + io <- getTermLocal builtinIOne + tItIsOne <- getTermLocal builtinItIsOne + view <- intervalView' + runNamesT [] $ do + [psi, u, u0] <- mapM (open . unArg) [psi, u, u0] + [la, lb, bA, phi, bT, e] <- mapM (open . unArg) [la, lb, bA, phi, bT, e] + ifM (headStop tpos phi) (return Nothing) $ Just <$> do + + let + hfill la bA phi u u0 i = pure tHComp <#> la + <#> bA + <#> (pure tIMax <@> phi <@> (pure tINeg <@> i)) + <@> (lam "j" $ \ j -> pure tPOr <#> la <@> phi <@> (pure tINeg <@> i) <@> (ilam "o" $ \ a -> bA) + <@> (ilam "o" $ \ o -> u <@> (pure tIMin <@> i <@> j) <..> o) + <@> (ilam "o" $ \ _ -> u0) + ) + <@> u0 + tf i o = hfill lb (bT <..> o) psi u u0 i + unglue g = pure tunglue <#> la <#> lb <#> bA <#> phi <#> bT <#> e <@> g + a1 = pure tHComp <#> la <#> bA <#> (pure tIMax <@> psi <@> phi) + <@> (lam "i" $ \ i -> pure tPOr <#> la <@> psi <@> phi <@> (ilam "_" $ \ _ -> bA) + <@> (ilam "o" $ \ o -> unglue (u <@> i <..> o)) + <@> (ilam "o" $ \ o -> pure tEFun <#> lb <#> la <#> (bT <..> o) <#> bA <@> (e <..> o) <@> tf i o) + ) + <@> (unglue u0) + t1 = tf (pure io) + -- pure tglue <#> la <#> lb <#> bA <#> phi <#> bT <#> e <@> (ilam "o" $ \ o -> t1 o) <@> a1 + case tpos of + Head -> t1 (pure tItIsOne) + Eliminated -> a1 +compGlue DoTransp psi Nothing u0 (IsFam (la, lb, bA, phi, bT, e)) tpos = do + let + localUse = builtinTrans ++ " for " ++ builtinGlue + getTermLocal = getTerm localUse + tPOr <- getTermLocal "primPOr" + tIMax <- getTermLocal builtinIMax + tIMin <- getTermLocal builtinIMin + tINeg <- getTermLocal builtinINeg + tHComp <- getTermLocal builtinHComp + tTrans <- getTermLocal builtinTrans + tForall <- getTermLocal builtinFaceForall + tEFun <- getTermLocal builtinEquivFun + tEProof <- getTermLocal builtinEquivProof + tglue <- getTermLocal builtin_glue + tunglue <- getTermLocal builtin_unglue + io <- getTermLocal builtinIOne + iz <- getTermLocal builtinIZero + tLMax <- getTermLocal builtinLevelMax + tPath <- getTermLocal builtinPath + tTransp <- getTermLocal builtinTranspProof + tItIsOne <- getTermLocal builtinItIsOne + kit <- fromMaybe __IMPOSSIBLE__ <$> getSigmaKit + runNamesT [] $ do + let ineg j = pure tINeg <@> j + imax i j = pure tIMax <@> i <@> j + imin i j = pure tIMin <@> i <@> j + + gcomp <- mkGComp localUse + + let transpFill la bA phi u0 i = + pure tTrans <#> (ilam "j" $ \ j -> la <@> imin i j) + <@> (ilam "j" $ \ j -> bA <@> imin i j) + <@> (imax phi (ineg i)) + <@> u0 + [psi,u0] <- mapM (open . unArg) [psi,u0] + glue1 <- do + g <- open $ (tglue `apply`) . map (setHiding Hidden) . map (subst 0 io) $ [la, lb, bA, phi, bT, e] + return $ \ t a -> g <@> t <@> a + unglue0 <- do + ug <- open $ (tunglue `apply`) . map (setHiding Hidden) . map (subst 0 iz) $ [la, lb, bA, phi, bT, e] + return $ \ a -> ug <@> a + [la, lb, bA, phi, bT, e] <- mapM (\ a -> open . runNames [] $ (lam "i" $ const (pure $ unArg a))) [la, lb, bA, phi, bT, e] + view <- intervalView' + + ifM (headStop tpos (phi <@> pure io)) (return Nothing) $ Just <$> do + let + tf i o = transpFill lb (lam "i" $ \ i -> bT <@> i <..> o) psi u0 i + t1 o = tf (pure io) o + a0 = unglue0 u0 + + -- compute "forall. phi" + forallphi = pure tForall <@> phi + + -- a1 with gcomp + a1 = gcomp la bA + (imax psi forallphi) + (lam "i" $ \ i -> pure tPOr <#> (la <@> i) + <@> psi + <@> forallphi + <@> (ilam "o" $ \ a -> bA <@> i) + <@> (ilam "o" $ \ _ -> a0) + <@> (ilam "o" $ \ o -> pure tEFun <#> (lb <@> i) + <#> (la <@> i) + <#> (bT <@> i <..> o) + <#> (bA <@> i) + <@> (e <@> i <..> o) + <@> (tf i o))) + a0 + + max l l' = pure tLMax <@> l <@> l' + sigCon x y = pure (Con (sigmaCon kit) ConOSystem []) <@> x <@> y + w i o = pure tEFun <#> (lb <@> i) + <#> (la <@> i) + <#> (bT <@> i <..> o) + <#> (bA <@> i) + <@> (e <@> i <..> o) + fiber la lb bA bB f b = + (pure (Def (sigmaName kit) []) <#> la + <#> lb + <@> bA + <@> (lam "a" $ \ a -> pure tPath <#> lb <#> bB <@> (f <@> a) <@> b)) + + -- We don't have to do anything special for "~ forall. phi" + -- here (to implement "ghcomp") as it is taken care off by + -- tEProof in t1'alpha below + pe o = -- o : [ φ 1 ] + pure tPOr <#> max (la <@> pure io) (lb <@> pure io) + <@> psi + <@> forallphi + <@> (ilam "o" $ \ _ -> + fiber (lb <@> pure io) (la <@> pure io) + (bT <@> (pure io) <..> o) (bA <@> pure io) + (w (pure io) o) a1) + <@> (ilam "o" $ \ o -> sigCon u0 (lam "_" $ \ _ -> a1)) + <@> (ilam "o" $ \ o -> sigCon (t1 o) (lam "_" $ \ _ -> a1)) + + -- "ghcomp" is implemented in the proof of tEProof + -- (see src/data/lib/prim/Agda/Builtin/Cubical/Glue.agda) + t1'alpha o = -- o : [ φ 1 ] + pure tEProof <#> (lb <@> pure io) + <#> (la <@> pure io) + <@> (bT <@> pure io <..> o) + <@> (bA <@> pure io) + <@> (e <@> pure io <..> o) + <@> a1 + <@> (imax psi forallphi) + <@> pe o + + -- TODO: optimize? + t1' o = t1'alpha o <&> (`applyE` [Proj ProjSystem (sigmaFst kit)]) + alpha o = t1'alpha o <&> (`applyE` [Proj ProjSystem (sigmaSnd kit)]) + a1' = pure tHComp + <#> (la <@> pure io) + <#> (bA <@> pure io) + <#> (imax (phi <@> pure io) psi) + <@> (lam "j" $ \ j -> + pure tPOr <#> (la <@> pure io) <@> (phi <@> pure io) <@> psi <@> (ilam "o" $ \ _ -> bA <@> pure io) + <@> (ilam "o" $ \ o -> alpha o <@@> (w (pure io) o <@> t1' o,a1,j)) + <@> (ilam "o" $ \ _ -> a1) + ) + <@> a1 + + -- glue1 (ilam "o" t1') a1' + case tpos of + Head -> t1' (pure tItIsOne) + Eliminated -> a1' +compGlue cmd phi u u0 _ _ = __IMPOSSIBLE__ + +compHCompU :: (MonadReduce m, HasConstInfo m, HasBuiltins m) => + TranspOrHComp + -> Arg Term + -> Maybe (Arg Term) + -> Arg Term + -> FamilyOrNot (Arg Term, Arg Term, Arg Term, Arg Term) + -> TermPosition + -> m (Maybe Term) + +compHCompU DoHComp psi (Just u) u0 (IsNot (la, phi, bT, bA)) tpos = do + let getTermLocal = getTerm $ (builtinHComp ++ " for " ++ builtinHComp ++ " of Set") + io <- getTermLocal builtinIOne + iz <- getTermLocal builtinIZero + tPOr <- getTermLocal "primPOr" + tIMax <- getTermLocal builtinIMax + tIMin <- getTermLocal builtinIMin + tINeg <- getTermLocal builtinINeg + tHComp <- getTermLocal builtinHComp + tTransp <- getTermLocal builtinTrans + tglue <- getTermLocal builtin_glueU + tunglue <- getTermLocal builtin_unglueU + tLSuc <- getTermLocal builtinLevelSuc + tSubIn <- getTermLocal builtinSubIn + tItIsOne <- getTermLocal builtinItIsOne + runNamesT [] $ do + [psi, u, u0] <- mapM (open . unArg) [psi, u, u0] + [la, phi, bT, bA] <- mapM (open . unArg) [la, phi, bT, bA] + + ifM (headStop tpos phi) (return Nothing) $ Just <$> do + + let + hfill la bA phi u u0 i = pure tHComp <#> la + <#> bA + <#> (pure tIMax <@> phi <@> (pure tINeg <@> i)) + <@> (lam "j" $ \ j -> pure tPOr <#> la <@> phi <@> (pure tINeg <@> i) <@> (ilam "o" $ \ a -> bA) + <@> (ilam "o" $ \ o -> u <@> (pure tIMin <@> i <@> j) <..> o) + <@> (ilam "o" $ \ _ -> u0) + ) + <@> u0 + transp la bA a0 = pure tTransp <#> (lam "i" $ const la) <@> lam "i" bA <@> pure iz <@> a0 + tf i o = hfill la (bT <@> pure io <..> o) psi u u0 i + bAS = pure tSubIn <#> (pure tLSuc <@> la) <#> (Sort . tmSort <$> la) <#> phi <@> bA + unglue g = pure tunglue <#> la <#> phi <#> bT <#> bAS <@> g + a1 = pure tHComp <#> la <#> bA <#> (pure tIMax <@> psi <@> phi) + <@> (lam "i" $ \ i -> pure tPOr <#> la <@> psi <@> phi <@> (ilam "_" $ \ _ -> bA) + <@> (ilam "o" $ \ o -> unglue (u <@> i <..> o)) + <@> (ilam "o" $ \ o -> transp la (\ i -> bT <@> (pure tINeg <@> i) <..> o) (tf i o)) + ) + <@> unglue u0 + t1 = tf (pure io) + + -- pure tglue <#> la <#> phi <#> bT <#> bAS <@> (ilam "o" $ \ o -> t1 o) <@> a1 + case tpos of + Eliminated -> a1 + Head -> t1 (pure tItIsOne) + + + +compHCompU DoTransp psi Nothing u0 (IsFam (la, phi, bT, bA)) tpos = do + let + localUse = builtinTrans ++ " for " ++ builtinHComp ++ " of Set" + getTermLocal = getTerm localUse + tPOr <- getTermLocal "primPOr" + tIMax <- getTermLocal builtinIMax + tIMin <- getTermLocal builtinIMin + tINeg <- getTermLocal builtinINeg + tHComp <- getTermLocal builtinHComp + tTrans <- getTermLocal builtinTrans + tTranspProof <- getTermLocal builtinTranspProof + tSubIn <- getTermLocal builtinSubIn + tForall <- getTermLocal builtinFaceForall + io <- getTermLocal builtinIOne + iz <- getTermLocal builtinIZero + tLSuc <- getTermLocal builtinLevelSuc + tPath <- getTermLocal builtinPath + tItIsOne <- getTermLocal builtinItIsOne + kit <- fromMaybe __IMPOSSIBLE__ <$> getSigmaKit + runNamesT [] $ do + let ineg j = pure tINeg <@> j + imax i j = pure tIMax <@> i <@> j + imin i j = pure tIMin <@> i <@> j + transp la bA a0 = pure tTrans <#> (lam "i" $ const la) <@> lam "i" bA <@> pure iz <@> a0 + + gcomp <- mkGComp localUse + + let transpFill la bA phi u0 i = + pure tTrans <#> (ilam "j" $ \ j -> la <@> imin i j) + <@> (ilam "j" $ \ j -> bA <@> imin i j) + <@> (imax phi (ineg i)) + <@> u0 + [psi,u0] <- mapM (open . unArg) [psi,u0] + glue1 <- do + tglue <- cl $ getTermLocal builtin_glueU + [la, phi, bT, bA] <- mapM (open . unArg . subst 0 io) $ [la, phi, bT, bA] + let bAS = pure tSubIn <#> (pure tLSuc <@> la) <#> (Sort . tmSort <$> la) <#> phi <@> bA + g <- (open =<<) $ pure tglue <#> la <#> phi <#> bT <#> bAS + return $ \ t a -> g <@> t <@> a + unglue0 <- do + tunglue <- cl $ getTermLocal builtin_unglueU + [la, phi, bT, bA] <- mapM (open . unArg . subst 0 iz) $ [la, phi, bT, bA] + let bAS = pure tSubIn <#> (pure tLSuc <@> la) <#> (Sort . tmSort <$> la) <#> phi <@> bA + ug <- (open =<<) $ pure tunglue <#> la <#> phi <#> bT <#> bAS + return $ \ a -> ug <@> a + [la, phi, bT, bA] <- mapM (\ a -> open . runNames [] $ (lam "i" $ const (pure $ unArg a))) [la, phi, bT, bA] + + ifM (headStop tpos (phi <@> pure io)) (return Nothing) $ Just <$> do + + let + lb = la + tf i o = transpFill lb (lam "i" $ \ i -> bT <@> i <@> pure io <..> o) psi u0 i + t1 o = tf (pure io) o + a0 = unglue0 u0 + + -- compute "forall. phi" + forallphi = pure tForall <@> phi + + -- a1 with gcomp + a1 = gcomp la bA + (imax psi forallphi) + (lam "i" $ \ i -> pure tPOr <#> (la <@> i) + <@> psi + <@> forallphi + <@> (ilam "o" $ \ a -> bA <@> i) + <@> (ilam "o" $ \ _ -> a0) + <@> (ilam "o" $ \ o -> transp (la <@> i) + (\ j -> bT <@> i <@> ineg j <..> o) + (tf i o))) + a0 + + sigCon x y = pure (Con (sigmaCon kit) ConOSystem []) <@> x <@> y + w i o = lam "x" $ + transp (la <@> i) + (\ j -> bT <@> i <@> ineg j <..> o) + fiber la lb bA bB f b = + (pure (Def (sigmaName kit) []) <#> la + <#> lb + <@> bA + <@> (lam "a" $ \ a -> pure tPath <#> lb <#> bB <@> (f <@> a) <@> b)) + + pt o = -- o : [ φ 1 ] + pure tPOr <#> (la <@> pure io) + <@> psi + <@> forallphi + <@> (ilam "o" $ \ _ -> bT <@> pure io <@> pure io <..> o) + <@> (ilam "o" $ \ o -> u0) + <@> (ilam "o" $ \ o -> t1 o) + + -- "ghcomp" is implemented in the proof of tTranspProof + -- (see src/data/lib/prim/Agda/Builtin/Cubical/HCompU.agda) + t1'alpha o = -- o : [ φ 1 ] + pure tTranspProof <#> (la <@> pure io) + <@> (lam "i" $ \ i -> bT <@> pure io <@> ineg i <..> o) + <@> imax psi forallphi + <@> pt o + <@> (pure tSubIn <#> (la <@> pure io) <#> (bA <@> pure io) + <#> imax psi forallphi + <@> a1) + + -- TODO: optimize? + t1' o = t1'alpha o <&> (`applyE` [Proj ProjSystem (sigmaFst kit)]) + alpha o = t1'alpha o <&> (`applyE` [Proj ProjSystem (sigmaSnd kit)]) + a1' = pure tHComp + <#> (la <@> pure io) + <#> (bA <@> pure io) + <#> (imax (phi <@> pure io) psi) + <@> (lam "j" $ \ j -> + pure tPOr <#> (la <@> pure io) <@> (phi <@> pure io) <@> psi <@> (ilam "o" $ \ _ -> bA <@> pure io) + <@> (ilam "o" $ \ o -> alpha o <@@> (w (pure io) o <@> t1' o,a1,j)) + <@> (ilam "o" $ \ _ -> a1) + ) + <@> a1 + + -- glue1 (ilam "o" t1') a1' + case tpos of + Eliminated -> a1' + Head -> t1' (pure tItIsOne) +compHCompU _ psi _ u0 _ _ = __IMPOSSIBLE__ + + +primTransHComp :: TranspOrHComp -> [Arg Term] -> Int -> ReduceM (Reduced MaybeReducedArgs Term) +primTransHComp cmd ts nelims = do + (l,bA,phi,u,u0) <- case (cmd,ts) of + (DoTransp, [l,bA,phi, u0]) -> do + -- u <- runNamesT [] $ do + -- u0 <- open $ unArg u0 + -- defaultArg <$> (ilam "o" $ \ _ -> u0) + return $ (IsFam l,IsFam bA,phi,Nothing,u0) + (DoHComp, [l,bA,phi,u,u0]) -> do + -- [l,bA] <- runNamesT [] $ do + -- forM [l,bA] $ \ a -> do + -- let info = argInfo a + -- a <- open $ unArg a + -- Arg info <$> (lam "i" $ \ _ -> a) + return $ (IsNot l,IsNot bA,phi,Just u,u0) + _ -> __IMPOSSIBLE__ + sphi <- reduceB' phi + vphi <- intervalView $ unArg $ ignoreBlocking sphi + let clP s = getTerm (cmdToName cmd) s + + -- WORK + case vphi of + IOne -> redReturn =<< case u of + -- cmd == DoComp + Just u -> runNamesT [] $ do + u <- open (unArg u) + u <@> clP builtinIOne <..> clP builtinItIsOne + -- cmd == DoTransp + Nothing -> return $ unArg u0 + _ -> do + let fallback' sc = do + u' <- case u of + -- cmd == DoComp + Just u -> + (:[]) <$> case vphi of + IZero -> fmap (reduced . notBlocked . argN) . runNamesT [] $ do + [l,c] <- mapM (open . unArg) [famThing l, ignoreBlocking sc] + lam "i" $ \ i -> clP builtinIsOneEmpty <#> l + <#> (ilam "o" $ \ _ -> c) + _ -> return (notReduced u) + -- cmd == DoTransp + Nothing -> return [] + return $ NoReduction $ [notReduced (famThing l), reduced sc, reduced sphi] ++ u' ++ [notReduced u0] + sbA <- reduceB' bA + t <- case unArg <$> ignoreBlocking sbA of + IsFam (Lam _info t) -> Just . fmap IsFam <$> reduceB' (absBody t) + IsFam _ -> return Nothing + IsNot t -> return . Just . fmap IsNot $ (t <$ sbA) + case t of + Nothing -> fallback' (famThing <$> sbA) + Just st -> do + let + fallback = fallback' (fmap famThing $ st *> sbA) + t = ignoreBlocking st + mHComp <- getPrimitiveName' builtinHComp + mGlue <- getPrimitiveName' builtinGlue + mId <- getBuiltinName' builtinId + pathV <- pathView' + case famThing t of + MetaV m _ -> fallback' (fmap famThing $ Blocked m () *> sbA) + -- absName t instead of "i" + Pi a b | nelims > 0 -> maybe fallback redReturn =<< compPi cmd "i" ((a,b) <$ t) (ignoreBlocking sphi) u u0 + | otherwise -> fallback + + Sort (Type l) | DoTransp <- cmd -> compSort cmd fallback phi u u0 (l <$ t) + + Def q [Apply la, Apply lb, Apply bA, Apply phi', Apply bT, Apply e] | Just q == mGlue -> do + maybe fallback redReturn =<< compGlue cmd phi u u0 ((la, lb, bA, phi', bT, e) <$ t) Head + + Def q [Apply _, Apply s, Apply phi', Apply bT, Apply bA] + | Just q == mHComp, Sort (Type la) <- unArg s -> do + maybe fallback redReturn =<< compHCompU cmd phi u u0 ((Level la <$ s, phi', bT, bA) <$ t) Head + + -- Path/PathP + d | PathType _ _ _ bA x y <- pathV (El __DUMMY_SORT__ d) -> do + if nelims > 0 then compPathP cmd sphi u u0 l ((bA, x, y) <$ t) else fallback + + Def q [Apply _ , Apply bA , Apply x , Apply y] | Just q == mId -> do + maybe fallback return =<< compId cmd sphi u u0 l ((bA, x, y) <$ t) + + Def q es -> do + info <- getConstInfo q + let lam_i = Lam defaultArgInfo . Abs "i" + + case theDef info of + r@Record{recComp = kit} | nelims > 0, Just as <- allApplyElims es, DoTransp <- cmd, Just transpR <- nameOfTransp kit + -> if recPars r == 0 + then redReturn $ unArg u0 + else redReturn $ (Def transpR []) `apply` + (map (fmap lam_i) as ++ [ignoreBlocking sphi,u0]) + | nelims > 0, Just as <- allApplyElims es, DoHComp <- cmd, Just hCompR <- nameOfHComp kit + -> redReturn $ (Def hCompR []) `apply` + (as ++ [ignoreBlocking sphi,fromMaybe __IMPOSSIBLE__ u,u0]) + + | Just as <- allApplyElims es, [] <- recFields r -> compData False (recPars r) cmd l (as <$ t) sbA sphi u u0 + Datatype{dataPars = pars, dataIxs = ixs, dataPathCons = pcons} + | and [null pcons | DoHComp <- [cmd]], Just as <- allApplyElims es -> compData (not $ null $ pcons) (pars+ixs) cmd l (as <$ t) sbA sphi u u0 + -- postulates with no arguments do not need to transport. + Axiom{} | [] <- es, DoTransp <- cmd -> redReturn $ unArg u0 + _ -> fallback + + _ -> fallback + where + compSort DoTransp fallback phi Nothing u0 (IsFam l) = do + -- TODO should check l is constant + redReturn $ unArg u0 + -- compSort DoHComp fallback phi (Just u) u0 (IsNot l) = -- hcomp for Set is a whnf, handled above. + compSort _ fallback phi u u0 _ = __IMPOSSIBLE__ + compPi :: TranspOrHComp -> ArgName -> FamilyOrNot (Dom Type, Abs Type) -- Γ , i : I + -> Arg Term -- Γ + -> Maybe (Arg Term) -- Γ + -> Arg Term -- Γ + -> ReduceM (Maybe Term) + compPi cmd t ab phi u u0 = do + let getTermLocal = getTerm $ cmdToName cmd ++ " for function types" + + tTrans <- getTermLocal builtinTrans + tHComp <- getTermLocal builtinHComp + tINeg <- getTermLocal builtinINeg + tIMax <- getTermLocal builtinIMax + iz <- getTermLocal builtinIZero + let + toLevel' t = do + s <- reduce $ getSort t + case s of + (Type l) -> return (Just l) + _ -> return Nothing + toLevel t = fromMaybe __IMPOSSIBLE__ <$> toLevel' t + -- make sure the codomain has a level. + caseMaybeM (toLevel' . absBody . snd . famThing $ ab) (return Nothing) $ \ _ -> do + runNamesT [] $ do + labA <- do + let (x,f) = case ab of + IsFam (a,_) -> (a, \ a -> runNames [] $ (lam "i" $ const (pure a))) + IsNot (a,_) -> (a, id) + lx <- toLevel' x + caseMaybe lx (return Nothing) $ \ lx -> Just <$> + mapM (open . f) [Level lx, unEl . unDom $ x] + caseMaybe labA (return Nothing) $ \ [la,bA] -> Just <$> do + [phi, u0] <- mapM (open . unArg) [phi, u0] + u <- traverse open (unArg <$> u) + + glam (getArgInfo (fst $ famThing ab)) (absName $ snd $ famThing ab) $ \ u1 -> do + case (cmd, ab, u) of + (DoHComp, IsNot (a , b), Just u) -> do + bT <- (raise 1 b `absApp`) <$> u1 + let v = u1 + pure tHComp <#> (Level <$> toLevel bT) + <#> (pure $ unEl $ bT) + <#> phi + <@> (lam "i" $ \ i -> ilam "o" $ \ o -> gApply (getHiding a) (u <@> i <..> o) v) + <@> (gApply (getHiding a) u0 v) + (DoTransp, IsFam (a , b), Nothing) -> do + let v i = do + let + iOrNot j = pure tIMax <@> i <@> (pure tINeg <@> j) + pure tTrans <#> (lam "j" $ \ j -> la <@> iOrNot j) + <@> (lam "j" $ \ j -> bA <@> iOrNot j) + <@> (pure tIMax <@> phi <@> i) + <@> u1 + -- Γ , u1 : A[i1] , i : I + bB v = (consS v $ liftS 1 $ raiseS 1) `applySubst` (absBody b {- Γ , i : I , x : A[i] -}) + tLam = Lam defaultArgInfo + bT <- bind "i" $ \ i -> bB <$> v i + -- Γ , u1 : A[i1] + (pure tTrans <#> (tLam <$> traverse (fmap Level . toLevel) bT) + <@> (pure . tLam $ unEl <$> bT) + <@> phi + <@> gApply (getHiding a) u0 (v (pure iz))) + (_,_,_) -> __IMPOSSIBLE__ + compPathP cmd@DoHComp sphi (Just u) u0 (IsNot l) (IsNot (bA,x,y)) = do + let getTermLocal = getTerm $ cmdToName cmd ++ " for path types" + tHComp <- getTermLocal builtinHComp + tINeg <- getTermLocal builtinINeg + tIMax <- getTermLocal builtinIMax + tOr <- getTermLocal "primPOr" + let + ineg j = pure tINeg <@> j + imax i j = pure tIMax <@> i <@> j + + redReturn . runNames [] $ do + [l,u,u0] <- mapM (open . unArg) [l,u,u0] + phi <- open . unArg . ignoreBlocking $ sphi + [bA, x, y] <- mapM (open . unArg) [bA, x, y] + lam "j" $ \ j -> + pure tHComp <#> l + <#> (bA <@> j) + <#> (phi `imax` (ineg j `imax` j)) + <@> (lam "i'" $ \ i -> + let or f1 f2 = pure tOr <#> l <@> f1 <@> f2 <#> (lam "_" $ \ _ -> bA <@> i) + in or phi (ineg j `imax` j) + <@> (ilam "o" $ \ o -> u <@> i <..> o <@@> (x, y, j)) -- a0 <@@> (x <@> i, y <@> i, j) + <@> (or (ineg j) j <@> (ilam "_" $ const x) + <@> (ilam "_" $ const y))) + <@> (u0 <@@> (x, y, j)) + compPathP cmd@DoTransp sphi Nothing u0 (IsFam l) (IsFam (bA,x,y)) = do + -- Γ ⊢ l + -- Γ, i ⊢ bA, x, y + let getTermLocal = getTerm $ cmdToName cmd ++ " for path types" + tINeg <- getTermLocal builtinINeg + tIMax <- getTermLocal builtinIMax + tOr <- getTermLocal "primPOr" + iz <- getTermLocal builtinIZero + io <- getTermLocal builtinIOne + let + ineg j = pure tINeg <@> j + imax i j = pure tIMax <@> i <@> j + comp <- do + tHComp <- getTermLocal builtinHComp + tTrans <- getTermLocal builtinTrans + let forward la bA r u = pure tTrans <#> (lam "i" $ \ i -> la <@> (i `imax` r)) + <@> (lam "i" $ \ i -> bA <@> (i `imax` r)) + <@> r + <@> u + return $ \ la bA phi u u0 -> + pure tHComp <#> (la <@> pure io) + <#> (bA <@> pure io) + <#> phi + <@> (lam "i" $ \ i -> ilam "o" $ \ o -> + forward la bA i (u <@> i <..> o)) + <@> forward la bA (pure iz) u0 + redReturn . runNames [] $ do + [l,u0] <- mapM (open . unArg) [l,u0] + phi <- open . unArg . ignoreBlocking $ sphi + [bA, x, y] <- mapM (\ a -> open . runNames [] $ (lam "i" $ const (pure $ unArg a))) [bA, x, y] + lam "j" $ \ j -> + comp l (lam "i" $ \ i -> bA <@> i <@> j) (phi `imax` (ineg j `imax` j)) + (lam "i'" $ \ i -> + let or f1 f2 = pure tOr <#> l <@> f1 <@> f2 <#> (lam "_" $ \ _ -> bA <@> i <@> j) in + or phi (ineg j `imax` j) + <@> (ilam "o" $ \ o -> u0 <@@> (x <@> pure iz, y <@> pure iz, j)) + <@> (or (ineg j) j <@> (ilam "_" $ const (x <@> i)) + <@> (ilam "_" $ const (y <@> i)))) + (u0 <@@> (x <@> pure iz, y <@> pure iz, j)) + compPathP _ sphi u a0 _ _ = __IMPOSSIBLE__ + compId cmd sphi u a0 l bA_x_y = do + let getTermLocal = getTerm $ cmdToName cmd ++ " for " ++ builtinId + unview <- intervalUnview' + mConId <- getBuiltinName' builtinConId + let isConId (Def q _) = Just q == mConId + isConId _ = False + sa0 <- reduceB' a0 + -- wasteful to compute b even when cheaper checks might fail + b <- case u of + Nothing -> return True + Just u -> allComponents unview (unArg . ignoreBlocking $ sphi) (unArg u) isConId + case mConId of + Just conid | isConId (unArg . ignoreBlocking $ sa0) , b -> (Just <$>) . (redReturn =<<) $ do + tHComp <- getTermLocal builtinHComp + tTrans <- getTermLocal builtinTrans + tIMin <- getTermLocal "primDepIMin" + tFace <- getTermLocal "primIdFace" + tPath <- getTermLocal "primIdPath" + tPathType <- getTermLocal builtinPath + runNamesT [] $ do + let irrInfo = setRelevance Irrelevant defaultArgInfo + let io = pure $ unview IOne + iz = pure $ unview IZero + conId = pure $ Def conid [] + l <- case l of + IsFam l -> open . unArg $ l + IsNot l -> do + open (Lam defaultArgInfo $ NoAbs "_" $ unArg l) + [p0] <- mapM (open . unArg) [a0] + p <- case u of + Just u -> do + u <- open . unArg $ u + return $ \ i o -> u <@> i <..> o + Nothing -> do + return $ \ i o -> p0 + phi <- open . unArg . ignoreBlocking $ sphi + [bA, x, y] <- + case bA_x_y of + IsFam (bA,x,y) -> mapM (\ a -> open . runNames [] $ (lam "i" $ const (pure $ unArg a))) [bA, x, y] + IsNot (bA,x,y) -> forM [bA,x,y] $ \ a -> open (Lam defaultArgInfo $ NoAbs "_" $ unArg a) + let + eval DoTransp l bA phi _ u0 = pure tTrans <#> l <@> bA <@> phi <@> u0 + eval DoHComp l bA phi u u0 = pure tHComp <#> (l <@> io) <#> (bA <@> io) <#> phi + <@> u <@> u0 + conId <#> (l <@> io) <#> (bA <@> io) <#> (x <@> io) <#> (y <@> io) + <@> (pure tIMin <@> phi + <@> (ilam "o" $ \ o -> pure tFace <#> (l <@> io) <#> (bA <@> io) <#> (x <@> io) <#> (y <@> io) + <@> (p io o))) + <@> (eval cmd l + (lam "i" $ \ i -> pure tPathType <#> (l <@> i) <#> (bA <@> i) <@> (x <@> i) <@> (y <@> i)) + phi + (lam "i" $ \ i -> ilam "o" $ \ o -> pure tPath <#> (l <@> i) <#> (bA <@> i) + <#> (x <@> i) <#> (y <@> i) + <@> (p i o) + ) + (pure tPath <#> (l <@> iz) <#> (bA <@> iz) <#> (x <@> iz) <#> (y <@> iz) + <@> p0) + ) + _ -> return $ Nothing + allComponents unview phi u p = do + let + boolToI b = if b then unview IOne else unview IZero + as <- decomposeInterval phi + andM . for as $ \ (bs,ts) -> do + let u' = listS (Map.toAscList $ Map.map boolToI bs) `applySubst` u + t <- reduce2Lam u' + return $! p $ ignoreBlocking t + reduce2Lam t = do + t <- reduce' t + case lam2Abs t of + t -> underAbstraction_ t $ \ t -> do + t <- reduce' t + case lam2Abs t of + t -> underAbstraction_ t reduceB' + where + lam2Abs (Lam _ t) = absBody t <$ t + lam2Abs t = Abs "y" (raise 1 t `apply` [argN $ var 0]) + allComponentsBack unview phi u p = do + let + boolToI b = if b then unview IOne else unview IZero + lamlam t = Lam defaultArgInfo (Abs "i" (Lam (setRelevance Irrelevant defaultArgInfo) (Abs "o" t))) + as <- decomposeInterval phi + (flags,t_alphas) <- fmap unzip . forM as $ \ (bs,ts) -> do + let u' = listS bs' `applySubst` u + bs' = (Map.toAscList $ Map.map boolToI bs) + let weaken = foldr composeS idS $ map (\ j -> liftS j (raiseS 1)) $ map fst bs' + t <- reduce2Lam u' + return $ (p $ ignoreBlocking t, listToMaybe [ (weaken `applySubst` (lamlam <$> t),bs) | null ts ]) + return $ (flags,t_alphas) + compData False _ cmd@DoHComp (IsNot l) (IsNot ps) fsc sphi (Just u) a0 = do + let getTermLocal = getTerm $ cmdToName cmd ++ " for data types" + + let sc = famThing <$> fsc + tEmpty <- getTermLocal builtinIsOneEmpty + tPOr <- getTermLocal builtinPOr + iO <- getTermLocal builtinIOne + iZ <- getTermLocal builtinIZero + tMin <- getTermLocal builtinIMin + tNeg <- getTermLocal builtinINeg + let iNeg t = tNeg `apply` [argN t] + iMin t u = tMin `apply` [argN t, argN u] + iz = pure iZ + constrForm <- do + mz <- getTerm' builtinZero + ms <- getTerm' builtinSuc + return $ \ t -> fromMaybe t (constructorForm' mz ms t) + su <- reduceB' u + sa0 <- reduceB' a0 + view <- intervalView' + unview <- intervalUnview' + let f = unArg . ignoreBlocking + phi = f sphi + u = f su + a0 = f sa0 + isLit t@(Lit lt) = Just t + isLit _ = Nothing + isCon (Con h _ _) = Just h + isCon _ = Nothing + combine l ty d [] = d + combine l ty d [(psi,u)] = u + combine l ty d ((psi,u):xs) + = pure tPOr <#> l <@> psi <@> (foldr imax iz (map fst xs)) + <#> (ilam "o" $ \ _ -> ty) -- the type + <@> u <@> (combine l ty d xs) + noRed' su = return $ NoReduction [notReduced l,reduced sc, reduced sphi, reduced su', reduced sa0] + where + su' = case view phi of + IZero -> notBlocked $ argN $ runNames [] $ do + [l,c] <- mapM (open . unArg) [l,ignoreBlocking sc] + lam "i" $ \ i -> pure tEmpty <#> l + <#> (ilam "o" $ \ _ -> c) + _ -> su + sameConHeadBack Nothing Nothing su k = noRed' su + sameConHeadBack lt h su k = do + let u = unArg . ignoreBlocking $ su + (b, ts) <- allComponentsBack unview phi u $ \ t -> + (isLit t == lt, isCon (constrForm t) == h) + let + (lit,hd) = unzip b + + if isJust lt && and lit then redReturn a0 else do + su <- caseMaybe (sequence ts) (return su) $ \ ts -> do + let (us,bools) = unzip ts + fmap ((sequenceA_ us $>) . argN) $ do + let + phis :: [Term] + phis = for bools $ \ m -> + foldr iMin iO $ map (\(i,b) -> if b then var i else iNeg (var i)) $ Map.toList m + runNamesT [] $ do + u <- open u + [l,c] <- mapM (open . unArg) [l,ignoreBlocking sc] + phis <- mapM open phis + us <- mapM (open . ignoreBlocking) us + lam "i" $ \ i -> do + combine l c (u <@> i) $ zip phis (map (\ t -> t <@> i) us) + + if isJust h && and hd then k (fromMaybe __IMPOSSIBLE__ h) su + else noRed' su + + sameConHeadBack (isLit a0) (isCon a0) su $ \ h su -> do + let u = unArg . ignoreBlocking $ su + Constructor{ conComp = cm } <- theDef <$> getConstInfo (conName h) + case nameOfHComp cm of + Just hcompD -> redReturn $ Def hcompD [] `apply` + (ps ++ map argN [phi,u,a0]) + Nothing -> noRed' su + + compData _ 0 DoTransp (IsFam l) (IsFam ps) fsc sphi Nothing a0 = redReturn $ unArg a0 + compData isHIT _ cmd@DoTransp (IsFam l) (IsFam ps) fsc sphi Nothing a0 = do + let getTermLocal = getTerm $ cmdToName cmd ++ " for data types" + let sc = famThing <$> fsc + mhcompName <- getName' builtinHComp + constrForm <- do + mz <- getTerm' builtinZero + ms <- getTerm' builtinSuc + return $ \ t -> fromMaybe t (constructorForm' mz ms t) + sa0 <- reduceB' a0 + let f = unArg . ignoreBlocking + phi = f sphi + a0 = f sa0 + noRed = return $ NoReduction [notReduced l,reduced sc, reduced sphi, reduced sa0] + let lam_i = Lam defaultArgInfo . Abs "i" + case constrForm a0 of + Con h _ args -> do + Constructor{ conComp = cm } <- theDef <$> getConstInfo (conName h) + case nameOfTransp cm of + Just transpD -> redReturn $ Def transpD [] `apply` + (map (fmap lam_i) ps ++ map argN [phi,a0]) + Nothing -> noRed + Def q es | isHIT, Just q == mhcompName, Just [_l0,_c0,psi,u,u0] <- allApplyElims es -> do + let bC = ignoreBlocking sc + hcomp <- getTermLocal builtinHComp + transp <- getTermLocal builtinTrans + io <- getTermLocal builtinIOne + iz <- getTermLocal builtinIZero + (redReturn =<<) . runNamesT [] $ do + [l,bC,phi,psi,u,u0] <- mapM (open . unArg) [l,bC,ignoreBlocking sphi,psi,u,u0] + -- hcomp (sc 1) [psi |-> transp sc phi u] (transp sc phi u0) + pure hcomp <#> (l <@> pure io) <#> (bC <@> pure io) <#> psi + <@> (lam "j" $ \ j -> ilam "o" $ \ o -> + pure transp <#> l <@> bC <@> phi <@> (u <@> j <..> o)) + <@> (pure transp <#> l <@> bC <@> phi <@> u0) + _ -> noRed + compData _ _ _ _ _ _ _ _ _ = __IMPOSSIBLE__ + compPO = __IMPOSSIBLE__ + +primComp :: TCM PrimitiveImpl +primComp = do + requireCubical + t <- runNamesT [] $ + hPi' "a" (elInf (cl primInterval) --> (el $ cl primLevel)) $ \ a -> + nPi' "A" (nPi' "i" (elInf (cl primInterval)) $ \ i -> (sort . tmSort <$> (a <@> i))) $ \ bA -> + hPi' "φ" (elInf $ cl primInterval) $ \ phi -> + (nPi' "i" (elInf $ cl primInterval) $ \ i -> pPi' "o" phi $ \ _ -> el' (a <@> i) (bA <@> i)) --> + (el' (a <@> cl primIZero) (bA <@> cl primIZero) --> el' (a <@> cl primIOne) (bA <@> cl primIOne)) + one <- primItIsOne + io <- primIOne + return $ PrimImpl t $ PrimFun __IMPOSSIBLE__ 5 $ \ ts nelims -> do + case ts of + [l,c,phi,u,a0] -> do + sphi <- reduceB' phi + vphi <- intervalView $ unArg $ ignoreBlocking sphi + case vphi of + IOne -> redReturn (unArg u `apply` [argN io, argN one]) + _ -> do + let getTermLocal = getTerm $ builtinComp + tIMax <- getTermLocal builtinIMax + tINeg <- getTermLocal builtinINeg + tHComp <- getTermLocal builtinHComp + tTrans <- getTermLocal builtinTrans + iz <- getTermLocal builtinIZero + (redReturn =<<) . runNamesT [] $ do + comp <- do + let + ineg j = (pure tINeg <@> j) :: TCMT IO Term + imax i j = pure tIMax <@> i <@> j + let forward la bA r u = pure tTrans <#> (lam "i" $ \ i -> la <@> (i `imax` r)) + <@> (lam "i" $ \ i -> bA <@> (i `imax` r)) + <@> r + <@> u + return $ \ la bA phi u u0 -> + pure tHComp <#> (la <@> pure io) <#> (bA <@> pure io) <#> phi + <@> (lam "i" $ \ i -> ilam "o" $ \ o -> + forward la bA i (u <@> i <..> o)) + <@> forward la bA (pure iz) u0 + + [l,c,phi,u,a0] <- mapM (open . unArg) [l,c,phi,u,a0] + comp l c phi u a0 + + _ -> __IMPOSSIBLE__ + + +prim_glueU' :: TCM PrimitiveImpl +prim_glueU' = do + requireCubical + t <- runNamesT [] $ + (hPi' "la" (el $ cl primLevel) $ \ la -> + hPi' "φ" (elInf $ cl primInterval) $ \ φ -> + hPi' "T" (nPi' "i" (elInf $ cl primInterval) $ \ _ -> pPi' "o" φ $ \ o -> sort . tmSort <$> la) $ \ t -> + hPi' "A" (elInf $ cl primSub <#> (cl primLevelSuc <@> la) <@> (Sort . tmSort <$> la) <@> φ <@> (t <@> primIZero)) $ \ a -> do + let bA = (cl primSubOut <#> (cl primLevelSuc <@> la) <#> (Sort . tmSort <$> la) <#> φ <#> (t <@> primIZero) <@> a) + (pPi' "o" φ $ \ o -> el' la (t <@> cl primIOne <..> o)) + --> (el' la bA) + --> el' la (cl primHComp <#> (cl primLevelSuc <@> la) <#> (Sort . tmSort <$> la) <#> φ <@> t <@> bA)) + view <- intervalView' + one <- primItIsOne + return $ PrimImpl t $ primFun __IMPOSSIBLE__ 6 $ \ts -> + case ts of + [la,phi,bT,bA,t,a] -> do + sphi <- reduceB' phi + case view $ unArg $ ignoreBlocking $ sphi of + IOne -> redReturn $ unArg t `apply` [argN one] + _ -> return (NoReduction $ map notReduced [la] ++ [reduced sphi] ++ map notReduced [bT,bA,t,a]) + _ -> __IMPOSSIBLE__ + +prim_unglueU' :: TCM PrimitiveImpl +prim_unglueU' = do + requireCubical + t <- runNamesT [] $ + (hPi' "la" (el $ cl primLevel) $ \ la -> + hPi' "φ" (elInf $ cl primInterval) $ \ φ -> + hPi' "T" (nPi' "i" (elInf $ cl primInterval) $ \ _ -> pPi' "o" φ $ \ o -> sort . tmSort <$> la) $ \ t -> + hPi' "A" (elInf $ cl primSub <#> (cl primLevelSuc <@> la) <@> (Sort . tmSort <$> la) <@> φ <@> (t <@> primIZero)) $ \ a -> do + let bA = (cl primSubOut <#> (cl primLevelSuc <@> la) <#> (Sort . tmSort <$> la) <#> φ <#> (t <@> primIZero) <@> a) + el' la (cl primHComp <#> (cl primLevelSuc <@> la) <#> (Sort . tmSort <$> la) <#> φ <@> t <@> bA) + --> el' la bA) + view <- intervalView' + one <- primItIsOne + mglueU <- getPrimitiveName' builtin_glueU + mtransp <- getPrimitiveName' builtinTrans + mHCompU <- getPrimitiveName' builtinHComp + let mhcomp = mHCompU + return $ PrimImpl t $ primFun __IMPOSSIBLE__ 5 $ \ts -> + case ts of + [la,phi,bT,bA,b] -> do + sphi <- reduceB' phi + case view $ unArg $ ignoreBlocking $ sphi of + IOne -> do + tTransp <- getTerm builtin_unglueU builtinTrans + iNeg <- getTerm builtin_unglueU builtinINeg + iZ <- getTerm builtin_unglueU builtinIZero + (redReturn =<<) . runNamesT [] $ do + [la,bT,b] <- mapM (open . unArg) [la,bT,b] + pure tTransp <#> (lam "i" $ \ _ -> la) + <@> (lam "i" $ \ i -> bT <@> (pure iNeg <@> i) <..> pure one) + <@> pure iZ + <@> b + _ -> do + sb <- reduceB' b + let fallback sbA = return (NoReduction $ map notReduced [la] ++ [reduced sphi] ++ map notReduced [bT,bA] ++ [reduced sb]) + case unArg $ ignoreBlocking $ sb of + Def q [Apply _,Apply _,Apply _,Apply _,Apply _,Apply a] + | Just q == mglueU -> redReturn $ unArg a + Def q [Apply l,Apply bA,Apply r,Apply u0] + | Just q == mtransp -> do + sbA <- reduceB bA + case unArg $ ignoreBlocking sbA of + Lam _ t -> do + st <- reduceB' (absBody t) + case ignoreBlocking st of + Def h es | Just [la,_,phi,bT,bA] <- allApplyElims es, Just h == mHCompU -> do + redReturn . fromMaybe __IMPOSSIBLE__ =<< compHCompU DoTransp r Nothing u0 (IsFam (la,phi,bT,bA)) Eliminated + _ -> fallback (st *> sbA) + _ -> fallback sbA + Def q [Apply l,Apply bA,Apply r,Apply u,Apply u0] + | Just q == mhcomp -> do + sbA <- reduceB bA + case unArg $ ignoreBlocking sbA of + Def h es | Just [la,_,phi,bT,bA] <- allApplyElims es, Just h == mHCompU -> do + redReturn . fromMaybe __IMPOSSIBLE__ =<< compHCompU DoHComp r (Just u) u0 (IsNot (la,phi,bT,bA)) Eliminated + _ -> fallback sbA + _ -> return (NoReduction $ map notReduced [la] ++ [reduced sphi] ++ map notReduced [bT,bA] ++ [reduced sb]) + _ -> __IMPOSSIBLE__ + + +primGlue' :: TCM PrimitiveImpl +primGlue' = do + requireCubical + -- Glue' : ∀ {l} (A : Set l) → ∀ φ → (T : Partial (Set a) φ) (f : (PartialP φ \ o → (T o) -> A)) + -- ([f] : PartialP φ \ o → isEquiv (T o) A (f o)) → Set l + t <- runNamesT [] $ + (hPi' "la" (el $ cl primLevel) $ \ la -> + hPi' "lb" (el $ cl primLevel) $ \ lb -> + nPi' "A" (sort . tmSort <$> la) $ \ a -> + hPi' "φ" (elInf $ cl primInterval) $ \ φ -> + nPi' "T" (pPi' "o" φ $ \ o -> el' (cl primLevelSuc <@> lb) (Sort . tmSort <$> lb)) $ \ t -> + (pPi' "o" φ $ \ o -> el' (cl primLevelMax <@> la <@> lb) $ cl primEquiv <#> lb <#> la <@> (t <@> o) <@> a) + --> (sort . tmSort <$> lb)) + view <- intervalView' + one <- primItIsOne + return $ PrimImpl t $ primFun __IMPOSSIBLE__ 6 $ \ts -> + case ts of + [la,lb,a,phi,t,e] -> do + sphi <- reduceB' phi + case view $ unArg $ ignoreBlocking $ sphi of + IOne -> redReturn $ unArg t `apply` [argN one] + _ -> return (NoReduction $ map notReduced [la,lb,a] ++ [reduced sphi] ++ map notReduced [t,e]) + _ -> __IMPOSSIBLE__ + +prim_glue' :: TCM PrimitiveImpl +prim_glue' = do + requireCubical + t <- runNamesT [] $ + (hPi' "la" (el $ cl primLevel) $ \ la -> + hPi' "lb" (el $ cl primLevel) $ \ lb -> + hPi' "A" (sort . tmSort <$> la) $ \ a -> + hPi' "φ" (elInf $ cl primInterval) $ \ φ -> + hPi' "T" (pPi' "o" φ $ \ o -> el' (cl primLevelSuc <@> lb) (Sort . tmSort <$> lb)) $ \ t -> + hPi' "e" (pPi' "o" φ $ \ o -> el' (cl primLevelMax <@> la <@> lb) $ cl primEquiv <#> lb <#> la <@> (t <@> o) <@> a) $ \ e -> + (pPi' "o" φ $ \ o -> el' lb (t <@> o)) --> (el' la a --> el' lb (cl primGlue <#> la <#> lb <@> a <#> φ <@> t <@> e))) + view <- intervalView' + one <- primItIsOne + return $ PrimImpl t $ primFun __IMPOSSIBLE__ 8 $ \ts -> + case ts of + [la,lb,bA,phi,bT,e,t,a] -> do + sphi <- reduceB' phi + case view $ unArg $ ignoreBlocking $ sphi of + IOne -> redReturn $ unArg t `apply` [argN one] + _ -> return (NoReduction $ map notReduced [la,lb,bA] ++ [reduced sphi] ++ map notReduced [bT,e,t,a]) + _ -> __IMPOSSIBLE__ + +prim_unglue' :: TCM PrimitiveImpl +prim_unglue' = do + requireCubical + t <- runNamesT [] $ + (hPi' "la" (el $ cl primLevel) $ \ la -> + hPi' "lb" (el $ cl primLevel) $ \ lb -> + hPi' "A" (sort . tmSort <$> la) $ \ a -> + hPi' "φ" (elInf $ cl primInterval) $ \ φ -> + hPi' "T" (pPi' "o" φ $ \ o -> el' (cl primLevelSuc <@> lb) (Sort . tmSort <$> lb)) $ \ t -> + hPi' "e" (pPi' "o" φ $ \ o -> el' (cl primLevelMax <@> la <@> lb) $ cl primEquiv <#> lb <#> la <@> (t <@> o) <@> a) $ \ e -> + (el' lb (cl primGlue <#> la <#> lb <@> a <#> φ <@> t <@> e)) --> el' la a) + view <- intervalView' + one <- primItIsOne + mGlue <- getPrimitiveName' builtinGlue + mglue <- getPrimitiveName' builtin_glue + mtransp <- getPrimitiveName' builtinTrans + mhcomp <- getPrimitiveName' builtinHComp + return $ PrimImpl t $ primFun __IMPOSSIBLE__ 7 $ \ts -> + case ts of + [la,lb,bA,phi,bT,e,b] -> do + sphi <- reduceB' phi + case view $ unArg $ ignoreBlocking $ sphi of + IOne -> do + let argOne = setRelevance Irrelevant $ argN one + tEFun <- getTerm builtin_unglue builtinEquivFun + redReturn $ tEFun `apply` [lb,la,argH $ unArg bT `apply` [argOne],bA, argN $ unArg e `apply` [argOne],b] + _ -> do + sb <- reduceB' b + let fallback sbA = return (NoReduction $ map notReduced [la,lb] ++ map reduced [sbA, sphi] ++ map notReduced [bT,e] ++ [reduced sb]) + case unArg $ ignoreBlocking $ sb of + Def q [Apply _,Apply _,Apply _,Apply _,Apply _,Apply _,Apply _,Apply a] + | Just q == mglue -> redReturn $ unArg a + Def q [Apply l,Apply bA,Apply r,Apply u0] + | Just q == mtransp -> do + sbA <- reduceB' bA + case unArg $ ignoreBlocking sbA of + Lam _ t -> do + st <- reduceB' (absBody t) + case ignoreBlocking st of + Def g es | Just [la',lb',bA',phi',bT',e'] <- allApplyElims es, Just g == mGlue -> do + redReturn . fromMaybe __IMPOSSIBLE__ =<< compGlue DoTransp r Nothing u0 (IsFam (la',lb',bA',phi',bT',e')) Eliminated + _ -> fallback (st *> sbA) + _ -> fallback sbA + Def q [Apply l,Apply bA,Apply r,Apply u,Apply u0] + | Just q == mhcomp -> do + sbA <- reduceB' bA + case unArg $ ignoreBlocking sbA of + Def g es | Just [la',lb',bA',phi',bT',e'] <- allApplyElims es, Just g == mGlue -> do + redReturn . fromMaybe __IMPOSSIBLE__ =<< compGlue DoHComp r (Just u) u0 (IsNot (la',lb',bA',phi',bT',e')) Eliminated + _ -> fallback sbA + _ -> return (NoReduction $ map notReduced [la,lb,bA] ++ [reduced sphi] ++ map notReduced [bT,e] ++ [reduced sb]) + _ -> __IMPOSSIBLE__ + + +-- TODO Andrea: keep reductions that happen under foralls? +primFaceForall' :: TCM PrimitiveImpl +primFaceForall' = do + requireCubical + t <- (elInf primInterval --> elInf primInterval) --> elInf primInterval + return $ PrimImpl t $ primFun __IMPOSSIBLE__ 1 $ \ts -> + case ts of + [phi] -> do + sphi <- reduceB' phi + case unArg $ ignoreBlocking $ sphi of + Lam _ t -> do + t <- reduce' t + case t of + NoAbs _ t -> redReturn t + Abs _ t -> maybe (return $ NoReduction [reduced sphi]) redReturn =<< toFaceMapsPrim t + _ -> return (NoReduction [reduced sphi]) + _ -> __IMPOSSIBLE__ + where + toFaceMapsPrim t = do + view <- intervalView' + unview <- intervalUnview' + us' <- decomposeInterval t + fr <- getTerm builtinFaceForall builtinFaceForall + let + v = view t + us = [ map Left (Map.toList bsm) ++ map Right ts + | (bsm,ts) <- us' + , 0 `Map.notMember` bsm + ] + fm (i,b) = if b then var (i-1) else unview (INeg (argN (var $ i-1))) + ffr t = fr `apply` [argN $ Lam defaultArgInfo $ Abs "i" t] + r = Just $ foldr (\ x r -> unview (IMax (argN x) (argN r))) (unview IZero) + (map (foldr (\ x r -> unview (IMin (argN (either fm ffr x)) (argN r))) (unview IOne)) us) + -- traceSLn "cube.forall" 20 (unlines [show v, show us', show us, show r]) $ + return $ + case us' of + [(m,[_])] | Map.null m -> Nothing + v -> r + +decomposeInterval :: HasBuiltins m => Term -> m [(Map Int Bool,[Term])] +decomposeInterval t = do + xs <- decomposeInterval' t + let isConsistent xs = all (\ xs -> Set.size xs == 1) . Map.elems $ xs -- optimize by not doing generate + filter + return [ (Map.map (head . Set.toList) bsm,ts) + | (bsm,ts) <- xs + , isConsistent bsm + ] + +decomposeInterval' :: HasBuiltins m => Term -> m [(Map Int (Set Bool),[Term])] +decomposeInterval' t = do + view <- intervalView' + unview <- intervalUnview' + let f :: IntervalView -> [[Either (Int,Bool) Term]] + -- TODO handle primIMinDep + -- TODO? handle forall + f IZero = mzero + f IOne = return [] + f (IMin x y) = do xs <- (f . view . unArg) x; ys <- (f . view . unArg) y; return (xs ++ ys) + f (IMax x y) = msum $ map (f . view . unArg) [x,y] + f (INeg x) = map (either (\ (x,y) -> Left (x,not y)) (Right . unview . INeg . argN)) <$> (f . view . unArg) x + f (OTerm (Var i [])) = return [Left (i,True)] + f (OTerm t) = return [Right t] + v = view t + return [ (bsm,ts) + | xs <- f v + , let (bs,ts) = partitionEithers xs + , let bsm = (Map.fromListWith Set.union . map (id -*- Set.singleton)) bs + ] + + +-- | Tries to @primTransp@ a whole telescope of arguments, following the rule for Σ types. +-- If a type in the telescope does not support transp, @transpTel@ throws it as an exception. +transpTel :: Abs Telescope -- Γ ⊢ i.Δ + -> Term -- Γ ⊢ φ : F -- i.Δ const on φ + -> Args -- Γ ⊢ δ : Δ[0] + -> ExceptT (Closure (Abs Type)) TCM Args -- Γ ⊢ Δ[1] +transpTel delta phi args = do + tTransp <- liftTCM primTrans + imin <- liftTCM primIMin + imax <- liftTCM primIMax + ineg <- liftTCM primINeg + let + noTranspError t = lift . throwError =<< liftTCM (buildClosure t) + bapp :: (Applicative m, Subst t a) => m (Abs a) -> m t -> m a + bapp t u = lazyAbsApp <$> t <*> u + gTransp (Just l) t phi a = pure tTransp <#> l <@> (Lam defaultArgInfo . fmap unEl <$> t) <@> phi <@> a + gTransp Nothing t phi a = do + -- Γ ⊢ i.Ξ + xi <- (open =<<) $ do + bind "i" $ \ i -> do + TelV xi _ <- (liftTCM . telView =<<) $ t `bapp` i + return xi + argnames <- do + teleArgNames . unAbs <$> xi + glamN argnames $ \ xi_args -> do + b' <- bind "i" $ \ i -> do + ti <- t `bapp` i + xin <- bind "i" $ \ i -> xi `bapp` (pure ineg <@> i) + xi_args <- xi_args + ni <- pure ineg <@> i + phi <- phi + lift $ piApplyM ti =<< trFillTel xin phi xi_args ni + axi <- do + a <- a + xif <- bind "i" $ \ i -> xi `bapp` (pure ineg <@> i) + phi <- phi + xi_args <- xi_args + lift $ apply a <$> transpTel xif phi xi_args + s <- reduce $ getSort (absBody b') + case s of + Type l -> do + l <- open $ lam_i (Level l) + b' <- open b' + axi <- open axi + gTransp (Just l) b' phi axi + Inf -> + case 0 `freeIn` (raise 1 b' `lazyAbsApp` var 0) of + False -> return axi + True -> noTranspError b' + _ -> noTranspError b' + lam_i = Lam defaultArgInfo . Abs "i" + go :: Telescope -> Term -> Args -> ExceptT (Closure (Abs Type)) TCM Args + go EmptyTel _ [] = return [] + go (ExtendTel t delta) phi (a:args) = do + -- Γ,i ⊢ t + -- Γ,i ⊢ (x : t). delta + -- Γ ⊢ a : t[0] + s <- reduce $ getSort t + -- Γ ⊢ b : t[1], Γ,i ⊢ b : t[i] + (b,bf) <- runNamesT [] $ do + l <- case s of + Inf -> return Nothing + Type l -> Just <$> open (lam_i (Level l)) + _ -> noTranspError (Abs "i" (unDom t)) + t <- open $ Abs "i" (unDom t) + [phi,a] <- mapM open [phi, unArg a] + b <- gTransp l t phi a + bf <- bind "i" $ \ i -> do + gTransp ((<$> l) $ \ l -> lam "j" $ \ j -> l <@> (pure imin <@> i <@> j)) + (bind "j" $ \ j -> t `bapp` (pure imin <@> i <@> j)) + (pure imax <@> (pure ineg <@> i) <@> phi) + a + return (b, absBody bf) + (:) (b <$ a) <$> go (lazyAbsApp delta bf) phi args + go (ExtendTel t delta) phi [] = __IMPOSSIBLE__ + go EmptyTel _ (_:_) = __IMPOSSIBLE__ + go (absBody delta) phi args + +-- | Like @transpTel@ but performing a transpFill. +trFillTel :: Abs Telescope -- Γ ⊢ i.Δ + -> Term + -> Args -- Γ ⊢ δ : Δ[0] + -> Term -- Γ ⊢ r : I + -> ExceptT (Closure (Abs Type)) TCM Args -- Γ ⊢ Δ[r] +trFillTel delta phi args r = do + imin <- liftTCM primIMin + imax <- liftTCM primIMax + ineg <- liftTCM primINeg + transpTel (Abs "j" $ raise 1 delta `lazyAbsApp` (imin `apply` (map argN [var 0, raise 1 r]))) + (imax `apply` [argN $ ineg `apply` [argN r], argN phi]) + args diff --git a/src/full/Agda/TypeChecking/ProjectionLike.hs b/src/full/Agda/TypeChecking/ProjectionLike.hs --- a/src/full/Agda/TypeChecking/ProjectionLike.hs +++ b/src/full/Agda/TypeChecking/ProjectionLike.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} -- | Dropping initial arguments (``parameters'') from a function which can be -- easily reconstructed from its principal argument. @@ -63,6 +62,8 @@ import qualified Data.Map as Map import Data.Monoid (Any(..), getAny) +import Agda.Interaction.Options + import Agda.Syntax.Abstract.Name import Agda.Syntax.Common import Agda.Syntax.Internal @@ -84,7 +85,6 @@ import Agda.Utils.Pretty ( prettyShow ) import Agda.Utils.Size -#include "undefined.h" import Agda.Utils.Impossible -- | View for a @Def f (Apply a : es)@ where @isProjection f@. @@ -133,7 +133,7 @@ -- (Also reduces projections, but they should not be there, -- since Internal is in lambda- and projection-beta-normal form.) -- -reduceProjectionLike :: Term -> TCM Term +reduceProjectionLike :: (MonadReduce m, MonadTCEnv m, HasConstInfo m) => Term -> m Term reduceProjectionLike v = do -- Andreas, 2013-11-01 make sure we do not reduce a constructor -- because that could be folded back into a literal by reduce. @@ -156,10 +156,11 @@ -- No precondition. -- Preserves constructorForm, since it really does only something -- on (applications of) projection-like functions. -elimView :: Bool -> Term -> TCM Term +elimView + :: (MonadReduce m, MonadTCEnv m, HasConstInfo m) + => Bool -> Term -> m Term elimView loneProjToLambda v = do reportSDoc "tc.conv.elim" 30 $ "elimView of " <+> prettyTCM v - reportSLn "tc.conv.elim" 50 $ "v = " ++ show v v <- reduceProjectionLike v reportSDoc "tc.conv.elim" 40 $ "elimView (projections reduced) of " <+> prettyTCM v @@ -204,7 +205,7 @@ -- is inferable (neutral). Thus: -- -- a. @f@ cannot have absurd clauses (which are stuck even if the principal --- argument is a constructor) +-- argument is a constructor). -- -- b. @f@ cannot be abstract as it does not reduce outside abstract blocks -- (always stuck). @@ -213,8 +214,14 @@ -- -- d. @f@ cannot match deeply. -- --- e. @f@s body may not mention the paramters. +-- e. @f@s body may not mention the parameters. -- +-- f. A rhs of @f@ cannot be a record expression, since this will be +-- translated to copatterns by recordExpressionsToCopatterns. +-- Thus, an application of @f@ waiting for a projection +-- can be stuck even when the principal argument is a constructor. +-- +-- -- For internal reasons: -- -- 3. @f@ cannot be constructor headed @@ -226,7 +233,7 @@ -- Examples for these reasons: see test/Succeed/NotProjectionLike.agda makeProjection :: QName -> TCM () -makeProjection x = -- if True then return () else do +makeProjection x = whenM (optProjectionLike <$> pragmaOptions) $ do inTopContext $ do reportSLn "tc.proj.like" 70 $ "Considering " ++ prettyShow x ++ " for projection likeness" defn <- getConstInfo x @@ -239,6 +246,8 @@ Function{funClauses = cls} | any (isNothing . clauseBody) cls -> reportSLn "tc.proj.like" 30 $ " projection-like functions cannot have absurd clauses" + | any (maybe __IMPOSSIBLE__ isRecordExpression . clauseBody) cls -> + reportSLn "tc.proj.like" 30 $ " projection-like functions cannot have record rhss" -- Constructor-headed functions can't be projection-like (at the moment). The reason -- for this is that invoking constructor-headedness will circumvent the inference of -- the dropped arguments. @@ -246,7 +255,7 @@ -- outside the abstract block. def@Function{funProjection = Nothing, funClauses = cls, funSplitTree = st0, funCompiled = cc0, funInv = NotInjective, - funMutual = Just [], -- Andreas, 2012-09-28: only consider non-mutual funs (or those whose recursion status has not yet been determined) + funMutual = Just [], -- Andreas, 2012-09-28: only consider non-mutual funs funAbstr = ConcreteDef} -> do ps0 <- filterM validProj $ candidateArgs [] t reportSLn "tc.proj.like" 30 $ if null ps0 then " no candidates found" @@ -262,16 +271,20 @@ , nest 2 $ "clauses =" vcat (map pretty cls) ] Just (d, n) -> do -- Yes, we are projection-like! - reportSDoc "tc.proj.like" 10 $ sep + reportSDoc "tc.proj.like" 10 $ vcat [ prettyTCM x <+> " : " <+> prettyTCM t - , text $ " is projection like in argument " ++ show n ++ " for type " ++ show d + , nest 2 $ sep + [ "is projection like in argument", prettyTCM n, "for type", prettyTCM (unArg d) ] ] __CRASH_WHEN__ "tc.proj.like.crash" 1000 let cls' = map (dropArgs n) cls cc = dropArgs n cc0 st = dropArgs n st0 - reportSLn "tc.proj.like" 60 $ " rewrote clauses to\n " ++ show cc + reportSLn "tc.proj.like" 60 $ unlines + [ " rewrote clauses to" + , " " ++ show cc + ] -- Andreas, 2013-10-20 build parameter dropping function let pIndex = n + 1 @@ -315,6 +328,14 @@ Primitive{} -> reportSLn "tc.proj.like" 30 $ " not a function, but Primitive" Record{} -> reportSLn "tc.proj.like" 30 $ " not a function, but Record" where + -- | If the user wrote a record expression as rhs, + -- the recordExpressionsToCopatterns translation will turn this into copatterns, + -- violating the conditions of projection-likeness. + -- Andreas, 2019-07-11, issue #3843. + isRecordExpression :: Term -> Bool + isRecordExpression = \case + Con _ ConORec _ -> True + _ -> False -- @validProj (d,n)@ checks whether the head @d@ of the type of the -- @n@th argument is injective in all args (i.d. being name of data/record/axiom). validProj :: (Arg QName, Int) -> TCM Bool diff --git a/src/full/Agda/TypeChecking/Quote.hs b/src/full/Agda/TypeChecking/Quote.hs --- a/src/full/Agda/TypeChecking/Quote.hs +++ b/src/full/Agda/TypeChecking/Quote.hs @@ -1,47 +1,28 @@ -{-# LANGUAGE CPP #-} module Agda.TypeChecking.Quote where import Control.Arrow ((&&&)) import Control.Monad -import Control.Monad.State (runState, get, put) -import Control.Monad.Reader (asks) -import Control.Monad.Writer (execWriterT, tell) -import Control.Monad.Trans (lift) -import Data.Char import Data.Maybe (fromMaybe) -import Data.Traversable (traverse) import Agda.Syntax.Common import Agda.Syntax.Internal as I import Agda.Syntax.Internal.Pattern ( dbPatPerm' ) import Agda.Syntax.Literal import Agda.Syntax.Position -import Agda.Syntax.Translation.InternalToAbstract import Agda.TypeChecking.CompiledClause import Agda.TypeChecking.DropArgs -import Agda.TypeChecking.Free import Agda.TypeChecking.Level import Agda.TypeChecking.Monad import Agda.TypeChecking.Monad.Builtin -import Agda.TypeChecking.Pretty -import Agda.TypeChecking.Reduce -import Agda.TypeChecking.Reduce.Monad import Agda.TypeChecking.Substitute -import Agda.TypeChecking.Telescope -import Agda.Utils.Except import Agda.Utils.Impossible -import Agda.Utils.Monad ( ifM ) -import Agda.Utils.Permutation ( Permutation(Perm), compactP, reverseP ) -import Agda.Utils.VarSet (VarSet) -import qualified Agda.Utils.VarSet as Set import Agda.Utils.FileName import Agda.Utils.Size -#include "undefined.h" data QuotingKit = QuotingKit { quoteTermWithKit :: Term -> ReduceM Term @@ -142,9 +123,8 @@ -- We keep no ranges in the quoted term, so the equality on terms -- is only on the structure. quoteSortLevelTerm :: Level -> ReduceM Term - quoteSortLevelTerm (Max []) = setLit !@! Lit (LitNat noRange 0) - quoteSortLevelTerm (Max [ClosedLevel n]) = setLit !@! Lit (LitNat noRange n) - quoteSortLevelTerm l = set !@ quoteTerm (unlevelWithKit lkit l) + quoteSortLevelTerm (ClosedLevel n) = setLit !@! Lit (LitNat noRange n) + quoteSortLevelTerm l = set !@ quoteTerm (unlevelWithKit lkit l) quoteSort :: Sort -> ReduceM Term quoteSort (Type t) = quoteSortLevelTerm t @@ -152,10 +132,11 @@ quoteSort Inf = pure unsupportedSort quoteSort SizeUniv = pure unsupportedSort quoteSort PiSort{} = pure unsupportedSort - quoteSort UnivSort{} = pure unsupportedSort + quoteSort FunSort{} = pure unsupportedSort + quoteSort UnivSort{} = pure unsupportedSort quoteSort (MetaS x es) = quoteTerm $ MetaV x es - quoteSort (DefS d es) = quoteTerm $ Def d es - quoteSort (DummyS s) =__IMPOSSIBLE_VERBOSE__ s + quoteSort (DefS d es) = quoteTerm $ Def d es + quoteSort (DummyS s) =__IMPOSSIBLE_VERBOSE__ s quoteType :: Type -> ReduceM Term quoteType (El _ t) = quoteTerm t @@ -172,10 +153,10 @@ quotePat (VarP o x) = varP !@! quoteString (dbPatVarName x) quotePat (DotP _ _) = pure dotP quotePat (ConP c _ ps) = conP !@ quoteQName (conName c) @@ quotePats ps - quotePat (LitP l) = litP !@ quoteLit l + quotePat (LitP _ l) = litP !@ quoteLit l quotePat (ProjP _ x) = projP !@ quoteQName x - quotePat (IApplyP o t u x) = pure unsupported - quotePat DefP{} = pure unsupported + quotePat (IApplyP o t u x) = pure unsupported + quotePat DefP{} = pure unsupported quoteClause :: Clause -> ReduceM Term quoteClause cl@Clause{namedClausePats = ps, clauseBody = body} = @@ -187,14 +168,13 @@ in normalClause !@ quotePats ps @@ quoteTerm v list :: [ReduceM Term] -> ReduceM Term - list [] = pure nil - list (a : as) = cons !@ a @@ list as + list = foldr (\ a as -> cons !@ a @@ as) (pure nil) quoteList :: (a -> ReduceM Term) -> [a] -> ReduceM Term quoteList q xs = list (map q xs) - quoteDom :: (Type -> ReduceM Term) -> Dom Type -> ReduceM Term - quoteDom q (Dom{domInfo = info, unDom = t}) = arg !@ quoteArgInfo info @@ q t + quoteDom :: (a -> ReduceM Term) -> Dom a -> ReduceM Term + quoteDom q Dom{domInfo = info, unDom = t} = arg !@ quoteArgInfo info @@ q t quoteAbs :: Subst t a => (a -> ReduceM Term) -> Abs a -> ReduceM Term quoteAbs q (Abs s t) = abs !@! quoteString s @@ q t @@ -250,7 +230,7 @@ MetaV x es -> meta !@! quoteMeta currentFile x @@ quoteArgs vs where vs = fromMaybe __IMPOSSIBLE__ $ allApplyElims es DontCare{} -> pure unsupported -- could be exposed at some point but we have to take care - Dummy s -> __IMPOSSIBLE_VERBOSE__ s + Dummy s _ -> __IMPOSSIBLE_VERBOSE__ s defParameters :: Definition -> [ReduceM Term] defParameters def = map par hiding @@ -273,7 +253,7 @@ Record{recConHead = c, recFields = fs} -> agdaDefinitionRecordDef !@! quoteName (conName c) - @@ quoteList (quoteArg (pure . quoteName)) fs + @@ quoteList (quoteDom (pure . quoteName)) fs Axiom{} -> pure agdaDefinitionPostulate DataOrRecSig{} -> pure agdaDefinitionPostulate GeneralizableVar{} -> pure agdaDefinitionPostulate -- TODO: reflect generalizable vars diff --git a/src/full/Agda/TypeChecking/ReconstructParameters.hs b/src/full/Agda/TypeChecking/ReconstructParameters.hs --- a/src/full/Agda/TypeChecking/ReconstructParameters.hs +++ b/src/full/Agda/TypeChecking/ReconstructParameters.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} -- | Reconstruct dropped parameters from constructors. Used by -- with-abstraction to avoid ill-typed abstractions (#745). Note that the @@ -7,8 +6,6 @@ module Agda.TypeChecking.ReconstructParameters where -import Data.Traversable - import Agda.Syntax.Common import Agda.Syntax.Internal import Agda.Syntax.Internal.Generic @@ -16,14 +13,12 @@ import Agda.TypeChecking.Monad import Agda.TypeChecking.CheckInternal import Agda.TypeChecking.Substitute -import Agda.TypeChecking.Reduce import Agda.TypeChecking.Telescope import Agda.TypeChecking.Pretty import Agda.Utils.Size import Agda.Utils.Impossible -#include "undefined.h" reconstructParametersInType :: Type -> TCM Type reconstructParametersInType a = @@ -48,7 +43,7 @@ reportSDoc "tc.with.reconstruct" 30 $ sep [ "reconstructing parameters in" , nest 2 $ sep [ prettyTCM v <+> ":", nest 2 $ prettyTCM a ] ] - v <- checkInternal' (defaultAction{ postAction = reconstruct }) v a + v <- checkInternal' (defaultAction{ postAction = reconstruct }) v CmpLeq a reportSDoc "tc.with.reconstruct" 30 $ nest 2 $ "-->" <+> prettyTCM v return v diff --git a/src/full/Agda/TypeChecking/RecordPatterns.hs b/src/full/Agda/TypeChecking/RecordPatterns.hs --- a/src/full/Agda/TypeChecking/RecordPatterns.hs +++ b/src/full/Agda/TypeChecking/RecordPatterns.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} -- | Code which replaces pattern matching on record constructors with @@ -19,16 +18,13 @@ import qualified Data.List as List import Data.Maybe import qualified Data.Map as Map -import qualified Data.Traversable import Agda.Syntax.Common import Agda.Syntax.Internal as I import Agda.Syntax.Internal.Pattern as I -import Agda.Syntax.Literal import Agda.TypeChecking.CompiledClause import Agda.TypeChecking.Coverage.SplitTree -import Agda.TypeChecking.EtaContract import Agda.TypeChecking.Datatypes import Agda.TypeChecking.Monad import Agda.TypeChecking.Pretty hiding (pretty) @@ -41,15 +37,13 @@ import Agda.Utils.Either import Agda.Utils.Functor -import Agda.Utils.List -import qualified Agda.Utils.Map as Map import Agda.Utils.Maybe import Agda.Utils.Permutation hiding (dropFrom) import Agda.Utils.Pretty (Pretty(..)) import qualified Agda.Utils.Pretty as P import Agda.Utils.Size +import Agda.Utils.Update (MonadChange, tellDirty) -#include "undefined.h" import Agda.Utils.Impossible --------------------------------------------------------------------------- @@ -69,7 +63,7 @@ LitP{} -> typeError $ ShouldBeRecordPattern p DotP{} -> typeError $ ShouldBeRecordPattern p ConP c ci ps -> do - whenNothing (conPRecord ci) $ + unless (conPRecord ci) $ typeError $ ShouldBeRecordPattern p let t = unArg $ fromMaybe __IMPOSSIBLE__ $ conPType ci reportSDoc "tc.rec" 45 $ vcat @@ -83,7 +77,7 @@ IApplyP{} -> typeError $ ShouldBeRecordPattern p DefP{} -> typeError $ ShouldBeRecordPattern p where - proj p = (`applyE` [Proj ProjSystem $ unArg p]) + proj p = (`applyE` [Proj ProjSystem $ unDom p]) comb :: (Term -> Term) -> DeBruijnPattern -> TCM [Term -> Term] comb prj p = map (\ f -> f . prj) <$> recordPatternToProjections p @@ -97,11 +91,12 @@ conjColumns :: [[Bool]] -> [Bool] conjColumns = foldl1 (zipWith (&&)) --- | @insertColumn i a m@ inserts a column before the @i@th column in --- matrix @m@ and fills it with value @a@. -insertColumn :: Int -> a -> [[a]] -> [[a]] -insertColumn i a rows = map ins rows where - ins row = let (init, last) = splitAt i row in init ++ a : last +-- UNUSED Liang-Ting 2019-07-16 +---- | @insertColumn i a m@ inserts a column before the @i@th column in +---- matrix @m@ and fills it with value @a@. +--insertColumn :: Int -> a -> [[a]] -> [[a]] +--insertColumn i a rows = map ins rows where +-- ins row = let (init, last) = splitAt i row in init ++ a : last {- UNUSED -- | @cutColumn i m@ removes the @i@th column from matrix @m@. @@ -115,13 +110,14 @@ cutColumns i n rows = unzip (map (cutSublist i n) rows) -} --- | @cutSublist i n xs = (xs', ys, xs'')@ cuts out a sublist @ys@ --- of width @n@ from @xs@, starting at column @i@. -cutSublist :: Int -> Int -> [a] -> ([a], [a], [a]) -cutSublist i n row = - let (init, rest) = splitAt i row - (mid , last) = splitAt n rest - in (init, mid, last) +-- UNUSED Liang-Ting 2019-07-16 +---- | @cutSublist i n xs = (xs', ys, xs'')@ cuts out a sublist @ys@ +---- of width @n@ from @xs@, starting at column @i@. +--cutSublist :: Int -> Int -> [a] -> ([a], [a], [a]) +--cutSublist i n row = +-- let (init, rest) = splitAt i row +-- (mid , last) = splitAt n rest +-- in (init, mid, last) getEtaAndArity :: SplitTag -> TCM (Bool, Nat) getEtaAndArity (SplitCon c) = @@ -131,8 +127,10 @@ getEtaAndArity (SplitLit l) = return (False, 0) getEtaAndArity SplitCatchall = return (False, 1) -translateCompiledClauses :: CompiledClauses -> TCM CompiledClauses -translateCompiledClauses cc = do +translateCompiledClauses + :: forall m. (HasConstInfo m, MonadChange m) + => CompiledClauses -> m CompiledClauses +translateCompiledClauses cc = ignoreAbstractMode $ do reportSDoc "tc.cc.record" 20 $ vcat [ "translate record patterns in compiled clauses" , nest 2 $ return $ pretty cc @@ -150,7 +148,7 @@ return cc where - loop :: CompiledClauses -> TCM (CompiledClauses) + loop :: CompiledClauses -> m (CompiledClauses) loop cc = case cc of Fail -> return cc Done{} -> return cc @@ -158,7 +156,7 @@ loops :: Arg Int -- ^ split variable -> Case CompiledClauses -- ^ original split tree - -> TCM CompiledClauses + -> m CompiledClauses loops i cs@Branches{ projPatterns = comatch , conBranches = conMap , etaBranch = eta @@ -181,7 +179,7 @@ [(c, b)] | not comatch -> -- possible eta-match getConstructorInfo c >>= \ case RecordCon YesEta fs -> - let ch = ConHead c Inductive fs in + let ch = ConHead c Inductive (map argFromDom fs) in yesEtaCase ch b _ -> noEtaCase _ -> noEtaCase @@ -210,136 +208,145 @@ -- | Transform definitions returning record expressions to use copatterns -- instead. This prevents terms from blowing up when reduced. -recordExpressionsToCopatterns :: CompiledClauses -> TCM CompiledClauses -recordExpressionsToCopatterns cc = - case cc of +recordExpressionsToCopatterns + :: (HasConstInfo m, MonadChange m) + => CompiledClauses + -> m CompiledClauses +recordExpressionsToCopatterns = \case Case i bs -> Case i <$> traverse recordExpressionsToCopatterns bs - Fail -> return cc - Done xs (Con c i es) | i == ConORec -> do -- don't translate if using the record constructor - Constructor{conData = d, conArity = ar} <- theDef <$> getConstInfo (conName c) - ddef <- theDef <$> getConstInfo d + cc@Fail -> return cc + cc@(Done xs (Con c ConORec es)) -> do -- don't translate if using the record /constructor/ + let vs = map unArg $ fromMaybe __IMPOSSIBLE__ $ allApplyElims es + Constructor{ conArity = ar } <- theDef <$> getConstInfo (conName c) irrProj <- optIrrelevantProjections <$> pragmaOptions getConstructorInfo (conName c) >>= \ case RecordCon YesEta fs | ar <- length fs, ar > 0, -- only for eta-records with at least one field - length es == ar, -- where the constructor application is saturated + length vs == ar, -- where the constructor application is saturated irrProj || not (any isIrrelevant fs) -> do -- and irrelevant projections (if any) are allowed - let body (Apply v) = WithArity 0 $ Done xs (unArg v) - body _ = __IMPOSSIBLE__ - bs = Branches True (Map.fromList $ zip (map unArg fs) (map body es)) - Nothing Map.empty Nothing Nothing False - -- translate new cases recursively (there might be nested record expressions) - Case (defaultArg $ length xs) <$> traverse recordExpressionsToCopatterns bs + tellDirty + Case (defaultArg $ length xs) <$> do + -- translate new cases recursively (there might be nested record expressions) + traverse recordExpressionsToCopatterns $ Branches + { projPatterns = True + , conBranches = Map.fromList $ + zipWith (\ f v -> (unDom f, WithArity 0 $ Done xs v)) fs vs + , etaBranch = Nothing + , litBranches = Map.empty + , catchAllBranch = Nothing + , fallThrough = Nothing + , lazyMatch = False + } _ -> return cc - Done{} -> return cc + cc@Done{} -> return cc --- | @replaceByProjections i projs cc@ replaces variables @i..i+n-1@ --- (counted from left) by projections @projs_1 i .. projs_n i@. +-- UNUSED Liang-Ting Chen 2019-07-16 +---- | @replaceByProjections i projs cc@ replaces variables @i..i+n-1@ +---- (counted from left) by projections @projs_1 i .. projs_n i@. +---- +---- If @n==0@, we matched on a zero-field record, which means that +---- we are actually introduce a new variable, increasing split +---- positions greater or equal to @i@ by one. +---- Otherwise, we have to lower +---- +--replaceByProjections :: Arg Int -> [QName] -> CompiledClauses -> CompiledClauses +--replaceByProjections (Arg ai i) projs cc = +-- let n = length projs -- --- If @n==0@, we matched on a zero-field record, which means that --- we are actually introduce a new variable, increasing split --- positions greater or equal to @i@ by one. --- Otherwise, we have to lower +-- loop :: Int -> CompiledClauses -> CompiledClauses +-- loop i cc = case cc of +-- Case j cs -- -replaceByProjections :: Arg Int -> [QName] -> CompiledClauses -> CompiledClauses -replaceByProjections (Arg ai i) projs cc = - let n = length projs - - loop :: Int -> CompiledClauses -> CompiledClauses - loop i cc = case cc of - Case j cs - - -- if j < i, we leave j untouched, but we increase i by the number - -- of variables replacing j in the branches - | unArg j < i -> Case j $ loops i cs - - -- if j >= i then we shrink j by (n-1) - | otherwise -> Case (j <&> \ k -> k - (n-1)) $ fmap (loop i) cs - - Done xs v -> - -- we have to delete (n-1) variables from xs - -- and instantiate v suitably with the projections - let (xs0,xs1,xs2) = cutSublist i n xs - names | null xs1 = ["r"] - | otherwise = map unArg xs1 - x = Arg ai $ foldr1 appendArgNames names - xs' = xs0 ++ x : xs2 - us = map (\ p -> Var 0 [Proj ProjSystem p]) (reverse projs) - -- go from level (i + n - 1) to index (subtract from |xs|-1) - index = length xs - (i + n) - in Done xs' $ applySubst (liftS (length xs2) $ us ++# raiseS 1) v - -- The body is NOT guarded by lambdas! - -- WRONG: underLambdas i (flip apply) (map defaultArg us) v - - Fail -> Fail - - loops :: Int -> Case CompiledClauses -> Case CompiledClauses - loops i bs@Branches{ conBranches = conMap - , litBranches = litMap - , catchAllBranch = catchAll } = - bs{ conBranches = fmap (\ (WithArity n c) -> WithArity n $ loop (i + n - 1) c) conMap - , litBranches = fmap (loop (i - 1)) litMap - , catchAllBranch = fmap (loop i) catchAll - } - in loop i cc +-- -- if j < i, we leave j untouched, but we increase i by the number +-- -- of variables replacing j in the branches +-- | unArg j < i -> Case j $ loops i cs +-- +-- -- if j >= i then we shrink j by (n-1) +-- | otherwise -> Case (j <&> \ k -> k - (n-1)) $ fmap (loop i) cs +-- +-- Done xs v -> +-- -- we have to delete (n-1) variables from xs +-- -- and instantiate v suitably with the projections +-- let (xs0,xs1,xs2) = cutSublist i n xs +-- names | null xs1 = ["r"] +-- | otherwise = map unArg xs1 +-- x = Arg ai $ foldr1 appendArgNames names +-- xs' = xs0 ++ x : xs2 +-- us = map (\ p -> Var 0 [Proj ProjSystem p]) (reverse projs) +-- -- go from level (i + n - 1) to index (subtract from |xs|-1) +-- index = length xs - (i + n) +-- in Done xs' $ applySubst (liftS (length xs2) $ us ++# raiseS 1) v +-- -- The body is NOT guarded by lambdas! +-- -- WRONG: underLambdas i (flip apply) (map defaultArg us) v +-- +-- Fail -> Fail +-- +-- loops :: Int -> Case CompiledClauses -> Case CompiledClauses +-- loops i bs@Branches{ conBranches = conMap +-- , litBranches = litMap +-- , catchAllBranch = catchAll } = +-- bs{ conBranches = fmap (\ (WithArity n c) -> WithArity n $ loop (i + n - 1) c) conMap +-- , litBranches = fmap (loop (i - 1)) litMap +-- , catchAllBranch = fmap (loop i) catchAll +-- } +-- in loop i cc --- | Check if a split is on a record constructor, and return the projections --- if yes. -isRecordCase :: Case c -> TCM (Maybe ([QName], c)) -isRecordCase (Branches { conBranches = conMap - , litBranches = litMap - , catchAllBranch = Nothing }) - | Map.null litMap - , [(con, WithArity _ br)] <- Map.toList conMap = do - isRC <- isRecordConstructor con - case isRC of - Just (r, Record { recFields = fs }) -> return $ Just (map unArg fs, br) - Just (r, _) -> __IMPOSSIBLE__ - Nothing -> return Nothing -isRecordCase _ = return Nothing +-- UNUSED Liang-Ting 2019-07-16 +---- | Check if a split is on a record constructor, and return the projections +---- if yes. +--isRecordCase :: Case c -> TCM (Maybe ([QName], c)) +--isRecordCase (Branches { conBranches = conMap +-- , litBranches = litMap +-- , catchAllBranch = Nothing }) +-- | Map.null litMap +-- , [(con, WithArity _ br)] <- Map.toList conMap = do +-- isRC <- isRecordConstructor con +-- case isRC of +-- Just (r, Record { recFields = fs }) -> return $ Just (map unArg fs, br) +-- Just (r, _) -> __IMPOSSIBLE__ +-- Nothing -> return Nothing +--isRecordCase _ = return Nothing --------------------------------------------------------------------------- -- * Record pattern translation for split trees --------------------------------------------------------------------------- - --- | Split tree annotation. -data RecordSplitNode = RecordSplitNode - { splitTag :: SplitTag - -- ^ Constructor name/literal for this branch. - , splitArity :: Int -- ^ Arity of the constructor. - , splitRecordPattern :: Bool -- ^ Should we translate this split away? - } +--UNUSED Liang-Ting Chen 2019-07-16 +---- | Split tree annotation. +--data RecordSplitNode = RecordSplitNode +-- { _splitTag :: SplitTag -- ^ Constructor name/literal for this branch. +-- , _splitArity :: Int -- ^ Arity of the constructor. +-- , _splitRecordPattern :: Bool -- ^ Should we translate this split away? +-- } -- | Split tree annotated for record pattern translation. -type RecordSplitTree = SplitTree' RecordSplitNode -type RecordSplitTrees = SplitTrees' RecordSplitNode - - - --- | Bottom-up procedure to annotate split tree. -recordSplitTree :: SplitTree -> TCM RecordSplitTree -recordSplitTree t = snd <$> loop t - where - - loop :: SplitTree -> TCM ([Bool], RecordSplitTree) - loop t = case t of - SplittingDone n -> return (replicate n True, SplittingDone n) - SplitAt i ts -> do - (xs, ts) <- loops (unArg i) ts - return (xs, SplitAt i ts) +--type RecordSplitTree = SplitTree' RecordSplitNode +--type RecordSplitTrees = SplitTrees' RecordSplitNode - loops :: Int -> SplitTrees -> TCM ([Bool], RecordSplitTrees) - loops i ts = do - (xss, ts) <- unzip <$> do - forM ts $ \ (c, t) -> do - (xs, t) <- loop t - (isRC, n) <- getEtaAndArity c - let (xs0, rest) = splitAt i xs - (xs1, xs2) = splitAt n rest - x = isRC && and xs1 - xs' = xs0 ++ x : xs2 - return (xs, (RecordSplitNode c n x, t)) - return (foldl1 (zipWith (&&)) xss, ts) +--UNUSED Liang-Ting Chen 2019-07-16 +---- | Bottom-up procedure to annotate split tree. +--recordSplitTree :: SplitTree -> TCM RecordSplitTree +--recordSplitTree t = snd <$> loop t +-- where +-- +-- loop :: SplitTree -> TCM ([Bool], RecordSplitTree) +-- loop t = case t of +-- SplittingDone n -> return (replicate n True, SplittingDone n) +-- SplitAt i ts -> do +-- (xs, ts) <- loops (unArg i) ts +-- return (xs, SplitAt i ts) +-- +-- loops :: Int -> SplitTrees -> TCM ([Bool], RecordSplitTrees) +-- loops i ts = do +-- (xss, ts) <- unzip <$> do +-- forM ts $ \ (c, t) -> do +-- (xs, t) <- loop t +-- (isRC, n) <- getEtaAndArity c +-- let (xs0, rest) = splitAt i xs +-- (xs1, xs2) = splitAt n rest +-- x = isRC && and xs1 +-- xs' = xs0 ++ x : xs2 +-- return (xs, (RecordSplitNode c n x, t)) +-- return (foldl1 (zipWith (&&)) xss, ts) -- | Bottom-up procedure to record-pattern-translate split tree. translateSplitTree :: SplitTree -> TCM SplitTree @@ -355,7 +362,7 @@ SplittingDone n -> -- start with n virgin variables return (replicate n True, SplittingDone n) - SplitAt i ts -> do + SplitAt i lz ts -> do (x, xs, ts) <- loops (unArg i) ts -- if we case on record constructor, drop case let t' = if x then @@ -363,7 +370,7 @@ [(c,t)] -> t _ -> __IMPOSSIBLE__ -- else retain case - else SplitAt i ts + else SplitAt i lz ts return (xs, t') -- @loops i ts = return (x, xs, ts')@ cf. @loop@ @@ -404,9 +411,9 @@ instance DropFrom (SplitTree' c) where dropFrom i n t = case t of SplittingDone m -> SplittingDone (m - n) - SplitAt x@(Arg ai j) ts - | j >= i + n -> SplitAt (Arg ai $ j - n) $ dropFrom i n ts - | j < i -> SplitAt x $ dropFrom i n ts + SplitAt x@(Arg ai j) lz ts + | j >= i + n -> SplitAt (Arg ai $ j - n) lz $ dropFrom i n ts + | j < i -> SplitAt x lz $ dropFrom i n ts | otherwise -> __IMPOSSIBLE__ instance DropFrom (c, SplitTree' c) where @@ -555,7 +562,7 @@ ] reportSDoc "tc.lhs.recpat" 10 $ - escapeContext (size $ clauseTel clause) $ vcat + escapeContext __IMPOSSIBLE__ (size $ clauseTel clause) $ vcat [ "Translated clause:" , nest 2 $ vcat [ "delta =" <+> prettyTCM (clauseTel c) @@ -579,7 +586,7 @@ newtype RecPatM a = RecPatM (TCMT (ReaderT Nat (StateT Nat IO)) a) deriving (Functor, Applicative, Monad, - MonadIO, MonadTCM, HasOptions, MonadDebug, + MonadIO, MonadTCM, HasOptions, MonadTCEnv, MonadTCState) -- | Runs a computation in the 'RecPatM' monad. @@ -621,8 +628,8 @@ instance Pretty (Kind -> Nat) where pretty f = - "(VarPat:" P.<+> P.text (show $ f VarPat) P.<+> - "DotPat:" P.<+> P.text (show $ f DotPat) P.<> ")" + ("(VarPat:" P.<+> P.text (show $ f VarPat) P.<+> + "DotPat:" P.<+> P.text (show $ f DotPat)) <> ")" instance PrettyTCM (Kind -> Nat) where prettyTCM = return . pretty @@ -704,7 +711,7 @@ translatePattern :: Pattern -> RecPatM (Pattern, [Term], Changes) translatePattern p@(ConP c ci ps) -- Andreas, 2015-05-28 only translate implicit record patterns - | Just PatOSystem <- conPRecord ci = do + | conPRecord ci , PatOSystem <- patOrigin (conPInfo ci) = do r <- recordTree p case r of Left r -> r @@ -744,7 +751,7 @@ Pattern -> RecPatM (Either (RecPatM (Pattern, [Term], Changes)) RecordTree) -- Andreas, 2015-05-28 only translate implicit record patterns -recordTree p@(ConP c ci ps) | Just PatOSystem <- conPRecord ci = do +recordTree p@(ConP c ci ps) | conPRecord ci , PatOSystem <- patOrigin (conPInfo ci) = do let t = fromMaybe __IMPOSSIBLE__ $ conPType ci rs <- mapM (recordTree . namedArg) ps case allRight rs of @@ -763,7 +770,7 @@ -- The content of an @Arg@ might not be reduced (if @Arg@ is @Irrelevant@). fields <- getRecordTypeFields =<< reduce (unArg t) -- let proj p = \x -> Def (unArg p) [defaultArg x] - let proj p = (`applyE` [Proj ProjSystem $ unArg p]) + let proj p = (`applyE` [Proj ProjSystem $ unDom p]) return $ Right $ RecCon t $ zip (map proj fields) ts recordTree p@(ConP _ ci _) = return $ Left $ translatePattern p recordTree p@DefP{} = return $ Left $ translatePattern p diff --git a/src/full/Agda/TypeChecking/Records.hs b/src/full/Agda/TypeChecking/Records.hs --- a/src/full/Agda/TypeChecking/Records.hs +++ b/src/full/Agda/TypeChecking/Records.hs @@ -1,51 +1,45 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE NondecreasingIndentation #-} module Agda.TypeChecking.Records where -#if MIN_VERSION_base(4,11,0) -import Prelude hiding ((<>)) -#endif - import Control.Monad -import Control.Monad.Reader import Control.Monad.Trans.Maybe -import Data.Function import qualified Data.List as List import Data.Maybe import qualified Data.Set as Set +import qualified Data.HashMap.Strict as HMap import Data.Traversable (traverse) import Agda.Syntax.Common import qualified Agda.Syntax.Concrete.Name as C -import Agda.Syntax.Concrete (FieldAssignment'(..), nameFieldA) +import Agda.Syntax.Concrete (FieldAssignment'(..)) import Agda.Syntax.Abstract.Name import Agda.Syntax.Internal as I import Agda.Syntax.Position +import Agda.Syntax.Scope.Base (isNameInScope) import Agda.TypeChecking.Irrelevance import Agda.TypeChecking.Monad +import Agda.TypeChecking.Monad.Builtin import Agda.TypeChecking.Pretty import Agda.TypeChecking.Reduce -import Agda.TypeChecking.Reduce.Monad () +import Agda.TypeChecking.Reduce.Monad () --instance only import Agda.TypeChecking.Substitute import Agda.TypeChecking.Telescope import {-# SOURCE #-} Agda.TypeChecking.ProjectionLike (eligibleForProjectionLike) import Agda.Utils.Either +import Agda.Utils.Except import Agda.Utils.Functor (for, ($>)) -import Agda.Utils.Lens import Agda.Utils.List import Agda.Utils.Maybe import Agda.Utils.Monad import Agda.Utils.Null -import qualified Agda.Utils.HashMap as HMap import Agda.Utils.Pretty (prettyShow) import Agda.Utils.Size -#include "undefined.h" import Agda.Utils.Impossible mkCon :: ConHead -> ConInfo -> Args -> Term @@ -65,13 +59,13 @@ , " official fields: " <+> sep (map pretty xs) , " provided fields: " <+> sep (map pretty ys) ] - unlessNull duplicate $ typeError . DuplicateFields . List.nub + unlessNull duplicate $ typeError . DuplicateFields . nubOn id unlessNull alien $ typeError . TooManyFields r missing return $ for axs $ \ ax -> fromMaybe (fill ax) $ lookup (unArg ax) fs where xs = map unArg axs -- official fields (accord. record type) ys = map fst fs -- provided fields - duplicate = ys List.\\ List.nub ys -- duplicate fields + duplicate = duplicates ys -- duplicate fields alien = ys List.\\ xs -- spurious fields missing = xs List.\\ ys -- missing fields @@ -107,7 +101,7 @@ nameIfHidden :: Arg C.Name -> c -> Named_ c nameIfHidden ax | visible ax = unnamed - | otherwise = named $ Ranged (getRange ax) $ prettyShow $ unArg ax + | otherwise = named $ WithOrigin Inserted $ Ranged (getRange ax) $ prettyShow $ unArg ax -- | The name of the module corresponding to a record. recordModule :: QName -> ModuleName @@ -115,7 +109,7 @@ -- | Get the definition for a record. Throws an exception if the name -- does not refer to a record or the record is abstract. -getRecordDef :: (MonadTCM m, HasConstInfo m) => QName -> m Defn +getRecordDef :: (HasConstInfo m, ReadTCState m, MonadError TCErr m) => QName -> m Defn getRecordDef r = maybe err return =<< isRecord r where err = typeError $ ShouldBeRecordType (El __DUMMY_SORT__ $ Def r []) @@ -126,10 +120,15 @@ return $ unArg r <$ proper -- if proper then Just (unArg r) else Nothing -- | Get the field names of a record. -getRecordFieldNames :: QName -> TCM [Arg C.Name] +getRecordFieldNames :: (HasConstInfo m, ReadTCState m, MonadError TCErr m) + => QName -> m [Dom C.Name] getRecordFieldNames r = recordFieldNames <$> getRecordDef r -recordFieldNames :: Defn -> [Arg C.Name] +getRecordFieldNames_ :: (HasConstInfo m, ReadTCState m) + => QName -> m (Maybe [Dom C.Name]) +getRecordFieldNames_ r = fmap recordFieldNames <$> isRecord r + +recordFieldNames :: Defn -> [Dom C.Name] recordFieldNames = map (fmap (nameConcrete . qnameName)) . recFields -- | Find all records with at least the given fields. @@ -137,7 +136,8 @@ findPossibleRecords fields = do defs <- HMap.elems <$> useTC (stSignature . sigDefinitions) idefs <- HMap.elems <$> useTC (stImports . sigDefinitions) - return $ cands defs ++ cands idefs + scope <- getScope + return $ filter (`isNameInScope` scope) $ cands defs ++ cands idefs where cands defs = [ defName d | d <- defs, possible d ] possible def = @@ -145,7 +145,7 @@ -- in the fields of record @def@ (if it is a record). case theDef def of Record{ recFields = fs } -> Set.isSubsetOf given $ - Set.fromList $ map (nameConcrete . qnameName . unArg) fs + Set.fromList $ map (nameConcrete . qnameName . unDom) fs _ -> False given = Set.fromList fields @@ -156,7 +156,7 @@ -- | Get the field names belonging to a record type. getRecordTypeFields :: Type -- ^ Record type. Need not be reduced. - -> TCM [Arg QName] + -> TCM [Dom QName] getRecordTypeFields t = do t <- reduce t -- Andreas, 2018-03-03, fix for #2989. case unEl t of @@ -169,7 +169,7 @@ -- | Returns the given record type's constructor name (with an empty -- range). -getRecordConstructor :: QName -> TCM ConHead +getRecordConstructor :: (HasConstInfo m, ReadTCState m, MonadError TCErr m) => QName -> m ConHead getRecordConstructor r = killRange <$> recConHead <$> getRecordDef r -- | Check if a name refers to a record. @@ -186,7 +186,7 @@ -- | Reduce a type and check whether it is a record type. -- Succeeds only if type is not blocked by a meta var. -- If yes, return its name, parameters, and definition. -isRecordType :: (MonadReduce m, HasConstInfo m) +isRecordType :: (MonadReduce m, HasConstInfo m, HasBuiltins m) => Type -> m (Maybe (QName, Args, Defn)) isRecordType t = either (const Nothing) Just <$> tryRecordType t @@ -194,9 +194,9 @@ -- Succeeds only if type is not blocked by a meta var. -- If yes, return its name, parameters, and definition. -- If no, return the reduced type (unless it is blocked). -tryRecordType :: (MonadReduce m, HasConstInfo m) +tryRecordType :: (MonadReduce m, HasConstInfo m, HasBuiltins m) => Type -> m (Either (Blocked Type) (QName, Args, Defn)) -tryRecordType t = ifBlockedType t (\ m a -> return $ Left $ Blocked m a) $ \ nb t -> do +tryRecordType t = ifBlocked t (\ m a -> return $ Left $ Blocked m a) $ \ nb t -> do let no = return $ Left $ NotBlocked nb t case unEl t of Def r es -> do @@ -240,7 +240,7 @@ -- if @f@ is not a projection (like) function, @a@ is the correct type fallback = return $ Just a reportSDoc "tc.deftype" 20 $ vcat - [ "definition f = " <> prettyTCM f <+> text (" -- raw: " ++ prettyShow f) + [ ("definition f = " <> prettyTCM f) <+> text (" -- raw: " ++ prettyShow f) , "has type a = " <> prettyTCM a , "principal t = " <> prettyTCM t ] @@ -291,11 +291,12 @@ -- Precondition: @t@ is reduced. -- projectTyped - :: Term -- ^ Head (record value). + :: (HasConstInfo m, MonadReduce m, MonadDebug m) + => Term -- ^ Head (record value). -> Type -- ^ Its type. -> ProjOrigin -> QName -- ^ Projection. - -> TCM (Maybe (Dom Type, Term, Type)) + -> m (Maybe (Dom Type, Term, Type)) projectTyped v t o f = caseMaybeM (getDefType f t) (return Nothing) $ \ tf -> do ifNotPiType tf (const $ return Nothing) {- else -} $ \ dom b -> do u <- applyDef o f (argFromDom dom $> v) @@ -346,6 +347,12 @@ Constructor {conData = r} -> isEtaRecord r _ -> return False +-- | Going under one of these does not count as a decrease in size for the termination checker. +isEtaOrCoinductiveRecordConstructor :: HasConstInfo m => QName -> m Bool +isEtaOrCoinductiveRecordConstructor c = + caseMaybeM (isRecordConstructor c) (return False) $ \ (_, def) -> + return $ (Just Inductive, NoEta) /= (recInduction def, recEtaEquality def) + -- | Check if a name refers to a record which is not coinductive. (Projections are then size-preserving) isInductiveRecord :: QName -> TCM Bool isInductiveRecord r = maybe False (\ d -> recInduction d /= Just CoInductive) <$> isRecord r @@ -372,7 +379,8 @@ -- | Check if a constructor name is the internally generated record constructor. -- -- Works also for abstract constructors. -isGeneratedRecordConstructor :: QName -> TCM Bool +isGeneratedRecordConstructor :: (MonadTCEnv m, HasConstInfo m) + => QName -> m Bool isGeneratedRecordConstructor c = ignoreAbstractMode $ do caseMaybeM (isRecordConstructor c) (return False) $ \ (_, def) -> case def of @@ -460,7 +468,7 @@ -- TODO: compose argInfo ai with tel. let tel = recTel def `apply` pars m = size tel - fs = recFields def + fs = map argFromDom $ recFields def -- Construct the record pattern @Γ₁, Γ' ⊢ u := c ys@. ys = zipWith (\ f i -> f $> var i) fs $ downFrom m u = mkCon (recConHead def) ConOSystem ys @@ -527,7 +535,7 @@ -- TODO: compose argInfo ai with tel. let tel = recTel def `apply` pars m = size tel - fs = recFields def + fs = map argFromDom $ recFields def ys = zipWith (\ f i -> f $> var i) fs $ downFrom m u = mkCon (recConHead def) ConOSystem ys b' = raise m b `absApp` u @@ -557,27 +565,27 @@ where @tel@ is the record telescope instantiated at the parameters @pars@. -} -etaExpandRecord :: (MonadTCM m, HasConstInfo m, MonadDebug m) +etaExpandRecord :: (HasConstInfo m, MonadDebug m, ReadTCState m, MonadError TCErr m) => QName -> Args -> Term -> m (Telescope, Args) etaExpandRecord = etaExpandRecord' False -- | Eta expand a record regardless of whether it's an eta-record or not. -forceEtaExpandRecord :: (MonadTCM m, HasConstInfo m, MonadDebug m) +forceEtaExpandRecord :: (HasConstInfo m, MonadDebug m, ReadTCState m, MonadError TCErr m) => QName -> Args -> Term -> m (Telescope, Args) forceEtaExpandRecord = etaExpandRecord' True -etaExpandRecord' :: (MonadTCM m, HasConstInfo m, MonadDebug m) +etaExpandRecord' :: (HasConstInfo m, MonadDebug m, ReadTCState m, MonadError TCErr m) => Bool -> QName -> Args -> Term -> m (Telescope, Args) etaExpandRecord' forceEta r pars u = do def <- getRecordDef r (tel, _, _, args) <- etaExpandRecord'_ forceEta r pars def u return (tel, args) -etaExpandRecord_ :: (MonadTCEnv m, HasOptions m, MonadDebug m) +etaExpandRecord_ :: HasConstInfo m => QName -> Args -> Defn -> Term -> m (Telescope, ConHead, ConInfo, Args) etaExpandRecord_ = etaExpandRecord'_ False -etaExpandRecord'_ :: (MonadTCEnv m, HasOptions m, MonadDebug m) +etaExpandRecord'_ :: HasConstInfo m => Bool -> QName -> Args -> Defn -> Term -> m (Telescope, ConHead, ConInfo, Args) etaExpandRecord'_ forceEta r pars def u = do let Record{ recConHead = con @@ -592,7 +600,9 @@ -- Already expanded. Con con_ ci es -> do let args = fromMaybe __IMPOSSIBLE__ $ allApplyElims es - when (con /= con_) $ do + -- Andreas, 2019-10-21, issue #4148 + -- @con == con_@ might fail, but their normal forms should be equal. + whenNothingM (conName con `sameDef` conName con_) $ do reportSDoc "impossible" 10 $ vcat [ "etaExpandRecord_: the following two constructors should be identical" , nest 2 $ text $ "con = " ++ prettyShow con @@ -605,7 +615,7 @@ _ -> do -- Andreas, < 2016-01-18: Note: recFields are always the original projections, -- thus, we can use them in Proj directly. - let xs' = for xs $ fmap $ \ x -> u `applyE` [Proj ProjSystem x] + let xs' = for (map argFromDom xs) $ fmap $ \ x -> u `applyE` [Proj ProjSystem x] reportSDoc "tc.record.eta" 20 $ vcat [ "eta expanding" <+> prettyTCM u <+> ":" <+> prettyTCM r , nest 2 $ vcat @@ -626,7 +636,12 @@ -- We can eta contract if all fields @f = ...@ are irrelevant -- or all fields @f@ are the projection @f v@ of the same value @v@, -- but we need at least one relevant field to find the value @v@. +-- +-- If all fields are erased, we cannot eta-contract. +-- Andreas, 2019-11-06, issue #4168: eta-contraction all-erased record +-- lead to compilation error. + -- TODO: this can be moved out of TCM. -- Andreas, 2018-01-28: attempted just that, but Auto does not -- put the conFields there (it does not run in TCM). @@ -635,9 +650,9 @@ {-# SPECIALIZE etaContractRecord :: QName -> ConHead -> ConInfo -> Args -> TCM Term #-} {-# SPECIALIZE etaContractRecord :: QName -> ConHead -> ConInfo -> Args -> ReduceM Term #-} etaContractRecord :: HasConstInfo m => QName -> ConHead -> ConInfo -> Args -> m Term -etaContractRecord r c ci args = do +etaContractRecord r c ci args = if all (not . usableModality) args then fallBack else do Just Record{ recFields = xs } <- isRecord r - let check :: Arg Term -> Arg QName -> Maybe (Maybe Term) + let check :: Arg Term -> Dom QName -> Maybe (Maybe Term) check a ax = do -- @a@ is the constructor argument, @ax@ the corr. record field name -- skip irrelevant record fields by returning DontCare @@ -646,10 +661,9 @@ -- if @a@ is the record field name applied to a single argument -- then it passes the check (_, Just (_, [])) -> Nothing -- not a projection - (_, Just (h, es)) | Proj _o f <- last es, unArg ax == f + (_, Just (h, es)) | Proj _o f <- last es, unDom ax == f -> Just $ Just $ h $ init es _ -> Nothing - fallBack = return (mkCon c ci args) case compare (length args) (length xs) of LT -> fallBack -- Not fully applied GT -> __IMPOSSIBLE__ -- Too many arguments. Impossible. @@ -662,28 +676,35 @@ else fallBack _ -> fallBack -- just irrelevant terms _ -> fallBack -- a Nothing + where + fallBack = return (mkCon c ci args) -- | Is the type a hereditarily singleton record type? May return a -- blocking metavariable. -- -- Precondition: The name should refer to a record type, and the -- arguments should be the parameters to the type. -isSingletonRecord :: QName -> Args -> TCM (Either MetaId Bool) +isSingletonRecord :: (MonadReduce m, MonadAddContext m, HasConstInfo m, HasBuiltins m, ReadTCState m) + => QName -> Args -> m (Either MetaId Bool) isSingletonRecord r ps = mapRight isJust <$> isSingletonRecord' False r ps -isSingletonRecordModuloRelevance :: QName -> Args -> TCM (Either MetaId Bool) +isSingletonRecordModuloRelevance :: (MonadReduce m, MonadAddContext m, HasConstInfo m, HasBuiltins m, ReadTCState m) + => QName -> Args -> m (Either MetaId Bool) isSingletonRecordModuloRelevance r ps = mapRight isJust <$> isSingletonRecord' True r ps -- | Return the unique (closed) inhabitant if exists. -- In case of counting irrelevance in, the returned inhabitant -- contains dummy terms. -isSingletonRecord' :: Bool -> QName -> Args -> TCM (Either MetaId (Maybe Term)) +isSingletonRecord' :: forall m. (MonadReduce m, MonadAddContext m, HasConstInfo m, HasBuiltins m, ReadTCState m) + => Bool -> QName -> Args -> m (Either MetaId (Maybe Term)) isSingletonRecord' regardIrrelevance r ps = do - reportSLn "tc.meta.eta" 30 $ "Is " ++ prettyShow r ++ " a singleton record type?" - def <- getRecordDef r - emap (mkCon (recConHead def) ConOSystem) <$> check (recTel def `apply` ps) + reportSDoc "tc.meta.eta" 30 $ "Is" <+> prettyTCM (Def r $ map Apply ps) <+> "a singleton record type?" + isRecord r >>= \case + Nothing -> return $ Right Nothing + Just def -> do + emap (mkCon (recConHead def) ConOSystem) <$> check (recTel def `apply` ps) where - check :: Telescope -> TCM (Either MetaId (Maybe [Arg Term])) + check :: Telescope -> m (Either MetaId (Maybe [Arg Term])) check tel = do reportSDoc "tc.meta.eta" 30 $ "isSingletonRecord' checking telescope " <+> prettyTCM tel @@ -703,19 +724,21 @@ -- | Check whether a type has a unique inhabitant and return it. -- Can be blocked by a metavar. -isSingletonType :: Type -> TCM (Either MetaId (Maybe Term)) +isSingletonType :: (MonadReduce m, MonadAddContext m, HasConstInfo m, HasBuiltins m, ReadTCState m) + => Type -> m (Either MetaId (Maybe Term)) isSingletonType = isSingletonType' False -- | Check whether a type has a unique inhabitant (irrelevant parts ignored). -- Can be blocked by a metavar. -isSingletonTypeModuloRelevance :: (MonadTCM tcm) => Type -> tcm (Either MetaId Bool) -isSingletonTypeModuloRelevance t = liftTCM $ do - mapRight isJust <$> isSingletonType' True t +isSingletonTypeModuloRelevance :: (MonadReduce m, MonadAddContext m, HasConstInfo m, HasBuiltins m, ReadTCState m) + => Type -> m (Either MetaId Bool) +isSingletonTypeModuloRelevance t = mapRight isJust <$> isSingletonType' True t -isSingletonType' :: Bool -> Type -> TCM (Either MetaId (Maybe Term)) +isSingletonType' :: (MonadReduce m, MonadAddContext m, HasConstInfo m, HasBuiltins m, ReadTCState m) + => Bool -> Type -> m (Either MetaId (Maybe Term)) isSingletonType' regardIrrelevance t = do TelV tel t <- telView t - ifBlockedType t (\ m _ -> return $ Left m) $ \ _ t -> do + ifBlocked t (\ m _ -> return $ Left m) $ \ _ t -> addContext tel $ do res <- isRecordType t case res of Just (r, ps, def) | YesEta <- recEtaEquality def -> do @@ -748,7 +771,7 @@ return i' (_, Def d pars) -> do guard =<< do liftTCM $ isEtaRecord d - fs <- liftTCM $ map unArg . recFields . theDef <$> getConstInfo d + fs <- liftTCM $ map unDom . recFields . theDef <$> getConstInfo d is <- forM fs $ \f -> do let o = ProjSystem (_, _, fa) <- MaybeT $ projectTyped u a o f diff --git a/src/full/Agda/TypeChecking/Records.hs-boot b/src/full/Agda/TypeChecking/Records.hs-boot --- a/src/full/Agda/TypeChecking/Records.hs-boot +++ b/src/full/Agda/TypeChecking/Records.hs-boot @@ -1,14 +1,13 @@ module Agda.TypeChecking.Records where -import Agda.Syntax.Common import Agda.Syntax.Internal import qualified Agda.Syntax.Concrete.Name as C import Agda.TypeChecking.Monad isRecord :: HasConstInfo m => QName -> m (Maybe Defn) isEtaRecord :: HasConstInfo m => QName -> m Bool -getRecordFieldNames :: QName -> TCM [Arg C.Name] +getRecordFieldNames_ :: (HasConstInfo m, ReadTCState m) => QName -> m (Maybe [Dom C.Name]) etaContractRecord :: HasConstInfo m => QName -> ConHead -> ConInfo -> Args -> m Term -isGeneratedRecordConstructor :: QName -> TCM Bool +isGeneratedRecordConstructor :: (MonadTCEnv m, HasConstInfo m) => QName -> m Bool isRecordConstructor :: HasConstInfo m => QName -> m (Maybe (QName, Defn)) diff --git a/src/full/Agda/TypeChecking/Reduce.hs b/src/full/Agda/TypeChecking/Reduce.hs --- a/src/full/Agda/TypeChecking/Reduce.hs +++ b/src/full/Agda/TypeChecking/Reduce.hs @@ -1,34 +1,31 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE NondecreasingIndentation #-} {-# LANGUAGE UndecidableInstances #-} +{-# LANGUAGE TypeFamilies #-} module Agda.TypeChecking.Reduce where import Prelude hiding (mapM) import Control.Monad.Reader hiding (mapM) -import qualified Data.List as List import Data.List ((\\)) import Data.Maybe import Data.Map (Map) -import Data.Monoid import Data.Traversable -import Data.Hashable +import Data.HashMap.Strict (HashMap) import Agda.Interaction.Options import Agda.Syntax.Position import Agda.Syntax.Common import Agda.Syntax.Internal -import Agda.Syntax.Internal.Pattern +import Agda.Syntax.Internal.MetaVars import Agda.Syntax.Scope.Base (Scope) import Agda.Syntax.Literal -import Agda.TypeChecking.Monad hiding ( underAbstraction_, enterClosure, isInstantiatedMeta - , getConstInfo - , lookupMeta ) +import {-# SOURCE #-} Agda.TypeChecking.Irrelevance (workOnTypes, isPropM) +import {-# SOURCE #-} Agda.TypeChecking.Level (reallyUnLevelView) +import Agda.TypeChecking.Monad hiding ( enterClosure, constructorForm ) import qualified Agda.TypeChecking.Monad as TCM -import Agda.TypeChecking.Monad.Builtin hiding (getPrimitive, constructorForm) import Agda.TypeChecking.Substitute import Agda.TypeChecking.CompiledClause import Agda.TypeChecking.EtaContract @@ -41,16 +38,15 @@ import {-# SOURCE #-} Agda.TypeChecking.Rewriting import {-# SOURCE #-} Agda.TypeChecking.Reduce.Fast -import Agda.Utils.Function import Agda.Utils.Functor import Agda.Utils.Lens import Agda.Utils.Maybe +import qualified Agda.Utils.Maybe.Strict as Strict import Agda.Utils.Monad -import Agda.Utils.HashMap (HashMap) import Agda.Utils.Size import Agda.Utils.Tuple +import qualified Agda.Utils.SmallSet as SmallSet -#include "undefined.h" import Agda.Utils.Impossible instantiate :: (Instantiate a, MonadReduce m) => a -> m a @@ -79,7 +75,7 @@ -- | Meaning no metas left in the instantiation. isFullyInstantiatedMeta :: MetaId -> TCM Bool isFullyInstantiatedMeta m = do - mv <- TCM.lookupMeta m + mv <- lookupMeta m case mvInstantiation mv of InstV _tel v -> noMetas <$> instantiateFull v _ -> return False @@ -89,11 +85,34 @@ -- Doesn't do any reduction, and preserves blocking tags (when blocking meta -- is uninstantiated). class Instantiate t where - instantiate' :: t -> ReduceM t + instantiate' :: t -> ReduceM t + default instantiate' :: (t ~ f a, Traversable f, Instantiate a) => t -> ReduceM t + instantiate' = traverse instantiate' + +instance Instantiate t => Instantiate [t] +instance Instantiate t => Instantiate (Map k t) +instance Instantiate t => Instantiate (Maybe t) +instance Instantiate t => Instantiate (Strict.Maybe t) + +instance Instantiate t => Instantiate (Abs t) +instance Instantiate t => Instantiate (Arg t) +instance Instantiate t => Instantiate (Elim' t) +instance Instantiate t => Instantiate (Tele t) + +instance (Instantiate a, Instantiate b) => Instantiate (a,b) where + instantiate' (x,y) = (,) <$> instantiate' x <*> instantiate' y + +instance (Instantiate a, Instantiate b,Instantiate c) => Instantiate (a,b,c) where + instantiate' (x,y,z) = (,,) <$> instantiate' x <*> instantiate' y <*> instantiate' z + instance Instantiate Term where instantiate' t@(MetaV x es) = do - mi <- mvInstantiation <$> lookupMeta x + blocking <- view stInstantiateBlocking <$> getTCState + + mv <- lookupMeta x + mi <- mvInstantiation <$> pure mv + case mi of InstV tel v -> instantiate' inst where @@ -108,19 +127,26 @@ -- when applicable -- specification: inst == foldr mkLam v tel `applyE` es inst = applySubst rho (foldr mkLam v $ drop (length es1) tel) `applyE` es2 + _ | Just m' <- mvTwin mv, blocking -> do + instantiate' (MetaV m' es) Open -> return t OpenInstance -> return t - BlockedConst _ -> return t + BlockedConst u | blocking -> instantiate' . unBrave $ BraveTerm u `applyE` es + | otherwise -> return t PostponedTypeCheckingProblem _ _ -> return t instantiate' (Level l) = levelTm <$> instantiate' l instantiate' (Sort s) = Sort <$> instantiate' s instantiate' t = return t +instance Instantiate t => Instantiate (Type' t) where + instantiate' (El s t) = El <$> instantiate' s <*> instantiate' t + instance Instantiate Level where - instantiate' (Max as) = levelMax <$> instantiate' as + instantiate' (Max m as) = levelMax m <$> instantiate' as +-- Note: since @PlusLevel' t@ embeds a @LevelAtom' t@, simply +-- using @traverse@ for @PlusLevel'@ would not be not correct. instance Instantiate PlusLevel where - instantiate' l@ClosedLevel{} = return l instantiate' (Plus n a) = Plus n <$> instantiate' a instance Instantiate LevelAtom where @@ -144,9 +170,6 @@ BlockedConst{} -> return v PostponedTypeCheckingProblem{} -> return v -instance Instantiate Type where - instantiate' (El s t) = El <$> instantiate' s <*> instantiate' t - instance Instantiate Sort where instantiate' s = case s of MetaS x es -> instantiate' (MetaV x es) >>= \case @@ -156,43 +179,14 @@ _ -> __IMPOSSIBLE__ _ -> return s -instance Instantiate Elim where - instantiate' (Apply v) = Apply <$> instantiate' v - instantiate' (Proj o f)= pure $ Proj o f - instantiate' (IApply x y v) = IApply <$> instantiate' x <*> instantiate' y <*> instantiate' v - -instance Instantiate t => Instantiate (Abs t) where - instantiate' = traverse instantiate' - -instance Instantiate t => Instantiate (Arg t) where - instantiate' = traverse instantiate' - -instance Instantiate t => Instantiate (Dom t) where - instantiate' = traverse instantiate' - -instance Instantiate t => Instantiate (Maybe t) where - instantiate' = traverse instantiate' - -instance Instantiate t => Instantiate [t] where - instantiate' = traverse instantiate' - -instance (Instantiate a, Instantiate b) => Instantiate (a,b) where - instantiate' (x,y) = (,) <$> instantiate' x <*> instantiate' y - - -instance (Instantiate a, Instantiate b,Instantiate c) => Instantiate (a,b,c) where - instantiate' (x,y,z) = (,,) <$> instantiate' x <*> instantiate' y <*> instantiate' z +instance (Instantiate t, Instantiate e) => Instantiate (Dom' t e) where + instantiate' (Dom i fin n tac x) = Dom i fin n <$> instantiate' tac <*> instantiate' x instance Instantiate a => Instantiate (Closure a) where instantiate' cl = do x <- enterClosure cl instantiate' return $ cl { clValue = x } -instance Instantiate Telescope where - instantiate' EmptyTel = return EmptyTel - instantiate' (ExtendTel a tel) = ExtendTel <$> instantiate' a <*> instantiate' tel ---instantiate' tel = return tel - instance Instantiate Constraint where instantiate' (ValueCmp cmp t u v) = do (t,u,v) <- instantiate' (t,u,v) @@ -203,7 +197,6 @@ instantiate' (ElimCmp cmp fs t v as bs) = ElimCmp cmp fs <$> instantiate' t <*> instantiate' v <*> instantiate' as <*> instantiate' bs instantiate' (LevelCmp cmp u v) = uncurry (LevelCmp cmp) <$> instantiate' (u,v) - instantiate' (TypeCmp cmp a b) = uncurry (TypeCmp cmp) <$> instantiate' (a,b) instantiate' (TelCmp a b cmp tela telb) = uncurry (TelCmp a b cmp) <$> instantiate' (tela,telb) instantiate' (SortCmp cmp a b) = uncurry (SortCmp cmp) <$> instantiate' (a,b) instantiate' (Guarded c pid) = Guarded <$> instantiate' c <*> pure pid @@ -215,9 +208,12 @@ instantiate' (HasBiggerSort a) = HasBiggerSort <$> instantiate' a instantiate' (HasPTSRule a b) = uncurry HasPTSRule <$> instantiate' (a,b) instantiate' (UnquoteTactic m t h g) = UnquoteTactic m <$> instantiate' t <*> instantiate' h <*> instantiate' g + instantiate' c@CheckMetaInst{} = return c -instance Instantiate e => Instantiate (Map k e) where - instantiate' = traverse instantiate' +instance Instantiate CompareAs where + instantiate' (AsTermsOf a) = AsTermsOf <$> instantiate' a + instantiate' AsSizes = return AsSizes + instantiate' AsTypes = return AsTypes instance Instantiate Candidate where instantiate' (Candidate u t ov) = Candidate <$> instantiate' u <*> instantiate' t <*> pure ov @@ -237,27 +233,46 @@ -- * Reduction to weak head normal form. --------------------------------------------------------------------------- +class IsMeta a where + isMeta :: HasBuiltins m => a -> m (Maybe MetaId) + +instance IsMeta Term where + isMeta (MetaV m _) = return $ Just m + isMeta _ = return Nothing + +instance IsMeta Type where + isMeta = isMeta . unEl + +instance IsMeta Level where + isMeta = isMeta <=< reallyUnLevelView + +instance IsMeta Sort where + isMeta (MetaS m _) = return $ Just m + isMeta _ = return Nothing + +instance IsMeta CompareAs where + isMeta (AsTermsOf a) = isMeta a + isMeta AsSizes = return Nothing + isMeta AsTypes = return Nothing + -- | Case on whether a term is blocked on a meta (or is a meta). -- That means it can change its shape when the meta is instantiated. -ifBlocked :: (MonadReduce m) => Term -> (MetaId -> Term -> m a) -> (NotBlocked -> Term -> m a) -> m a +ifBlocked + :: (Reduce t, IsMeta t, MonadReduce m, HasBuiltins m) + => t -> (MetaId -> t -> m a) -> (NotBlocked -> t -> m a) -> m a ifBlocked t blocked unblocked = do t <- reduceB t case t of - Blocked m _ -> blocked m (ignoreBlocking t) - NotBlocked _ (MetaV m _) -> blocked m (ignoreBlocking t) - NotBlocked nb _ -> unblocked nb (ignoreBlocking t) + Blocked m t -> blocked m t + NotBlocked nb t -> isMeta t >>= \case + Just m -> blocked m t + Nothing -> unblocked nb t -isBlocked :: MonadReduce m => Term -> m (Maybe MetaId) +isBlocked + :: (Reduce t, IsMeta t, MonadReduce m, HasBuiltins m) + => t -> m (Maybe MetaId) isBlocked t = ifBlocked t (\m _ -> return $ Just m) (\_ _ -> return Nothing) --- | Case on whether a type is blocked on a meta (or is a meta). -ifBlockedType :: MonadReduce m => Type -> (MetaId -> Type -> m a) -> (NotBlocked -> Type -> m a) -> m a -ifBlockedType (El s t) blocked unblocked = - ifBlocked t (\ m v -> blocked m $ El s v) (\ nb v -> unblocked nb $ El s v) - -isBlockedType :: MonadReduce m => Type -> m (Maybe MetaId) -isBlockedType t = ifBlockedType t (\m _ -> return $ Just m) (\_ _ -> return Nothing) - class Reduce t where reduce' :: t -> ReduceM t reduceB' :: t -> ReduceM (Blocked t) @@ -266,16 +281,20 @@ reduceB' t = notBlocked <$> reduce' t instance Reduce Type where - reduce' (El s t) = El s <$> reduce' t - reduceB' (El s t) = fmap (El s) <$> reduceB' t + reduce' (El s t) = workOnTypes $ El s <$> reduce' t + reduceB' (El s t) = workOnTypes $ fmap (El s) <$> reduceB' t instance Reduce Sort where reduce' s = do s <- instantiate' s case s of - PiSort s1 s2 -> do - (s1,s2) <- reduce' (s1,s2) - maybe (return $ PiSort s1 s2) reduce' $ piSort' s1 s2 + PiSort a s2 -> do + (s1' , s2') <- reduce' (getSort a , s2) + let a' = set lensSort s1' a + maybe (return $ PiSort a' s2') reduce' $ piSort' a' s2' + FunSort s1 s2 -> do + (s1' , s2') <- reduce (s1 , s2) + maybe (return $ FunSort s1' s2') reduce' $ funSort' s1' s2' UnivSort s' -> do s' <- reduce' s' ui <- univInf @@ -294,11 +313,10 @@ reduce' (IApply x y v) = IApply <$> reduce' x <*> reduce' y <*> reduce' v instance Reduce Level where - reduce' (Max as) = levelMax <$> mapM reduce' as - reduceB' (Max as) = fmap levelMax . traverse id <$> traverse reduceB' as + reduce' (Max m as) = levelMax m <$> mapM reduce' as + reduceB' (Max m as) = fmap (levelMax m) . traverse id <$> traverse reduceB' as instance Reduce PlusLevel where - reduceB' l@ClosedLevel{} = return $ notBlocked l reduceB' (Plus n l) = fmap (Plus n) <$> reduceB' l instance Reduce LevelAtom where @@ -368,7 +386,7 @@ NotBlocked i _ -> NotBlocked i () reduceIApply' :: (Term -> ReduceM (Blocked Term)) -> ReduceM (Blocked Term) -> [Elim] -> ReduceM (Blocked Term) -reduceIApply' reduceB' d (IApply x y r : es) = do +reduceIApply' red d (IApply x y r : es) = do view <- intervalView' r <- reduceB' r -- We need to propagate the blocking information so that e.g. @@ -376,21 +394,25 @@ let blockedInfo = blockedOrMeta r case view (ignoreBlocking r) of - IZero -> reduceB' (applyE x es) - IOne -> reduceB' (applyE y es) - _ -> fmap (<* blockedInfo) (reduceIApply d es) -reduceIApply' reduceB' d (_ : es) = reduceIApply d es -reduceIApply' reduceB' d [] = d + IZero -> red (applyE x es) + IOne -> red (applyE y es) + _ -> fmap (<* blockedInfo) (reduceIApply' red d es) +reduceIApply' red d (_ : es) = reduceIApply' red d es +reduceIApply' _ d [] = d +instance Reduce DeBruijnPattern where + reduceB' (DotP o v) = fmap (DotP o) <$> reduceB' v + reduceB' p = return $ notBlocked p + instance Reduce Term where reduceB' = {-# SCC "reduce'" #-} maybeFastReduceTerm shouldTryFastReduce :: ReduceM Bool shouldTryFastReduce = (optFastReduce <$> pragmaOptions) `and2M` do allowed <- asksTC envAllowedReductions - let optionalReductions = [NonTerminatingReductions, UnconfirmedReductions] - requiredReductions = allReductions \\ optionalReductions - return $ (allowed \\ optionalReductions) == requiredReductions + let optionalReductions = SmallSet.fromList [NonTerminatingReductions, UnconfirmedReductions] + requiredReductions = allReductions SmallSet.\\ optionalReductions + return $ (allowed SmallSet.\\ optionalReductions) == requiredReductions maybeFastReduceTerm :: Term -> ReduceM (Blocked Term) maybeFastReduceTerm v = do @@ -427,7 +449,7 @@ $ unfoldDefinitionE False reduceB' (Con c ci []) (conName c) es traverse reduceNat v Sort s -> fmap Sort <$> reduceB' s - Level l -> ifM (elem LevelReductions <$> asksTC envAllowedReductions) + Level l -> ifM (SmallSet.member LevelReductions <$> asksTC envAllowedReductions) {- then -} (fmap levelTm <$> reduceB' l) {- else -} done Pi _ _ -> done @@ -500,38 +522,38 @@ unfoldDefinitionStep :: Bool -> Term -> QName -> Elims -> ReduceM (Reduced (Blocked Term) Term) unfoldDefinitionStep unfoldDelayed v0 f es = {-# SCC "reduceDef" #-} do + traceSDoc "tc.reduce" 90 ("unfoldDefinitionStep v0" <+> prettyTCM v0) $ do info <- getConstInfo f rewr <- instantiateRewriteRules =<< getRewriteRulesFor f allowed <- asksTC envAllowedReductions + prp <- isPropM $ defType info let def = theDef info v = v0 `applyE` es -- Non-terminating functions -- (i.e., those that failed the termination check) -- and delayed definitions - -- are not unfolded unless explicitely permitted. + -- are not unfolded unless explicitly permitted. dontUnfold = - (defNonterminating info && notElem NonTerminatingReductions allowed) - || (defTerminationUnconfirmed info && notElem UnconfirmedReductions allowed) + (defNonterminating info && SmallSet.notMember NonTerminatingReductions allowed) + || (defTerminationUnconfirmed info && SmallSet.notMember UnconfirmedReductions allowed) || (defDelayed info == Delayed && not unfoldDelayed) - copatterns = - case def of - Function{funCopatternLHS = b} -> b - _ -> False + || prp || isIrrelevant (defArgInfo info) + copatterns = defCopatternLHS info case def of Constructor{conSrcCon = c} -> noReduction $ notBlocked $ Con (c `withRangeOf` f) ConOSystem [] `applyE` es Primitive{primAbstr = ConcreteDef, primName = x, primClauses = cls} -> do pf <- fromMaybe __IMPOSSIBLE__ <$> getPrimitive' x - if FunctionReductions `elem` allowed + if FunctionReductions `SmallSet.member` allowed then reducePrimitive x v0 f es pf dontUnfold cls (defCompiled info) rewr else noReduction $ notBlocked v _ -> do - if (RecursiveReductions `elem` allowed) || - (isJust (isProjection_ def) && ProjectionReductions `elem` allowed) || -- includes projection-like - (isInlineFun def && InlineReductions `elem` allowed) || - (definitelyNonRecursive_ def && copatterns && CopatternReductions `elem` allowed) || - (definitelyNonRecursive_ def && FunctionReductions `elem` allowed) + if (RecursiveReductions `SmallSet.member` allowed) || + (isJust (isProjection_ def) && ProjectionReductions `SmallSet.member` allowed) || -- includes projection-like + (isInlineFun def && InlineReductions `SmallSet.member` allowed) || + (definitelyNonRecursive_ def && copatterns && CopatternReductions `SmallSet.member` allowed) || + (definitelyNonRecursive_ def && FunctionReductions `SmallSet.member` allowed) then reduceNormalE v0 f (map notReduced es) dontUnfold (defClauses info) (defCompiled info) rewr @@ -565,9 +587,14 @@ reduceNormalE :: Term -> QName -> [MaybeReduced Elim] -> Bool -> [Clause] -> Maybe CompiledClauses -> RewriteRules -> ReduceM (Reduced (Blocked Term) Term) reduceNormalE v0 f es dontUnfold def mcc rewr = {-# SCC "reduceNormal" #-} do + traceSDoc "tc.reduce" 90 ("reduceNormalE v0 =" <+> prettyTCM v0) $ do case (def,rewr) of - _ | dontUnfold -> defaultResult -- non-terminating or delayed - ([],[]) -> defaultResult -- no definition for head + _ | dontUnfold -> traceSLn "tc.reduce" 90 "reduceNormalE: don't unfold (non-terminating or delayed)" $ + defaultResult -- non-terminating or delayed + ([],[]) -> traceSLn "tc.reduce" 90 "reduceNormalE: no clauses or rewrite rules" $ do + -- no definition for head + blk <- defBlocked <$> getConstInfo f + noReduction $ blk $> vfull (cls,rewr) -> do ev <- appDefE_ f v0 cls mcc rewr es debugReduce ev @@ -590,13 +617,15 @@ reportSDoc "tc.reduce" 100 $ " raw " <+> text (show v) -- | Reduce a non-primitive definition if it is a copy linking to another def. -reduceDefCopy :: QName -> Elims -> TCM (Reduced () Term) +reduceDefCopy :: forall m. (MonadReduce m, HasConstInfo m, HasOptions m, + ReadTCState m, MonadTCEnv m, MonadDebug m) + => QName -> Elims -> m (Reduced () Term) reduceDefCopy f es = do - info <- TCM.getConstInfo f - rewr <- instantiateRewriteRules =<< TCM.getRewriteRulesFor f + info <- getConstInfo f + rewr <- instantiateRewriteRules =<< getRewriteRulesFor f if (defCopy info) then reduceDef_ info rewr f es else return $ NoReduction () where - reduceDef_ :: Definition -> RewriteRules -> QName -> Elims -> TCM (Reduced () Term) + reduceDef_ :: Definition -> RewriteRules -> QName -> Elims -> m (Reduced () Term) reduceDef_ info rewr f es = do let v0 = Def f [] cls = (defClauses info) @@ -604,7 +633,7 @@ if (defDelayed info == Delayed) || (defNonterminating info) then return $ NoReduction () else do - ev <- runReduceM $ appDefE_ f v0 cls mcc rewr $ map notReduced es + ev <- liftReduce $ appDefE_ f v0 cls mcc rewr $ map notReduced es case ev of YesReduction simpl t -> return $ YesReduction simpl t NoReduction{} -> return $ NoReduction () @@ -618,7 +647,7 @@ -- first, possibly rewrite literal v to constructor form v <- constructorForm v - traceSDoc "tc.inj.reduce" 30 ("reduceHead" <+> prettyTCM v) $ do + traceSDoc "tc.inj.reduce" 30 (ignoreAbstractMode $ "reduceHead" <+> prettyTCM v) $ do case v of Def f es -> do @@ -652,10 +681,12 @@ case v of _ | inTypes -> return v -- Don't inline in types (to avoid unfolding of goals) Def f es -> do - def <- theDef <$> getConstInfo f + info <- getConstInfo f + let def = theDef info + irr = isIrrelevant $ defArgInfo info case def of -- Only for simple definitions with no pattern matching (TODO: maybe copatterns?) Function{ funCompiled = Just Done{}, funDelayed = NotDelayed } - | def ^. funInline -> liftReduce $ + | def ^. funInline , not irr -> liftReduce $ ignoreBlocking <$> unfoldDefinitionE False (return . notBlocked) (Def f []) f es _ -> return v _ -> return v @@ -679,6 +710,7 @@ appDefE :: Term -> CompiledClauses -> RewriteRules -> MaybeReducedElims -> ReduceM (Reduced (Blocked Term) Term) appDefE v cc rewr es = do + traceSDoc "tc.reduce" 90 ("appDefE v = " <+> prettyTCM v) $ do r <- matchCompiledE cc es case r of YesReduction simpl t -> return $ YesReduction simpl t @@ -689,7 +721,8 @@ appDef' v cls rewr args = appDefE' v cls rewr $ map (fmap Apply) args appDefE' :: Term -> [Clause] -> RewriteRules -> MaybeReducedElims -> ReduceM (Reduced (Blocked Term) Term) -appDefE' v cls rewr es = goCls cls $ map ignoreReduced es +appDefE' v cls rewr es = traceSDoc "tc.reduce" 90 ("appDefE' v = " <+> prettyTCM v) $ do + goCls cls $ map ignoreReduced es where goCls :: [Clause] -> [Elim] -> ReduceM (Reduced (Blocked Term) Term) goCls cl es = do @@ -742,7 +775,6 @@ reduce' (ElimCmp cmp fs t v as bs) = ElimCmp cmp fs <$> reduce' t <*> reduce' v <*> reduce' as <*> reduce' bs reduce' (LevelCmp cmp u v) = uncurry (LevelCmp cmp) <$> reduce' (u,v) - reduce' (TypeCmp cmp a b) = uncurry (TypeCmp cmp) <$> reduce' (a,b) reduce' (TelCmp a b cmp tela telb) = uncurry (TelCmp a b cmp) <$> reduce' (tela,telb) reduce' (SortCmp cmp a b) = uncurry (SortCmp cmp) <$> reduce' (a,b) reduce' (Guarded c pid) = Guarded <$> reduce' c <*> pure pid @@ -754,7 +786,13 @@ reduce' (HasBiggerSort a) = HasBiggerSort <$> reduce' a reduce' (HasPTSRule a b) = uncurry HasPTSRule <$> reduce' (a,b) reduce' (UnquoteTactic m t h g) = UnquoteTactic m <$> reduce' t <*> reduce' h <*> reduce' g + reduce' c@CheckMetaInst{} = return c +instance Reduce CompareAs where + reduce' (AsTermsOf a) = AsTermsOf <$> reduce' a + reduce' AsSizes = return AsSizes + reduce' AsTypes = return AsTypes + instance Reduce e => Reduce (Map k e) where reduce' = traverse reduce' @@ -772,6 +810,10 @@ <*> reduce' a <*> reduce' b +instance Reduce t => Reduce (IPBoundary' t) where + reduce' = traverse reduce' + reduceB' = fmap sequenceA . traverse reduceB' + --------------------------------------------------------------------------- -- * Simplification --------------------------------------------------------------------------- @@ -781,6 +823,34 @@ class Simplify t where simplify' :: t -> ReduceM t + default simplify' :: (t ~ f a, Traversable f, Simplify a) => t -> ReduceM t + simplify' = traverse simplify' + +-- boring instances: + +instance Simplify t => Simplify [t] +instance Simplify t => Simplify (Map k t) +instance Simplify t => Simplify (Maybe t) +instance Simplify t => Simplify (Strict.Maybe t) + +instance Simplify t => Simplify (Arg t) +instance Simplify t => Simplify (Elim' t) +instance Simplify t => Simplify (Named name t) +instance Simplify t => Simplify (IPBoundary' t) + +instance (Simplify a, Simplify b) => Simplify (a,b) where + simplify' (x,y) = (,) <$> simplify' x <*> simplify' y + +instance (Simplify a, Simplify b, Simplify c) => Simplify (a,b,c) where + simplify' (x,y,z) = + do (x,(y,z)) <- simplify' (x,(y,z)) + return (x,y,z) + +instance Simplify Bool where + simplify' = return + +-- interesting instances: + instance Simplify Term where simplify' v = do v <- instantiate' v @@ -809,18 +879,14 @@ simplifyBlocked' (Blocked _ t) = return t simplifyBlocked' (NotBlocked _ t) = simplify' t -- Andrea(s), 2014-12-05 OK? -instance Simplify Type where +instance Simplify t => Simplify (Type' t) where simplify' (El s t) = El <$> simplify' s <*> simplify' t -instance Simplify Elim where - simplify' (Apply v) = Apply <$> simplify' v - simplify' (Proj o f)= pure $ Proj o f - simplify' (IApply x y v) = IApply <$> simplify' x <*> simplify' y <*> simplify' v - instance Simplify Sort where simplify' s = do case s of - PiSort s1 s2 -> piSort <$> simplify' s1 <*> simplify' s2 + PiSort a s -> piSort <$> simplify' a <*> simplify' s + FunSort s1 s2 -> funSort <$> simplify' s1 <*> simplify' s2 UnivSort s -> do ui <- univInf univSort ui <$> simplify' s @@ -833,10 +899,9 @@ DummyS{} -> return s instance Simplify Level where - simplify' (Max as) = levelMax <$> simplify' as + simplify' (Max m as) = levelMax m <$> simplify' as instance Simplify PlusLevel where - simplify' l@ClosedLevel{} = return l simplify' (Plus n l) = Plus n <$> simplify' l instance Simplify LevelAtom where @@ -852,32 +917,9 @@ simplify' a@(Abs x _) = Abs x <$> underAbstraction_ a simplify' simplify' (NoAbs x v) = NoAbs x <$> simplify' v -instance Simplify t => Simplify (Arg t) where - simplify' = traverse simplify' - -instance Simplify t => Simplify (Named name t) where - simplify' = traverse simplify' - instance Simplify t => Simplify (Dom t) where simplify' = traverse simplify' -instance Simplify t => Simplify [t] where - simplify' = traverse simplify' - -instance Simplify e => Simplify (Map k e) where - simplify' = traverse simplify' - -instance Simplify a => Simplify (Maybe a) where - simplify' = traverse simplify' - -instance (Simplify a, Simplify b) => Simplify (a,b) where - simplify' (x,y) = (,) <$> simplify' x <*> simplify' y - -instance (Simplify a, Simplify b, Simplify c) => Simplify (a,b,c) where - simplify' (x,y,z) = - do (x,(y,z)) <- simplify' (x,(y,z)) - return (x,y,z) - instance Simplify a => Simplify (Closure a) where simplify' cl = do x <- enterClosure cl simplify' @@ -896,11 +938,10 @@ return $ ValueCmp cmp t u v simplify' (ValueCmpOnFace cmp p t u v) = do ((p,t),u,v) <- simplify' ((p,t),u,v) - return $ ValueCmp cmp t u v + return $ ValueCmp cmp (AsTermsOf t) u v simplify' (ElimCmp cmp fs t v as bs) = ElimCmp cmp fs <$> simplify' t <*> simplify' v <*> simplify' as <*> simplify' bs simplify' (LevelCmp cmp u v) = uncurry (LevelCmp cmp) <$> simplify' (u,v) - simplify' (TypeCmp cmp a b) = uncurry (TypeCmp cmp) <$> simplify' (a,b) simplify' (TelCmp a b cmp tela telb) = uncurry (TelCmp a b cmp) <$> simplify' (tela,telb) simplify' (SortCmp cmp a b) = uncurry (SortCmp cmp) <$> simplify' (a,b) simplify' (Guarded c pid) = Guarded <$> simplify' c <*> pure pid @@ -912,9 +953,12 @@ simplify' (HasBiggerSort a) = HasBiggerSort <$> simplify' a simplify' (HasPTSRule a b) = uncurry HasPTSRule <$> simplify' (a,b) simplify' (UnquoteTactic m t h g) = UnquoteTactic m <$> simplify' t <*> simplify' h <*> simplify' g + simplify' c@CheckMetaInst{} = return c -instance Simplify Bool where - simplify' = return +instance Simplify CompareAs where + simplify' (AsTermsOf a) = AsTermsOf <$> simplify' a + simplify' AsSizes = return AsSizes + simplify' AsTypes = return AsTypes -- UNUSED -- instance Simplify ConPatternInfo where @@ -951,13 +995,52 @@ --------------------------------------------------------------------------- class Normalise t where - normalise' :: t -> ReduceM t + normalise' :: t -> ReduceM t + default normalise' :: (t ~ f a, Traversable f, Normalise a) => t -> ReduceM t + normalise' = traverse normalise' + +-- boring instances: + +instance Normalise t => Normalise [t] +instance Normalise t => Normalise (Map k t) +instance Normalise t => Normalise (Maybe t) +instance Normalise t => Normalise (Strict.Maybe t) + +-- Arg not included since we do not normalize irrelevant subterms +-- Elim' not included since it contains Arg +instance Normalise t => Normalise (Named name t) +instance Normalise t => Normalise (IPBoundary' t) +instance Normalise t => Normalise (WithHiding t) + +instance (Normalise a, Normalise b) => Normalise (a,b) where + normalise' (x,y) = (,) <$> normalise' x <*> normalise' y + +instance (Normalise a, Normalise b, Normalise c) => Normalise (a,b,c) where + normalise' (x,y,z) = + do (x,(y,z)) <- normalise' (x,(y,z)) + return (x,y,z) + +instance Normalise Bool where + normalise' = return + +instance Normalise Char where + normalise' = return + +instance Normalise Int where + normalise' = return + +instance Normalise DBPatVar where + normalise' = return + +-- interesting instances: + instance Normalise Sort where normalise' s = do s <- reduce' s case s of - PiSort s1 s2 -> piSort <$> normalise' s1 <*> normalise' s2 + PiSort a s -> piSort <$> normalise' a <*> normalise' s + FunSort s1 s2 -> funSort <$> normalise' s1 <*> normalise' s2 UnivSort s -> do ui <- univInf univSort ui <$> normalise' s @@ -969,7 +1052,7 @@ DefS d es -> return s DummyS{} -> return s -instance Normalise Type where +instance Normalise t => Normalise (Type' t) where normalise' (El s t) = El <$> normalise' s <*> normalise' t instance Normalise Term where @@ -989,16 +1072,16 @@ DontCare _ -> return v Dummy{} -> return v -instance Normalise Elim where - normalise' (Apply v) = Apply <$> normalise' v +-- Note: not the default instance for Elim' since we do something special for Arg. +instance Normalise t => Normalise (Elim' t) where + normalise' (Apply v) = Apply <$> normalise' v -- invokes Normalise Arg here normalise' (Proj o f)= pure $ Proj o f normalise' (IApply x y v) = IApply <$> normalise' x <*> normalise' y <*> normalise' v instance Normalise Level where - normalise' (Max as) = levelMax <$> normalise' as + normalise' (Max m as) = levelMax m <$> normalise' as instance Normalise PlusLevel where - normalise' l@ClosedLevel{} = return l normalise' (Plus n l) = Plus n <$> normalise' l instance Normalise LevelAtom where @@ -1015,26 +1098,13 @@ normalise' (NoAbs x v) = NoAbs x <$> normalise' v instance Normalise t => Normalise (Arg t) where - normalise' a | isIrrelevant a = return a -- Andreas, 2012-04-02: Do not normalize irrelevant terms!? - | otherwise = traverse normalise' a - -instance Normalise t => Normalise (Named name t) where - normalise' = traverse normalise' + normalise' a + | isIrrelevant a = return a -- Andreas, 2012-04-02: Do not normalize irrelevant terms!? + | otherwise = traverse normalise' a instance Normalise t => Normalise (Dom t) where normalise' = traverse normalise' -instance Normalise t => Normalise [t] where - normalise' = traverse normalise' - -instance (Normalise a, Normalise b) => Normalise (a,b) where - normalise' (x,y) = (,) <$> normalise' x <*> normalise' y - -instance (Normalise a, Normalise b, Normalise c) => Normalise (a,b,c) where - normalise' (x,y,z) = - do (x,(y,z)) <- normalise' (x,(y,z)) - return (x,y,z) - instance Normalise a => Normalise (Closure a) where normalise' cl = do x <- enterClosure cl normalise' @@ -1057,7 +1127,6 @@ normalise' (ElimCmp cmp fs t v as bs) = ElimCmp cmp fs <$> normalise' t <*> normalise' v <*> normalise' as <*> normalise' bs normalise' (LevelCmp cmp u v) = uncurry (LevelCmp cmp) <$> normalise' (u,v) - normalise' (TypeCmp cmp a b) = uncurry (TypeCmp cmp) <$> normalise' (a,b) normalise' (TelCmp a b cmp tela telb) = uncurry (TelCmp a b cmp) <$> normalise' (tela,telb) normalise' (SortCmp cmp a b) = uncurry (SortCmp cmp) <$> normalise' (a,b) normalise' (Guarded c pid) = Guarded <$> normalise' c <*> pure pid @@ -1069,26 +1138,20 @@ normalise' (HasBiggerSort a) = HasBiggerSort <$> normalise' a normalise' (HasPTSRule a b) = uncurry HasPTSRule <$> normalise' (a,b) normalise' (UnquoteTactic m t h g) = UnquoteTactic m <$> normalise' t <*> normalise' h <*> normalise' g - -instance Normalise Bool where - normalise' = return - -instance Normalise Int where - normalise' = return + normalise' c@CheckMetaInst{} = return c -instance Normalise Char where - normalise' = return +instance Normalise CompareAs where + normalise' (AsTermsOf a) = AsTermsOf <$> normalise' a + normalise' AsSizes = return AsSizes + normalise' AsTypes = return AsTypes instance Normalise ConPatternInfo where normalise' i = normalise' (conPType i) <&> \ t -> i { conPType = t } -instance Normalise DBPatVar where - normalise' = return - instance Normalise a => Normalise (Pattern' a) where normalise' p = case p of VarP o x -> VarP o <$> normalise' x - LitP _ -> return p + LitP{} -> return p ConP c mt ps -> ConP c <$> normalise' mt <*> normalise' ps DefP o q ps -> DefP o q <$> normalise' ps DotP o v -> DotP o <$> normalise' v @@ -1098,12 +1161,6 @@ instance Normalise DisplayForm where normalise' (Display n ps v) = Display n <$> normalise' ps <*> return v -instance Normalise e => Normalise (Map k e) where - normalise' = traverse normalise' - -instance Normalise a => Normalise (Maybe a) where - normalise' = traverse normalise' - instance Normalise Candidate where normalise' (Candidate u t ov) = Candidate <$> normalise' u <*> normalise' t <*> pure ov @@ -1125,18 +1182,79 @@ -- | @instantiateFull'@ 'instantiate's metas everywhere (and recursively) -- but does not 'reduce'. class InstantiateFull t where - instantiateFull' :: t -> ReduceM t + instantiateFull' :: t -> ReduceM t + default instantiateFull' :: (t ~ f a, Traversable f, InstantiateFull a) => t -> ReduceM t + instantiateFull' = traverse instantiateFull' + +-- Traversables (doesn't include binders like Abs, Tele): + +instance InstantiateFull t => InstantiateFull [t] +instance InstantiateFull t => InstantiateFull (HashMap k t) +instance InstantiateFull t => InstantiateFull (Map k t) +instance InstantiateFull t => InstantiateFull (Maybe t) +instance InstantiateFull t => InstantiateFull (Strict.Maybe t) + +instance InstantiateFull t => InstantiateFull (Arg t) +instance InstantiateFull t => InstantiateFull (Elim' t) +instance InstantiateFull t => InstantiateFull (Named name t) +instance InstantiateFull t => InstantiateFull (Open t) +instance InstantiateFull t => InstantiateFull (WithArity t) + +-- Tuples: + +instance (InstantiateFull a, InstantiateFull b) => InstantiateFull (a,b) where + instantiateFull' (x,y) = (,) <$> instantiateFull' x <*> instantiateFull' y + +instance (InstantiateFull a, InstantiateFull b, InstantiateFull c) => InstantiateFull (a,b,c) where + instantiateFull' (x,y,z) = + do (x,(y,z)) <- instantiateFull' (x,(y,z)) + return (x,y,z) + +instance (InstantiateFull a, InstantiateFull b, InstantiateFull c, InstantiateFull d) => InstantiateFull (a,b,c,d) where + instantiateFull' (x,y,z,w) = + do (x,(y,z,w)) <- instantiateFull' (x,(y,z,w)) + return (x,y,z,w) + +-- Base types: + +instance InstantiateFull Bool where + instantiateFull' = return + +instance InstantiateFull Char where + instantiateFull' = return + +instance InstantiateFull Int where + instantiateFull' = return + +instance InstantiateFull ModuleName where + instantiateFull' = return + instance InstantiateFull Name where instantiateFull' = return +instance InstantiateFull QName where + instantiateFull' = return + +instance InstantiateFull Scope where + instantiateFull' = return + +instance InstantiateFull ConHead where + instantiateFull' = return + +instance InstantiateFull DBPatVar where + instantiateFull' = return + +-- Rest: + instance InstantiateFull Sort where instantiateFull' s = do s <- instantiate' s case s of Type n -> Type <$> instantiateFull' n Prop n -> Prop <$> instantiateFull' n - PiSort s1 s2 -> piSort <$> instantiateFull' s1 <*> instantiateFull' s2 + PiSort a s -> piSort <$> instantiateFull' a <*> instantiateFull' s + FunSort s1 s2 -> funSort <$> instantiateFull' s1 <*> instantiateFull' s2 UnivSort s -> do ui <- univInf univSort ui <$> instantiateFull' s @@ -1146,7 +1264,7 @@ DefS d es -> DefS d <$> instantiateFull' es DummyS{} -> return s -instance (InstantiateFull a) => InstantiateFull (Type' a) where +instance InstantiateFull t => InstantiateFull (Type' t) where instantiateFull' (El s t) = El <$> instantiateFull' s <*> instantiateFull' t @@ -1168,10 +1286,9 @@ Dummy{} -> return v instance InstantiateFull Level where - instantiateFull' (Max as) = levelMax <$> instantiateFull' as + instantiateFull' (Max m as) = levelMax m <$> instantiateFull' as instance InstantiateFull PlusLevel where - instantiateFull' l@ClosedLevel{} = return l instantiateFull' (Plus n l) = Plus n <$> instantiateFull' l instance InstantiateFull LevelAtom where @@ -1199,18 +1316,9 @@ t :# sigma -> consS <$> instantiateFull' t <*> instantiateFull' sigma -instance InstantiateFull Bool where - instantiateFull' = return - -instance InstantiateFull Int where - instantiateFull' = return - instance InstantiateFull ConPatternInfo where instantiateFull' i = instantiateFull' (conPType i) <&> \ t -> i { conPType = t } -instance InstantiateFull DBPatVar where - instantiateFull' = return - instance InstantiateFull a => InstantiateFull (Pattern' a) where instantiateFull' (VarP o x) = VarP o <$> instantiateFull' x instantiateFull' (DotP o t) = DotP o <$> instantiateFull' t @@ -1224,25 +1332,8 @@ instantiateFull' a@(Abs x _) = Abs x <$> underAbstraction_ a instantiateFull' instantiateFull' (NoAbs x a) = NoAbs x <$> instantiateFull' a -instance InstantiateFull t => InstantiateFull (Arg t) where - instantiateFull' = traverse instantiateFull' - -instance InstantiateFull t => InstantiateFull (Named name t) where - instantiateFull' = traverse instantiateFull' - -instance InstantiateFull t => InstantiateFull (Dom t) where - instantiateFull' = traverse instantiateFull' - -instance InstantiateFull t => InstantiateFull [t] where - instantiateFull' = traverse instantiateFull' - -instance (InstantiateFull a, InstantiateFull b) => InstantiateFull (a,b) where - instantiateFull' (x,y) = (,) <$> instantiateFull' x <*> instantiateFull' y - -instance (InstantiateFull a, InstantiateFull b, InstantiateFull c) => InstantiateFull (a,b,c) where - instantiateFull' (x,y,z) = - do (x,(y,z)) <- instantiateFull' (x,(y,z)) - return (x,y,z) +instance (InstantiateFull t, InstantiateFull e) => InstantiateFull (Dom' t e) where + instantiateFull' (Dom i fin n tac x) = Dom i fin n <$> instantiateFull' tac <*> instantiateFull' x instance InstantiateFull a => InstantiateFull (Closure a) where instantiateFull' cl = do @@ -1263,7 +1354,6 @@ ElimCmp cmp fs t v as bs -> ElimCmp cmp fs <$> instantiateFull' t <*> instantiateFull' v <*> instantiateFull' as <*> instantiateFull' bs LevelCmp cmp u v -> uncurry (LevelCmp cmp) <$> instantiateFull' (u,v) - TypeCmp cmp a b -> uncurry (TypeCmp cmp) <$> instantiateFull' (a,b) TelCmp a b cmp tela telb -> uncurry (TelCmp a b cmp) <$> instantiateFull' (tela,telb) SortCmp cmp a b -> uncurry (SortCmp cmp) <$> instantiateFull' (a,b) Guarded c pid -> Guarded <$> instantiateFull' c <*> pure pid @@ -1275,23 +1365,12 @@ HasBiggerSort a -> HasBiggerSort <$> instantiateFull' a HasPTSRule a b -> uncurry HasPTSRule <$> instantiateFull' (a,b) UnquoteTactic m t g h -> UnquoteTactic m <$> instantiateFull' t <*> instantiateFull' g <*> instantiateFull' h - -instance (InstantiateFull a) => InstantiateFull (Elim' a) where - instantiateFull' (Apply v) = Apply <$> instantiateFull' v - instantiateFull' (Proj o f)= pure $ Proj o f - instantiateFull' (IApply x y v) = IApply <$> instantiateFull' x <*> instantiateFull' y <*> instantiateFull' v - -instance InstantiateFull e => InstantiateFull (Map k e) where - instantiateFull' = traverse instantiateFull' - -instance InstantiateFull e => InstantiateFull (HashMap k e) where - instantiateFull' = traverse instantiateFull' - -instance InstantiateFull ModuleName where - instantiateFull' = return + c@CheckMetaInst{} -> return c -instance InstantiateFull Scope where - instantiateFull' = return +instance InstantiateFull CompareAs where + instantiateFull' (AsTermsOf a) = AsTermsOf <$> instantiateFull' a + instantiateFull' AsSizes = return AsSizes + instantiateFull' AsTypes = return AsTypes instance InstantiateFull Signature where instantiateFull' (Sig a b c) = uncurry3 Sig <$> instantiateFull' (a, b, c) @@ -1303,9 +1382,6 @@ instantiateFull' EmptyTel = return EmptyTel instantiateFull' (ExtendTel a b) = uncurry ExtendTel <$> instantiateFull' (a, b) -instance InstantiateFull Char where - instantiateFull' = return - instance InstantiateFull Definition where instantiateFull' def@Defn{ defType = t ,defDisplay = df, theDef = d } = do (t, df, d) <- instantiateFull' (t, df, d) @@ -1313,18 +1389,24 @@ instance InstantiateFull NLPat where instantiateFull' (PVar x y) = return $ PVar x y - instantiateFull' (PWild) = return PWild instantiateFull' (PDef x y) = PDef <$> instantiateFull' x <*> instantiateFull' y instantiateFull' (PLam x y) = PLam x <$> instantiateFull' y instantiateFull' (PPi x y) = PPi <$> instantiateFull' x <*> instantiateFull' y + instantiateFull' (PSort x) = PSort <$> instantiateFull' x instantiateFull' (PBoundVar x y) = PBoundVar x <$> instantiateFull' y instantiateFull' (PTerm x) = PTerm <$> instantiateFull' x instance InstantiateFull NLPType where - instantiateFull' (NLPType l a) = NLPType - <$> instantiateFull' l + instantiateFull' (NLPType s a) = NLPType + <$> instantiateFull' s <*> instantiateFull' a +instance InstantiateFull NLPSort where + instantiateFull' (PType x) = PType <$> instantiateFull' x + instantiateFull' (PProp x) = PProp <$> instantiateFull' x + instantiateFull' PInf = return PInf + instantiateFull' PSizeUniv = return PSizeUniv + instance InstantiateFull RewriteRule where instantiateFull' (RewriteRule q gamma f ps rhs t) = RewriteRule q @@ -1334,9 +1416,6 @@ <*> instantiateFull' rhs <*> instantiateFull' t -instance InstantiateFull a => InstantiateFull (Open a) where - instantiateFull' (OpenThing n a) = OpenThing n <$> instantiateFull' a - instance InstantiateFull DisplayForm where instantiateFull' (Display n ps v) = uncurry (Display n) <$> instantiateFull' (ps, v) @@ -1353,10 +1432,10 @@ DataOrRecSig{} -> return d GeneralizableVar{} -> return d AbstractDefn d -> AbstractDefn <$> instantiateFull' d - Function{ funClauses = cs, funCompiled = cc, funInv = inv, funExtLam = extLam } -> do - (cs, cc, inv) <- instantiateFull' (cs, cc, inv) + Function{ funClauses = cs, funCompiled = cc, funCovering = cov, funInv = inv, funExtLam = extLam } -> do + (cs, cc, cov, inv) <- instantiateFull' (cs, cc, cov, inv) extLam <- instantiateFull' extLam - return $ d { funClauses = cs, funCompiled = cc, funInv = inv, funExtLam = extLam } + return $ d { funClauses = cs, funCompiled = cc, funCovering = cov, funInv = inv, funExtLam = extLam } Datatype{ dataSort = s, dataClause = cl } -> do s <- instantiateFull' s cl <- instantiateFull' cl @@ -1382,9 +1461,6 @@ instantiateFull' NotInjective = return NotInjective instantiateFull' (Inverse inv) = Inverse <$> instantiateFull' inv -instance InstantiateFull a => InstantiateFull (WithArity a) where - instantiateFull' (WithArity n a) = WithArity n <$> instantiateFull' a - instance InstantiateFull a => InstantiateFull (Case a) where instantiateFull' (Branches cop cs eta ls m b lz) = Branches cop @@ -1401,22 +1477,25 @@ instantiateFull' (Case n bs) = Case n <$> instantiateFull' bs instance InstantiateFull Clause where - instantiateFull' (Clause rl rf tel ps b t catchall unreachable) = + instantiateFull' (Clause rl rf tel ps b t catchall recursive unreachable ell) = Clause rl rf <$> instantiateFull' tel <*> instantiateFull' ps <*> instantiateFull' b <*> instantiateFull' t <*> return catchall + <*> return recursive <*> return unreachable + <*> return ell instance InstantiateFull Interface where instantiateFull' (Interface h s ft ms mod scope inside - sig display userwarn b foreignCode - highlighting pragmas usedOpts patsyns warnings) = + sig display userwarn importwarn b foreignCode + highlighting pragmas usedOpts patsyns warnings partialdefs) = Interface h s ft ms mod scope inside <$> instantiateFull' sig <*> instantiateFull' display <*> return userwarn + <*> return importwarn <*> instantiateFull' b <*> return foreignCode <*> return highlighting @@ -1424,19 +1503,11 @@ <*> return usedOpts <*> return patsyns <*> return warnings + <*> return partialdefs instance InstantiateFull a => InstantiateFull (Builtin a) where instantiateFull' (Builtin t) = Builtin <$> instantiateFull' t instantiateFull' (Prim x) = Prim <$> instantiateFull' x - -instance InstantiateFull QName where - instantiateFull' = return - -instance InstantiateFull ConHead where - instantiateFull' = return - -instance InstantiateFull a => InstantiateFull (Maybe a) where - instantiateFull' = mapM instantiateFull' instance InstantiateFull Candidate where instantiateFull' (Candidate u t ov) = diff --git a/src/full/Agda/TypeChecking/Reduce/Fast.hs b/src/full/Agda/TypeChecking/Reduce/Fast.hs --- a/src/full/Agda/TypeChecking/Reduce/Fast.hs +++ b/src/full/Agda/TypeChecking/Reduce/Fast.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE BangPatterns #-} {-# LANGUAGE PatternGuards #-} {-# LANGUAGE PatternSynonyms #-} @@ -39,9 +38,7 @@ module Agda.TypeChecking.Reduce.Fast ( fastReduce, fastNormalise ) where -import Control.Arrow (first, second) import Control.Applicative hiding (empty) -import Control.Monad.Reader import Control.Monad.ST import Control.Monad.ST.Unsafe (unsafeSTToIO, unsafeInterleaveST) @@ -51,7 +48,6 @@ import qualified Data.IntSet as IntSet import qualified Data.List as List import Data.Traversable (traverse) -import Data.Coerce import Data.Semigroup ((<>)) import System.IO.Unsafe (unsafePerformIO) @@ -59,22 +55,18 @@ import Data.STRef import Data.Char -import Debug.Trace (trace) - import Agda.Syntax.Internal import Agda.Syntax.Common import Agda.Syntax.Position import Agda.Syntax.Literal import Agda.TypeChecking.CompiledClause +import Agda.TypeChecking.Irrelevance (isPropM) import Agda.TypeChecking.Monad hiding (Closure(..)) import Agda.TypeChecking.Reduce as R import Agda.TypeChecking.Rewriting (rewrite) -import Agda.TypeChecking.Reduce.Monad as RedM import Agda.TypeChecking.Substitute import Agda.TypeChecking.Monad.Builtin hiding (constructorForm) -import Agda.TypeChecking.CompiledClause.Match () -import Agda.TypeChecking.Free.Precompute import Agda.Interaction.Options @@ -82,15 +74,14 @@ import Agda.Utils.Lens import Agda.Utils.List import Agda.Utils.Maybe -import Agda.Utils.Memo +import Agda.Utils.Monad import Agda.Utils.Null (empty) -import Agda.Utils.Function import Agda.Utils.Functor -import Agda.Utils.Pretty hiding ((<>)) +import Agda.Utils.Pretty import Agda.Utils.Size import Agda.Utils.Zipper +import qualified Agda.Utils.SmallSet as SmallSet -#include "undefined.h" import Agda.Utils.Impossible import Debug.Trace @@ -126,14 +117,24 @@ -- | Compute a 'CompactDef' from a regular definition. compactDef :: BuiltinEnv -> Definition -> RewriteRules -> ReduceM CompactDef compactDef bEnv def rewr = do + + -- WARNING: don't use isPropM here because it relies on reduction, + -- which causes an infinite loop. + let isPrp = case getSort (defType def) of + Prop{} -> True + _ -> False + let irr = isPrp || isIrrelevant (defArgInfo def) + cdefn <- case theDef def of + _ | irr -> pure CAxiom _ | Just (defName def) == bPrimForce bEnv -> pure CForce _ | Just (defName def) == bPrimErase bEnv -> case telView' (defType def) of TelV tel _ | size tel == 5 -> pure CErase | otherwise -> pure COther -- Non-standard equality. Fall back to slow reduce. + _ | defBlocked def /= notBlocked_ -> pure COther -- Blocked definition Constructor{conSrcCon = c, conArity = n} -> pure CCon{cconSrcCon = c, cconArity = n} Function{funCompiled = Just cc, funClauses = _:_, funProjection = proj} -> pure CFun{ cfunCompiled = fastCompiledClauses bEnv cc @@ -210,14 +211,14 @@ "primToLower" -> mkPrim 1 $ charFun toLower "primCharToNat" -> mkPrim 1 $ \ [LitChar _ a] -> nat (fromIntegral (fromEnum a)) "primNatToChar" -> mkPrim 1 $ \ [LitNat _ a] -> char (toEnum $ fromIntegral $ a `mod` 0x110000) - "primShowChar" -> mkPrim 1 $ \ a -> string (show $ pretty a) + "primShowChar" -> mkPrim 1 $ \ [a] -> string (prettyShow a) -- Strings -- "primStringToList" -- We don't have the list builtins (but could have, TODO) -- "primStringFromList" -- and they are not literals "primStringAppend" -> mkPrim 2 $ \ [LitString _ a, LitString _ b] -> string (b ++ a) "primStringEquality" -> mkPrim 2 $ \ [LitString _ a, LitString _ b] -> bool (b == a) - "primShowString" -> mkPrim 1 $ \ a -> string (show $ pretty a) + "primShowString" -> mkPrim 1 $ \ [a] -> string (prettyShow a) -- "primErase" -- "primForce" @@ -303,13 +304,14 @@ -- ^ (if True) In case of non-canonical argument use catchAllBranch. } -noBranches :: FastCase a -noBranches = FBranches{ fprojPatterns = False - , fconBranches = Map.empty - , fsucBranch = Nothing - , flitBranches = Map.empty - , fcatchAllBranch = Nothing - , ffallThrough = False } +--UNUSED Liang-Ting Chen 2019-07-16 +--noBranches :: FastCase a +--noBranches = FBranches{ fprojPatterns = False +-- , fconBranches = Map.empty +-- , fsucBranch = Nothing +-- , flitBranches = Map.empty +-- , fcatchAllBranch = Nothing +-- , ffallThrough = False } -- | Case tree with bodies. @@ -412,8 +414,8 @@ rewr <- if rwr then instantiateRewriteRules =<< getRewriteRulesFor f else return [] compactDef bEnv info rewr - let flags = ReductionFlags{ allowNonTerminating = elem NonTerminatingReductions allowedReductions - , allowUnconfirmed = elem UnconfirmedReductions allowedReductions + let flags = ReductionFlags{ allowNonTerminating = NonTerminatingReductions `SmallSet.member` allowedReductions + , allowUnconfirmed = UnconfirmedReductions `SmallSet.member` allowedReductions , hasRewriting = rwr } ReduceM $ \ redEnv -> reduceTm redEnv bEnv (memoQName constInfo) norm flags v @@ -514,9 +516,9 @@ emptyEnv :: Env s emptyEnv = Env [] - -isEmptyEnv :: Env s -> Bool -isEmptyEnv (Env xs) = null xs +--UNUSED Liang-Ting Chen 2019-07-16 +--isEmptyEnv :: Env s -> Bool +--isEmptyEnv (Env xs) = null xs envSize :: Env s -> Int envSize (Env xs) = length xs @@ -564,7 +566,17 @@ infixr 2 :>, >: (>:) :: CatchAllFrame s -> MatchStack s -> MatchStack s -c >: cs :> cl = c : cs :> cl +(>:) c (cs :> cl) = c : cs :> cl +-- Previously written as: +-- c >: cs :> cl = c : cs :> cl +-- +-- However, some versions/tools fail to parse infix data constructors properly. +-- For example, stylish-haskell@0.9.2.1 fails with the following error: +-- Language.Haskell.Stylish.Parse.parseModule: could not parse +-- src/full/Agda/TypeChecking/Reduce/Fast.hs: ParseFailed (SrcLoc +-- ".hs" 625 1) "Parse error in pattern: " +-- +-- See https://ghc.haskell.org/trac/ghc/ticket/10018 which may be related. data CatchAllFrame s = CatchAll FastCompiledClauses (Spine s) -- ^ @CatchAll cc spine@. Case trees are not fully expanded, that is, @@ -755,7 +767,7 @@ _ -> __IMPOSSIBLE__ unusedPointerString :: String -unusedPointerString = show (Impossible __FILE__ __LINE__) +unusedPointerString = show (withFileAndLine Impossible) unusedPointer :: Pointer s unusedPointer = Pure (Closure (Value $ notBlocked ()) @@ -774,6 +786,9 @@ where -- Helpers to get information from the ReduceEnv. metaStore = redSt rEnv ^. stMetaStore + -- Are we currently instance searching. In that case we don't fail hard on missing clauses. This + -- is a (very unsatisfactory) work-around for #3870. + speculative = redSt rEnv ^. stConsideringInstance getMeta m = maybe __IMPOSSIBLE__ mvInstantiation (IntMap.lookup (metaId m) metaStore) partialDefs = runReduce getPartialDefs rewriteRules f = cdefRewriteRules (constInfo f) @@ -870,16 +885,20 @@ evalPointerAM (unArg v) [] (sucCtrl ctrl) -- Case: constructor. Perform beta reduction if projected from, otherwise return a value. - Con c i [] -> - evalIApplyAM spine ctrl $ - case splitAt ar spine of - (args, Proj _ p : spine') -> evalPointerAM (unArg arg) spine' ctrl -- Andreas #2170: fit argToDontCare here?! - where - fields = map unArg $ conFields c - Just n = List.elemIndex p fields - Apply arg = args !! n - _ -> rewriteAM (evalTrueValue (Con c' i []) env spine ctrl) - where CCon{cconSrcCon = c', cconArity = ar} = cdefDef (constInfo (conName c)) + Con c i [] + -- Constructors of types in Prop are not representex as + -- CCon, so this match might fail! + | CCon{cconSrcCon = c', cconArity = ar} <- cdefDef (constInfo (conName c)) -> + evalIApplyAM spine ctrl $ + case splitAt ar spine of + (args, Proj _ p : spine') + -> evalPointerAM (unArg arg) spine' ctrl -- Andreas #2170: fit argToDontCare here?! + where + fields = map unArg $ conFields c + Just n = List.elemIndex p fields + Apply arg = args !! n + _ -> rewriteAM (evalTrueValue (Con c' i []) env spine ctrl) + | otherwise -> runAM done -- Case: variable. Look up the variable in the environment and evaluate the resulting -- pointer. If the variable is not in the environment it's a free variable and we adjust the @@ -908,6 +927,7 @@ -- And we know the spine is empty since literals cannot be applied or projected. Lit{} -> runAM (evalTrueValue t emptyEnv [] ctrl) Pi{} -> runAM done + DontCare{} -> runAM done -- Case: non-empty spine. If the focused term has a non-empty spine, we shift the -- eliminations onto the spine. @@ -931,7 +951,6 @@ -- to slowReduceTerm for these. Level{} -> fallbackAM s Sort{} -> fallbackAM s - DontCare{} -> fallbackAM s Dummy{} -> fallbackAM s where done = Eval (mkValue (notBlocked ()) cl) ctrl @@ -1213,7 +1232,7 @@ (spine0, Proj o p : spine1) -> case lookupCon p bs <|> ((`lookupCon` bs) =<< op) of Nothing - | elem f partialDefs -> stuckMatch (NotBlocked MissingClauses ()) stack ctrl + | f `elem` partialDefs -> stuckMatch (NotBlocked MissingClauses ()) stack ctrl | otherwise -> __IMPOSSIBLE__ Just cc -> runAM (Match f cc (spine0 <> spine1) stack ctrl) where CFun{ cfunProjection = op } = cdefDef (constInfo p) @@ -1260,7 +1279,7 @@ -- Fall back to slow reduction. This happens if we encounter a definition that's not supported -- by the machine (like a primitive function that does not work on literals), or a term that is - -- not supported (Level, Sort, and DontCare at the moment). In this case we decode the current + -- not supported (Level and Sort at the moment). In this case we decode the current -- focus to a 'Term', call slow reduction and pack up the result in a value closure. If the top -- of the control stack is a 'NormaliseK' and the focus is a value closure (i.e. already in -- weak-head normal form) we call 'slowNormaliseArgs' and pop the 'NormaliseK' frame. Otherwise @@ -1329,14 +1348,16 @@ stuckMatch :: Blocked_ -> MatchStack s -> ControlStack s -> ST s (Blocked Term) stuckMatch blk (_ :> cl) ctrl = rewriteAM (Eval (mkValue blk cl) ctrl) - -- On a mismatch we find the the next 'CatchAll' on the control stack and + -- On a mismatch we find the next 'CatchAll' on the control stack and -- continue matching from there. If there isn't one we get an incomplete -- matching error (or get stuck if the function is marked partial). failedMatch :: QName -> MatchStack s -> ControlStack s -> ST s (Blocked Term) failedMatch f (CatchAll cc spine : stack :> cl) ctrl = runAM (Match f cc spine (stack :> cl) ctrl) failedMatch f ([] :> cl) ctrl - | elem f partialDefs = rewriteAM (Eval (mkValue (NotBlocked MissingClauses ()) cl) ctrl) - | otherwise = runReduce $ + -- Bad work-around for #3870: don't fail hard during instance search. + | speculative = rewriteAM (Eval (mkValue (NotBlocked MissingClauses ()) cl) ctrl) + | f `elem` partialDefs = rewriteAM (Eval (mkValue (NotBlocked MissingClauses ()) cl) ctrl) + | otherwise = runReduce $ traceSLn "impossible" 10 ("Incomplete pattern matching when applying " ++ show f) __IMPOSSIBLE__ diff --git a/src/full/Agda/TypeChecking/Reduce/Monad.hs b/src/full/Agda/TypeChecking/Reduce/Monad.hs --- a/src/full/Agda/TypeChecking/Reduce/Monad.hs +++ b/src/full/Agda/TypeChecking/Reduce/Monad.hs @@ -1,50 +1,34 @@ -{-# LANGUAGE CPP #-} {-# OPTIONS_GHC -fno-warn-orphans #-} module Agda.TypeChecking.Reduce.Monad ( constructorForm , enterClosure - , underAbstraction , underAbstraction_ - , addCtxTel , getConstInfo - , isInstantiatedMeta - , lookupMeta , askR, applyWhenVerboseS ) where import Prelude hiding (null) -import Control.Arrow ((***), first, second) -import Control.Applicative hiding (empty) import Control.Monad.Reader import qualified Data.IntMap as IntMap import qualified Data.Map as Map import Data.Maybe -import Data.Monoid -import Debug.Trace import System.IO.Unsafe import Agda.Syntax.Common -import Agda.Syntax.Position import Agda.Syntax.Internal import Agda.TypeChecking.Monad hiding - ( enterClosure, underAbstraction_, underAbstraction, addCtx, - isInstantiatedMeta, verboseS, typeOfConst, lookupMeta, lookupMeta' ) -import Agda.TypeChecking.Monad.Builtin hiding ( constructorForm ) + ( enterClosure, isInstantiatedMeta, verboseS, typeOfConst, lookupMeta, lookupMeta', constructorForm ) import Agda.TypeChecking.Substitute -import Agda.Interaction.Options -import qualified Agda.Utils.HashMap as HMap import Agda.Utils.Functor import Agda.Utils.Lens import Agda.Utils.Monad -import Agda.Utils.Null -import Agda.Utils.Pretty +import Agda.Utils.Pretty () --instance only -#include "undefined.h" import Agda.Utils.Impossible instance HasBuiltins ReduceM where @@ -57,9 +41,12 @@ ms <- getBuiltin' builtinSuc return $ fromMaybe v $ constructorForm' mz ms v -enterClosure :: Closure a -> (a -> ReduceM b) -> ReduceM b -enterClosure (Closure sig env scope cps x) f = localR (mapRedEnvSt inEnv inState) (f x) - where +enterClosure :: LensClosure a c => c -> (a -> ReduceM b) -> ReduceM b +enterClosure c | Closure _sig env scope cps x <- c ^. lensClosure = \case + -- The \case is a hack to correctly associate the where block to the rhs + -- rather than to the expression in the pattern guard. + f -> localR (mapRedEnvSt inEnv inState) (f x) + where inEnv e = env inState s = -- TODO: use the signature here? would that fix parts of issue 118? @@ -71,65 +58,27 @@ let (i, s') = nextFresh s withTCState (const s') (f i) -withFreshName :: (MonadReduce m) => Range -> ArgName -> (Name -> m a) -> m a -withFreshName r s k = withFreshR $ \i -> k (mkName r i s) - -withFreshName_ :: (MonadReduce m) => ArgName -> (Name -> m a) -> m a -withFreshName_ = withFreshName noRange - -addCtx :: (MonadReduce m) => Name -> Dom Type -> m a -> m a -addCtx x a ret = do - ctx <- asksTC $ map (fst . unDom) . envContext - let ce = (x,) <$> a - oldChkpt <- viewTC eCurrentCheckpoint - withFreshR $ \ chkpt -> - localTC (\e -> e { envContext = ce : envContext e - , envCurrentCheckpoint = chkpt - , envCheckpoints = Map.insert chkpt IdS $ - fmap (raise 1) (envCheckpoints e) - }) ret - -- let-bindings keep track of own their context - -addCtxTel :: (MonadReduce m) => Telescope -> m a -> m a -addCtxTel EmptyTel ret = ret -addCtxTel (ExtendTel t tel) ret = underAbstraction t tel $ \tel -> addCtxTel tel ret - -underAbstraction :: (MonadReduce m, Subst t a) => Dom Type -> Abs a -> (a -> m b) -> m b -underAbstraction _ (NoAbs _ v) f = f v -underAbstraction t a f = - withFreshName_ (realName $ absName a) $ \x -> addCtx x t $ f (absBody a) - where - realName s = if isNoName s then "x" else s - -underAbstraction_ :: (MonadReduce m, Subst t a) => Abs a -> (a -> m b) -> m b -underAbstraction_ = underAbstraction __DUMMY_DOM__ - -lookupMeta' :: MetaId -> ReduceM (Maybe MetaVariable) -lookupMeta' (MetaId i) = IntMap.lookup i <$> useR stMetaStore +instance MonadAddContext ReduceM where + withFreshName r s k = withFreshR $ \i -> k (mkName r i s) -lookupMeta :: MetaId -> ReduceM MetaVariable -lookupMeta = fromMaybe __IMPOSSIBLE__ <.> lookupMeta' + addCtx = defaultAddCtx -isInstantiatedMeta :: MetaId -> ReduceM Bool -isInstantiatedMeta i = do - mv <- lookupMeta i - return $ case mvInstantiation mv of - InstV{} -> True - _ -> False + addLetBinding' = defaultAddLetBinding' --- | Apply a function if a certain verbosity level is activated. --- --- Precondition: The level must be non-negative. -{-# SPECIALIZE applyWhenVerboseS :: VerboseKey -> Int -> (ReduceM a -> ReduceM a) -> ReduceM a-> ReduceM a #-} -applyWhenVerboseS :: HasOptions m => VerboseKey -> Int -> (m a -> m a) -> m a -> m a -applyWhenVerboseS k n f a = ifM (hasVerbosity k n) (f a) a + updateContext rho f ret = withFreshR $ \ chkpt -> + localTC (\e -> e { envContext = f $ envContext e + , envCurrentCheckpoint = chkpt + , envCheckpoints = Map.insert chkpt IdS $ + fmap (applySubst rho) (envCheckpoints e) + }) ret + -- let-bindings keep track of own their context instance MonadDebug ReduceM where - traceDebugMessage n s cont = do + traceDebugMessage k n s cont = do ReduceEnv env st <- askR unsafePerformIO $ do - _ <- runTCM env st $ displayDebugMessage n s + _ <- runTCM env st $ displayDebugMessage k n s return $ cont formatDebugMessage k n d = do @@ -137,6 +86,9 @@ unsafePerformIO $ do (s , _) <- runTCM env st $ formatDebugMessage k n d return $ return s + + verboseBracket k n s = applyWhenVerboseS k n $ + bracket_ (openVerboseBracket k n s) (const $ closeVerboseBracket k n) instance HasConstInfo ReduceM where getRewriteRulesFor = defaultGetRewriteRulesFor getTCState diff --git a/src/full/Agda/TypeChecking/Rewriting.hs b/src/full/Agda/TypeChecking/Rewriting.hs --- a/src/full/Agda/TypeChecking/Rewriting.hs +++ b/src/full/Agda/TypeChecking/Rewriting.hs @@ -1,5 +1,5 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE NondecreasingIndentation #-} +{-# LANGUAGE GADTs #-} {-# OPTIONS_GHC -fno-warn-orphans #-} @@ -46,29 +46,22 @@ import Prelude hiding (null) -import Control.Applicative hiding (empty) import Control.Monad -import Control.Monad.Reader (local, asks) -import Data.Foldable ( Foldable, foldMap ) import Data.IntSet (IntSet) import qualified Data.IntSet as IntSet import qualified Data.List as List -import Data.Monoid import Agda.Interaction.Options +import Agda.Syntax.Abstract.Name import Agda.Syntax.Common import Agda.Syntax.Internal as I +import Agda.Syntax.Internal.MetaVars import Agda.TypeChecking.Datatypes import Agda.TypeChecking.Monad -import Agda.TypeChecking.Monad.Builtin -import Agda.TypeChecking.Monad.Env -import Agda.TypeChecking.EtaExpand import Agda.TypeChecking.Free -import Agda.TypeChecking.Free.Lazy -import Agda.TypeChecking.MetaVars import Agda.TypeChecking.Conversion import qualified Agda.TypeChecking.Positivity.Occurrence as Pos import Agda.TypeChecking.Pretty @@ -76,23 +69,19 @@ import Agda.TypeChecking.Reduce import Agda.TypeChecking.Substitute import Agda.TypeChecking.Telescope +import Agda.TypeChecking.Rewriting.Confluence import Agda.TypeChecking.Rewriting.NonLinMatch -import qualified Agda.TypeChecking.Reduce.Monad as Red +import Agda.TypeChecking.Rewriting.NonLinPattern import Agda.TypeChecking.Warnings import Agda.Utils.Functor -import qualified Agda.Utils.HashMap as HMap -import Agda.Utils.Lens import Agda.Utils.List import Agda.Utils.Maybe import Agda.Utils.Monad import Agda.Utils.Null -import Agda.Utils.Singleton import Agda.Utils.Size -import Agda.Utils.Lens -import qualified Agda.Utils.HashMap as HMap +import qualified Agda.Utils.SmallSet as SmallSet -#include "undefined.h" import Agda.Utils.Impossible requireOptionRewriting :: TCM () @@ -143,15 +132,39 @@ let [a, b] = fmap snd <$> lastTwo return $ Just $ RelView tel delta a b core --- | Add @q : Γ → rel us lhs rhs@ as rewrite rule +-- | Check the given rewrite rules and add them to the signature. +addRewriteRules :: [QName] -> TCM () +addRewriteRules qs = do + + -- Check the rewrite rules + rews <- mapM checkRewriteRule qs + + -- Add rewrite rules to the signature + forM_ rews $ \rew -> do + let f = rewHead rew + matchables = getMatchables rew + reportSDoc "rewriting" 10 $ + "adding rule" <+> prettyTCM (rewName rew) <+> + "to the definition of" <+> prettyTCM f + reportSDoc "rewriting" 30 $ "matchable symbols: " <+> prettyTCM matchables + modifySignature $ addRewriteRulesFor f [rew] matchables + + -- Run confluence check for the new rules + -- (should be done after adding all rules, see #3795) + whenM (optConfluenceCheck <$> pragmaOptions) $ + checkConfluenceOfRules rews + + +-- | Check the validity of @q : Γ → rel us lhs rhs@ as rewrite rule -- @ -- Γ ⊢ lhs ↦ rhs : B -- @ --- to the signature where @B = A[us/Δ]@. +-- where @B = A[us/Δ]@. -- Remember that @rel : Δ → A → A → Set i@, so -- @rel us : (lhs rhs : A[us/Δ]) → Set i@. -addRewriteRule :: QName -> TCM () -addRewriteRule q = do +-- Returns the checked rewrite rule to be added to the signature. +checkRewriteRule :: QName -> TCM RewriteRule +checkRewriteRule q = do requireOptionRewriting let failNoBuiltin = typeError $ GenericError $ "Cannot add rewrite rule without prior BUILTIN REWRITE" @@ -167,8 +180,7 @@ ] -- We know that the type of rel is that of a relation. relV <- relView =<< do defType <$> getConstInfo rel - let RelView _tel delta a _a' _core = -- line break for CPP - fromMaybe __IMPOSSIBLE__ relV + let RelView _tel delta a _a' _core = fromMaybe __IMPOSSIBLE__ relV reportSDoc "rewriting" 30 $ do "rewrite relation at type " <+> do inTopContext $ prettyTCM (telFromList delta) <+> " |- " <+> do @@ -180,15 +192,20 @@ , prettyTCM gamma1 , " |- " <+> do addContext gamma1 $ prettyTCM core ] - let failureWrongTarget = typeError . GenericDocError =<< hsep + let failureWrongTarget :: TCM a + failureWrongTarget = typeError . GenericDocError =<< hsep [ prettyTCM q , " does not target rewrite relation" ] - let failureMetas = typeError . GenericDocError =<< hsep + let failureMetas :: TCM a + failureMetas = typeError . GenericDocError =<< hsep [ prettyTCM q , " is not a legal rewrite rule, since it contains unsolved meta variables" ] - let failureNotDefOrCon = typeError . GenericDocError =<< hsep + let failureNotDefOrCon :: TCM a + failureNotDefOrCon = typeError . GenericDocError =<< hsep [ prettyTCM q , " is not a legal rewrite rule, since the left-hand side is neither a defined symbol nor a constructor" ] - let failureFreeVars xs = typeError . GenericDocError =<< hsep + let failureFreeVars :: IntSet -> TCM a + failureFreeVars xs = typeError . GenericDocError =<< hsep [ prettyTCM q , " is not a legal rewrite rule, since the following variables are not bound by the left hand side: " , prettyList_ (map (prettyTCM . var) $ IntSet.toList xs) ] - let failureIllegalRule = typeError . GenericDocError =<< hsep + let failureIllegalRule :: TCM a + failureIllegalRule = typeError . GenericDocError =<< hsep [ prettyTCM q , " is not a legal rewrite rule" ] -- Check that type of q targets rel. @@ -214,13 +231,14 @@ -- 2017-06-18, Jesper: Unfold inlined definitions on the LHS. -- This is necessary to replace copies created by imports by their -- original definition. - lhs <- modifyAllowedReductions (const [InlineReductions]) $ normalise lhs + lhs <- modifyAllowedReductions (const $ SmallSet.singleton InlineReductions) $ normalise lhs -- Find head symbol f of the lhs, its type and its arguments. (f , hd , t , es) <- case lhs of Def f es -> do - t <- defType <$> getConstInfo f - return (f , Def f , t , es) + def <- getConstInfo f + checkAxFunOrCon f def + return (f , Def f , defType def , es) Con c ci vs -> do let hd = Con c ci ~(Just ((_ , _ , pars) , t)) <- getFullyAppliedConType c $ unDom b @@ -230,7 +248,7 @@ ifNotAlreadyAdded f $ do - rew <- addContext gamma1 $ do + addContext gamma1 $ do -- Normalize lhs args: we do not want to match redexes. es <- normalise es @@ -255,24 +273,17 @@ "variables free in the rewrite rule: " <+> text (show freeVars) unlessNull (freeVars IntSet.\\ boundVars) failureFreeVars - return $ RewriteRule q gamma f ps rhs (unDom b) - - reportSDoc "rewriting" 10 $ vcat - [ "considering rewrite rule " , prettyTCM rew ] - reportSDoc "rewriting" 90 $ vcat - [ "considering rewrite rule" , text (show rew) ] + let rew = RewriteRule q gamma f ps rhs (unDom b) - -- NO LONGER WORKS: - -- -- Check whether lhs can be rewritten with itself. - -- -- Otherwise, there are unbound variables in either gamma or rhs. - -- addContext gamma $ - -- unlessM (isJust <$> runReduceM (rewriteWith (Just b) lhs rew)) $ - -- failureFreeVars + reportSDoc "rewriting" 10 $ vcat + [ "checked rewrite rule" , prettyTCM rew ] + reportSDoc "rewriting" 90 $ vcat + [ "checked rewrite rule" , text (show rew) ] - -- Add rewrite rule gamma ⊢ lhs ↦ rhs : b for f. - addRewriteRules f [rew] + return rew _ -> failureWrongTarget + where checkNoLhsReduction :: QName -> Elims -> TCM () checkNoLhsReduction f es = do @@ -293,14 +304,28 @@ unless ok fail _ -> fail - ifNotAlreadyAdded :: QName -> TCM () -> TCM () + checkAxFunOrCon :: QName -> Definition -> TCM () + checkAxFunOrCon f def = case theDef def of + Axiom{} -> return () + Function{} -> return () + Constructor{} -> return () + AbstractDefn{} -> return () + Primitive{} -> return () -- TODO: is this fine? + _ -> typeError . GenericDocError =<< hsep + [ prettyTCM q , " is not a legal rewrite rule, since the head symbol" + , prettyTCM f , "is not a postulate, a function, or a constructor" + ] + + ifNotAlreadyAdded :: QName -> TCM RewriteRule -> TCM RewriteRule ifNotAlreadyAdded f cont = do rews <- getRewriteRulesFor f -- check if q is already an added rewrite rule - if any ((q ==) . rewName) rews then - genericWarning =<< do - "Rewrite rule " <+> prettyTCM q <+> " has already been added" - else cont + case List.find ((q ==) . rewName) rews of + Just rew -> do + genericWarning =<< do + "Rewrite rule " <+> prettyTCM q <+> " has already been added" + return rew + Nothing -> cont usedArgs :: [Pos.Occurrence] -> IntSet usedArgs occs = IntSet.fromList $ map snd $ usedIxs @@ -320,20 +345,13 @@ Var i [] | i < k -> (i :) <$> loop vs _ -> errorNotGeneral + errorNotGeneral :: TCM a errorNotGeneral = typeError . GenericDocError =<< vcat [ prettyTCM q <+> text " is not a legal rewrite rule, since the constructor parameters are not fully general:" , nest 2 $ text "Constructor: " <+> prettyTCM c , nest 2 $ text "Parameters: " <+> prettyList (map prettyTCM vs) ] --- | Append rewrite rules to a definition. -addRewriteRules :: QName -> RewriteRules -> TCM () -addRewriteRules f rews = do - reportSDoc "rewriting" 10 $ "rewrite rule ok, adding it to the definition of " <+> prettyTCM f - let matchables = getMatchables rews - reportSDoc "rewriting" 30 $ "matchable symbols: " <+> prettyTCM matchables - modifySignature $ addRewriteRulesFor f rews matchables - -- | @rewriteWith t f es rew@ where @f : t@ -- tries to rewrite @f es@ with @rew@, returning the reduct if successful. rewriteWith :: Type @@ -376,7 +394,7 @@ -- Andreas, 2018-09-08, issue #3211: -- discount module parameters for constructor heads _ -> __IMPOSSIBLE__ - loop block t rules =<< instantiateFull' es + loop block t rules =<< instantiateFull' es -- TODO: remove instantiateFull? else return $ NoReduction (block $> v `applyE` es) where @@ -397,71 +415,5 @@ Right w -> return $ YesReduction YesSimplification $ w `applyE` es2 | otherwise = loop (block `mappend` NotBlocked Underapplied ()) t rews es - ------------------------------------------------------------------------- --- * Auxiliary functions ------------------------------------------------------------------------- - -class NLPatVars a where - nlPatVarsUnder :: Int -> a -> IntSet - - nlPatVars :: a -> IntSet - nlPatVars = nlPatVarsUnder 0 - -instance (Foldable f, NLPatVars a) => NLPatVars (f a) where - nlPatVarsUnder k = foldMap $ nlPatVarsUnder k - -instance NLPatVars NLPType where - nlPatVarsUnder k (NLPType l a) = nlPatVarsUnder k l `IntSet.union` nlPatVarsUnder k a - -instance NLPatVars NLPat where - nlPatVarsUnder k p = - case p of - PVar i _ -> singleton $ i - k - PDef _ es -> nlPatVarsUnder k es - PWild -> empty - PLam _ p' -> nlPatVarsUnder (k+1) $ unAbs p' - PPi a b -> nlPatVarsUnder k a `IntSet.union` nlPatVarsUnder (k+1) (unAbs b) - PBoundVar _ es -> nlPatVarsUnder k es - PTerm{} -> empty - -rewArity :: RewriteRule -> Int -rewArity = length . rewPats - --- | Get all symbols that a rewrite rule matches against -class GetMatchables a where - getMatchables :: a -> [QName] - -instance (Foldable f, GetMatchables a) => GetMatchables (f a) where - getMatchables = foldMap getMatchables - -instance GetMatchables NLPat where - getMatchables p = - case p of - PVar _ _ -> empty - PWild -> empty - PDef f _ -> singleton f - PLam _ x -> empty - PPi a b -> empty - PBoundVar i es -> empty - PTerm _ -> empty -- should be safe (I hope) - -instance GetMatchables RewriteRule where - getMatchables = getMatchables . rewPats - --- Only computes free variables that are not bound (i.e. those in a PTerm) -instance Free NLPat where - freeVars' p = case p of - PVar _ _ -> mempty - PWild -> mempty - PDef _ es -> freeVars' es - PLam _ u -> freeVars' u - PPi a b -> freeVars' (a,b) - PBoundVar _ es -> freeVars' es - PTerm t -> freeVars' t - -instance Free NLPType where - freeVars' (NLPType l a) = - ifM ((IgnoreNot ==) <$> asks feIgnoreSorts) - {- then -} (freeVars' (l, a)) - {- else -} (freeVars' a) + rewArity :: RewriteRule -> Int + rewArity = length . rewPats diff --git a/src/full/Agda/TypeChecking/Rewriting/Clause.hs b/src/full/Agda/TypeChecking/Rewriting/Clause.hs new file mode 100644 --- /dev/null +++ b/src/full/Agda/TypeChecking/Rewriting/Clause.hs @@ -0,0 +1,77 @@ +{-# LANGUAGE TypeFamilies #-} + +module Agda.TypeChecking.Rewriting.Clause where + +import Data.Maybe + +import Agda.Syntax.Common +import Agda.Syntax.Internal +import Agda.Syntax.Position + +import Agda.TypeChecking.Monad + +import Agda.Utils.Functor +import Agda.Utils.Impossible +import Agda.Utils.Monad + +------------------------------------------------------------------------ +-- * Converting clauses to rewrite rules +------------------------------------------------------------------------ + +-- | Get all the clauses of a definition and convert them to rewrite +-- rules. +getClausesAsRewriteRules :: QName -> TCM [RewriteRule] +getClausesAsRewriteRules f = do + cls <- defClauses <$> getConstInfo f + forMaybeM (zip [1..] cls) $ \(i,cl) -> do + clname <- clauseQName f i + return $ clauseToRewriteRule f clname cl + +-- | Generate a sensible name for the given clause +clauseQName :: QName -> Int -> TCM QName +clauseQName f i = QName (qnameModule f) <$> clauseName (qnameName f) i + where + clauseName n i = freshName noRange (show n ++ "-clause" ++ show i) + +-- | @clauseToRewriteRule f q cl@ converts the clause @cl@ of the +-- function @f@ to a rewrite rule with name @q@. Returns @Nothing@ +-- if @clauseBody cl@ is @Nothing@. Precondition: @clauseType cl@ is +-- not @Nothing@. +clauseToRewriteRule :: QName -> QName -> Clause -> Maybe RewriteRule +clauseToRewriteRule f q cl = clauseBody cl <&> \rhs -> RewriteRule + { rewName = q + , rewContext = clauseTel cl + , rewHead = f + , rewPats = toNLPat $ namedClausePats cl + , rewRHS = rhs + , rewType = unArg $ fromMaybe __IMPOSSIBLE__ $ clauseType cl + } + +class ToNLPat a b where + toNLPat :: a -> b + + default toNLPat + :: ( ToNLPat a' b', Functor f, a ~ f a', b ~ f b') + => a -> b + toNLPat = fmap toNLPat + +instance ToNLPat a b => ToNLPat [a] [b] where +instance ToNLPat a b => ToNLPat (Dom a) (Dom b) where +instance ToNLPat a b => ToNLPat (Elim' a) (Elim' b) where +instance ToNLPat a b => ToNLPat (Abs a) (Abs b) where + +instance ToNLPat (Arg DeBruijnPattern) (Elim' NLPat) where + toNLPat (Arg ai p) = case p of + VarP _ x -> app $ PVar (dbPatVarIndex x) [] + DotP _ u -> app $ PTerm u + ConP c _ ps -> app $ PDef (conName c) $ toNLPat ps + LitP o l -> app $ PTerm $ Lit l + ProjP o f -> Proj o f + IApplyP _ u v x -> IApply (PTerm u) (PTerm v) $ PVar (dbPatVarIndex x) [] + DefP _ f ps -> app $ PDef f $ toNLPat ps + + where + app = Apply . Arg ai + +instance ToNLPat (NamedArg DeBruijnPattern) (Elim' NLPat) where + toNLPat = toNLPat . fmap namedThing diff --git a/src/full/Agda/TypeChecking/Rewriting/Confluence.hs b/src/full/Agda/TypeChecking/Rewriting/Confluence.hs new file mode 100644 --- /dev/null +++ b/src/full/Agda/TypeChecking/Rewriting/Confluence.hs @@ -0,0 +1,679 @@ +{-# LANGUAGE ScopedTypeVariables #-} +{-# LANGUAGE TypeFamilies #-} +{-# LANGUAGE NondecreasingIndentation #-} + +-- | Checking confluence of rewrite rules. +-- +-- Given a rewrite rule @f ps ↦ v@, we construct critical pairs +-- involving this as the main rule by searching for: +-- +-- 1. *Different* rules @f ps' ↦ v'@ where @ps@ and @ps'@ can be +-- unified@. +-- +-- 2. Subpatterns @g qs@ of @ps@ and rewrite rules @g qs' ↦ w@ where +-- @qs@ and @qs'@ can be unified. +-- +-- Each of these leads to a *critical pair* @v₁ <-- u --> v₂@, which +-- should satisfy @v₁ = v₂@. + +module Agda.TypeChecking.Rewriting.Confluence ( checkConfluenceOfRules , checkConfluenceOfClause ) where + +import Control.Applicative +import Control.Monad +import Control.Monad.Reader + +import Data.Function ( on ) +import Data.Functor ( ($>) ) +import Data.List ( elemIndex , tails ) +import qualified Data.Set as Set + +import Agda.Syntax.Common +import Agda.Syntax.Internal +import Agda.Syntax.Internal.MetaVars + +import Agda.TypeChecking.Constraints +import Agda.TypeChecking.Conversion +import Agda.TypeChecking.Datatypes +import Agda.TypeChecking.Free +import Agda.TypeChecking.Irrelevance ( workOnTypes ) +import Agda.TypeChecking.Level +import Agda.TypeChecking.MetaVars +import Agda.TypeChecking.Monad +import Agda.TypeChecking.Monad.Builtin +import Agda.TypeChecking.Pretty +import Agda.TypeChecking.Pretty.Warning +import Agda.TypeChecking.Records +import Agda.TypeChecking.Reduce +import Agda.TypeChecking.Rewriting.Clause +import Agda.TypeChecking.Rewriting.NonLinPattern +import Agda.TypeChecking.Sort +import Agda.TypeChecking.Substitute +import Agda.TypeChecking.Telescope +import Agda.TypeChecking.Warnings + +import Agda.Utils.Except +import Agda.Utils.Impossible +import Agda.Utils.List +import Agda.Utils.ListT +import Agda.Utils.Maybe +import Agda.Utils.Monad +import Agda.Utils.Singleton +import Agda.Utils.Size + + +-- ^ Check confluence of the given rewrite rules wrt all other rewrite +-- rules (also amongst themselves). +checkConfluenceOfRules :: [RewriteRule] -> TCM () +checkConfluenceOfRules = checkConfluenceOfRules' False + +-- ^ Check confluence of the given clause wrt rewrite rules of the +-- constructors it matches against +checkConfluenceOfClause :: QName -> Int -> Clause -> TCM () +checkConfluenceOfClause f i cl = do + fi <- clauseQName f i + whenJust (clauseToRewriteRule f fi cl) $ \rew -> do + checkConfluenceOfRules' True [rew] + let matchables = getMatchables rew + reportSDoc "rewriting.confluence" 30 $ + "Function" <+> prettyTCM f <+> "has matchable symbols" <+> prettyList_ (map prettyTCM matchables) + modifySignature $ setMatchableSymbols f matchables + +checkConfluenceOfRules' :: Bool -> [RewriteRule] -> TCM () +checkConfluenceOfRules' isClause rews = inTopContext $ inAbstractMode $ do + + forM_ (tails rews) $ listCase (return ()) $ \rew rewsRest -> do + + reportSDoc "rewriting.confluence" 10 $ + "Checking confluence of rule" <+> prettyTCM (rewName rew) + + let f = rewHead rew + qs = rewPats rew + tel = rewContext rew + def <- getConstInfo f + (fa , hdf) <- addContext tel $ makeHead def (rewType rew) + + -- Step 1: check other rewrite rules that overlap at top position + forMM_ (getRulesFor f isClause) $ \ rew' -> + unless (any (sameName rew') $ rew:rewsRest) $ + checkConfluenceTop hdf rew rew' + + -- Step 2: check other rewrite rules that overlap with a subpattern + -- of this rewrite rule + es <- nlPatToTerm qs + forMM_ (addContext tel $ allHolesList (fa, hdf) es) $ \ hole -> + caseMaybe (headView $ ohContents hole) __IMPOSSIBLE__ $ \ (g , hdg , _) -> do + forMM_ (getRulesFor g isClause) $ \rew' -> + unless (any (sameName rew') rewsRest) $ + checkConfluenceSub hdf hdg rew rew' hole + + -- Step 3: check other rewrite rules that have a subpattern which + -- overlaps with this rewrite rule + forM_ (defMatchable def) $ \ g -> do + forMM_ (getClausesAndRewriteRulesFor g) $ \ rew' -> do + unless (any (sameName rew') rewsRest) $ do + es' <- nlPatToTerm (rewPats rew') + let tel' = rewContext rew' + def' <- getConstInfo g + (ga , hdg) <- addContext tel' $ makeHead def' (rewType rew') + forMM_ (addContext tel' $ allHolesList (ga , hdg) es') $ \ hole -> + caseMaybe (headView $ ohContents hole) __IMPOSSIBLE__ $ \ (f' , _ , _) -> + when (f == f') $ checkConfluenceSub hdg hdf rew' rew hole + + where + + sameName = (==) `on` rewName + + -- Check confluence of two rewrite rules that have the same head symbol, + -- e.g. @f ps --> a@ and @f ps' --> b@. + checkConfluenceTop :: (Elims -> Term) -> RewriteRule -> RewriteRule -> TCM () + checkConfluenceTop hd rew1 rew2 = + traceCall (CheckConfluence (rewName rew1) (rewName rew2)) $ + localTCStateSavingWarnings $ do + + sub1 <- makeMetaSubst $ rewContext rew1 + sub2 <- makeMetaSubst $ rewContext rew2 + + let f = rewHead rew1 -- == rewHead rew2 + a1 = applySubst sub1 $ rewType rew1 + a2 = applySubst sub2 $ rewType rew2 + + es1 <- applySubst sub1 <$> nlPatToTerm (rewPats rew1) + es2 <- applySubst sub2 <$> nlPatToTerm (rewPats rew2) + + -- Make sure we are comparing eliminations with the same arity + -- (see #3810). + let n = min (size es1) (size es2) + (es1' , es1r) = splitAt n es1 + (es2' , es2r) = splitAt n es2 + + lhs1 = hd $ es1' ++ es2r + lhs2 = hd $ es2' ++ es1r + + -- Use type of rewrite rule with the most eliminations + a | null es1r = a2 + | otherwise = a1 + + reportSDoc "rewriting.confluence" 20 $ sep + [ "Considering potential critical pair at top-level: " + , nest 2 $ prettyTCM $ lhs1, " =?= " + , nest 2 $ prettyTCM $ lhs2 , " : " , nest 2 $ prettyTCM a + ] + + maybeCriticalPair <- tryUnification lhs1 lhs2 $ do + -- Unify the left-hand sides of both rewrite rules + fa <- defType <$> getConstInfo f + fpol <- getPolarity' CmpEq f + onlyReduceTypes $ + compareElims fpol [] fa (hd []) es1' es2' + + -- Get the rhs of both rewrite rules (after unification). In + -- case of different arities, add additional arguments from + -- one side to the other side. + let rhs1 = applySubst sub1 (rewRHS rew1) `applyE` es2r + rhs2 = applySubst sub2 (rewRHS rew2) `applyE` es1r + + return (rhs1 , rhs2) + + whenJust maybeCriticalPair $ \ (rhs1 , rhs2) -> + checkCriticalPair a hd (es1' ++ es2r) rhs1 rhs2 + + -- Check confluence between two rules that overlap at a subpattern, + -- e.g. @f ps[g qs] --> a@ and @g qs' --> b@. + checkConfluenceSub :: (Elims -> Term) -> (Elims -> Term) -> RewriteRule -> RewriteRule -> OneHole Elims -> TCM () + checkConfluenceSub hdf hdg rew1 rew2 hole0 = + traceCall (CheckConfluence (rewName rew1) (rewName rew2)) $ + localTCStateSavingWarnings $ do + + sub1 <- makeMetaSubst $ rewContext rew1 + + let f = rewHead rew1 + bvTel0 = ohBoundVars hole0 + k = size bvTel0 + b0 = applySubst (liftS k sub1) $ ohType hole0 + (g,_,es0) = fromMaybe __IMPOSSIBLE__ $ headView $ + applySubst (liftS k sub1) $ ohContents hole0 + qs2 = rewPats rew2 + + -- If the second rewrite rule has more eliminations than the + -- subpattern of the first rule, the only chance of overlap is + -- by eta-expanding the subpattern of the first rule. + hole1 <- addContext bvTel0 $ + forceEtaExpansion b0 (hdg es0) $ drop (size es0) qs2 + + verboseS "rewriting.confluence.eta" 30 $ + unless (size es0 == size qs2) $ + addContext bvTel0 $ + reportSDoc "rewriting.confluence.eta" 30 $ vcat + [ "forceEtaExpansion result:" + , nest 2 $ "bound vars: " <+> prettyTCM (ohBoundVars hole1) + , nest 2 $ "hole contents: " <+> addContext (ohBoundVars hole1) (prettyTCM $ ohContents hole1) + ] + + let hole = hole1 `composeHole` hole0 + (g,_,es') = fromMaybe __IMPOSSIBLE__ $ headView $ ohContents hole -- g == rewHead rew2 + bvTel = ohBoundVars hole + plug = ohPlugHole hole + + sub2 <- addContext bvTel $ makeMetaSubst $ rewContext rew2 + + let es1 = applySubst (liftS (size bvTel) sub1) es' + es2 <- applySubst sub2 <$> nlPatToTerm (rewPats rew2) + + -- Make sure we are comparing eliminations with the same arity + -- (see #3810). Because we forced eta-expansion of es1, we + -- know that it is at least as long as es2. + when (size es1 < size es2) __IMPOSSIBLE__ + let n = size es2 + (es1' , es1r) = splitAt n es1 + + let lhs1 = applySubst sub1 $ hdf $ plug $ hdg es1 + lhs2 = applySubst sub1 $ hdf $ plug $ hdg $ es2 ++ es1r + a = applySubst sub1 $ rewType rew1 + + reportSDoc "rewriting.confluence" 20 $ sep + [ "Considering potential critical pair at subpattern: " + , nest 2 $ prettyTCM $ lhs1 , " =?= " + , nest 2 $ prettyTCM $ lhs2 , " : " , nest 2 $ prettyTCM a + ] + + maybeCriticalPair <- tryUnification lhs1 lhs2 $ do + -- Unify the subpattern of the first rewrite rule with the lhs + -- of the second one + ga <- defType <$> getConstInfo g + gpol <- getPolarity' CmpEq g + onlyReduceTypes $ addContext bvTel $ + compareElims gpol [] ga (hdg []) es1' es2 + + -- Right-hand side of first rewrite rule (after unification) + let rhs1 = applySubst sub1 $ rewRHS rew1 + + -- Left-hand side of first rewrite rule, with subpattern + -- rewritten by the second rewrite rule + let w = applySubst sub2 (rewRHS rew2) `applyE` es1r + reportSDoc "rewriting.confluence" 30 $ sep + [ "Plugging hole with w = " + , nest 2 $ addContext bvTel $ prettyTCM w + ] + let rhs2 = applySubst sub1 $ hdf $ plug w + + return (rhs1 , rhs2) + + whenJust maybeCriticalPair $ \ (rhs1 , rhs2) -> + checkCriticalPair a hdf (applySubst sub1 $ plug $ hdg es1) rhs1 rhs2 + + headView :: Term -> Maybe (QName, Elims -> Term, Elims) + headView (Def f es) = Just (f , Def f , es) + headView (Con c ci es) = Just (conName c , Con c ci , es) + headView _ = Nothing + + makeHead :: Definition -> Type -> TCM (Type , Elims -> Term) + makeHead def a = case theDef def of + Constructor{ conSrcCon = ch } -> do + ca <- snd . fromMaybe __IMPOSSIBLE__ <$> getFullyAppliedConType ch a + return (ca , Con ch ConOSystem) + -- For record projections @f : R Δ → A@, we rely on the invariant + -- that any clause is fully general in the parameters, i.e. it + -- is quantified over the parameter telescope @Δ@ + Function { funProjection = Just proj } -> do + let f = projOrig proj + r = unArg $ projFromType proj + rtype <- defType <$> getConstInfo r + TelV ptel _ <- telView rtype + n <- getContextSize + let pars :: Args + pars = raise (n - size ptel) $ teleArgs ptel + ftype <- defType def `piApplyM` pars + return (ftype , Def f) + _ -> return (defType def , Def $ defName def) + + getClausesAndRewriteRulesFor :: QName -> TCM [RewriteRule] + getClausesAndRewriteRulesFor f = + (++) <$> getClausesAsRewriteRules f <*> getRewriteRulesFor f + + getRulesFor :: QName -> Bool -> TCM [RewriteRule] + getRulesFor f isClause + | isClause = getRewriteRulesFor f + | otherwise = getClausesAndRewriteRulesFor f + + -- Build a substitution that replaces all variables in the given + -- telescope by fresh metavariables. + makeMetaSubst :: (MonadMetaSolver m) => Telescope -> m Substitution + makeMetaSubst gamma = parallelS . reverse . map unArg <$> newTelMeta gamma + + -- Try to run the TCM action, return @Just x@ if it succeeds with + -- result @x@ or @Nothing@ if it throws a type error. Abort if + -- there are any constraints. + tryUnification :: Term -> Term -> TCM a -> TCM (Maybe a) + tryUnification lhs1 lhs2 f = (Just <$> f) + `catchError` \case + err@TypeError{} -> do + reportSDoc "rewriting.confluence" 20 $ vcat + [ "Unification failed with error: " + , nest 2 $ prettyTCM err + ] + return Nothing + err -> throwError err + `ifNoConstraints` return $ \pid _ -> do + cs <- getConstraintsForProblem pid + prettyCs <- prettyInterestingConstraints cs + warning $ RewriteMaybeNonConfluent lhs1 lhs2 prettyCs + return Nothing + + checkCriticalPair + :: Type -- Type of the critical pair + -> (Elims -> Term) -- Head of lhs + -> Elims -- Eliminations of lhs + -> Term -- First reduct + -> Term -- Second reduct + -> TCM () + checkCriticalPair a hd es rhs1 rhs2 = do + + (a,es,rhs1,rhs2) <- instantiateFull (a,es,rhs1,rhs2) + + let ms = Set.toList $ allMetas singleton $ (a,es,rhs1,rhs2) + + reportSDoc "rewriting.confluence" 30 $ sep + [ "Abstracting over metas: " + , prettyList_ (map (text . show) ms) + ] + (gamma , (a,es,rhs1,rhs2)) <- fromMaybe __IMPOSSIBLE__ <$> + abstractOverMetas ms (a,es,rhs1,rhs2) + + addContext gamma $ reportSDoc "rewriting.confluence" 10 $ sep + [ "Found critical pair: " , nest 2 $ prettyTCM rhs1 + , " =?= " , nest 2 $ prettyTCM rhs2 + , " : " , nest 2 $ prettyTCM a ] + + addContext gamma $ do + dontAssignMetas $ noConstraints $ equalTerm a rhs1 rhs2 + `catchError` \case + TypeError s err -> do + prettyErr <- withTCState (const s) $ prettyTCM err + warning $ RewriteNonConfluent (hd es) rhs1 rhs2 prettyErr + err -> throwError err + +-- | Given metavariables ms and some x, construct a telescope Γ and +-- replace all occurrences of the given metavariables in @x@ by +-- normal variables from Γ. Returns @Nothing@ if metas have cyclic +-- dependencies. +abstractOverMetas :: (MetasToVars a) => [MetaId] -> a -> TCM (Maybe (Telescope, a)) +abstractOverMetas ms x = do + + -- Sort metas in dependency order + forMM (dependencySortMetas ms) $ \ms' -> do + + -- Get types and suggested names of metas + as <- forM ms' getMetaType + ns <- forM ms' getMetaNameSuggestion + + -- Construct telescope (still containing the metas) + let gamma = unflattenTel ns $ map defaultDom as + + -- Replace metas by variables + let n = size ms' + metaIndex x = (n-1-) <$> elemIndex x ms' + runReaderT (metasToVars (gamma, x)) metaIndex + +-- ^ A @OneHole p@ is a @p@ with a subpattern @f ps@ singled out. +data OneHole a = OneHole + { ohBoundVars :: Telescope -- Telescope of bound variables at the hole + , ohType :: Type -- Type of the term in the hole + , ohPlugHole :: Term -> a -- Plug the hole with some term + , ohContents :: Term -- The term in the hole + } deriving (Functor) + +-- | The trivial hole +idHole :: Type -> Term -> OneHole Term +idHole a v = OneHole EmptyTel a id v + +-- | Plug a hole with another hole +composeHole :: OneHole Term -> OneHole a -> OneHole a +composeHole inner outer = OneHole + { ohBoundVars = ohBoundVars outer `abstract` ohBoundVars inner + , ohType = ohType inner + , ohPlugHole = ohPlugHole outer . ohPlugHole inner + , ohContents = ohContents inner + } + +ohAddBV :: ArgName -> Dom Type -> OneHole a -> OneHole a +ohAddBV x a oh = oh { ohBoundVars = ExtendTel a $ Abs x $ ohBoundVars oh } + +-- ^ Given a @p : a@, @allHoles p@ lists all the possible +-- decompositions @p = p'[(f ps)/x]@. +class (Subst Term p , Free p) => AllHoles p where + type PType p + allHoles :: (Alternative m , MonadReduce m, MonadAddContext m, HasBuiltins m, HasConstInfo m) + => PType p -> p -> m (OneHole p) + +allHoles_ + :: ( Alternative m , MonadReduce m, MonadAddContext m, HasBuiltins m, HasConstInfo m, MonadDebug m + , AllHoles p , PType p ~ () ) + => p -> m (OneHole p) +allHoles_ = allHoles () + +allHolesList + :: ( MonadReduce m, MonadAddContext m, HasBuiltins m, HasConstInfo m , AllHoles p) + => PType p -> p -> m [OneHole p] +allHolesList a = sequenceListT . allHoles a + +-- | Given a term @v : a@ and eliminations @es@, force eta-expansion +-- of @v@ to match the structure (Apply/Proj) of the eliminations. +-- +-- Examples: +-- +-- 1. @v : _A@ and @es = [$ w]@: this will instantiate +-- @_A := (x : _A1) → _A2@ and return the @OneHole Term@ +-- @λ x → [v x]@. +-- +-- 2. @v : _A@ and @es = [.fst]@: this will instantiate +-- @_A := _A1 × _A2@ and return the @OneHole Term@ +-- @([v .fst]) , (v .snd)@. +forceEtaExpansion :: Type -> Term -> [Elim' a] -> TCM (OneHole Term) +forceEtaExpansion a v [] = return $ idHole a v +forceEtaExpansion a v (e:es) = case e of + + Apply (Arg i w) -> do + + -- Force a to be a pi type + reportSDoc "rewriting.confluence.eta" 40 $ fsep + [ "Forcing" , prettyTCM v , ":" , prettyTCM a , "to take one more argument" ] + dom <- defaultArgDom i <$> newTypeMeta_ + cod <- addContext dom $ newTypeMeta_ + equalType a $ mkPi (("x",) <$> dom) cod + + -- Construct body of eta-expansion + let body = raise 1 v `apply` [Arg i $ var 0] + + -- Continue with remaining eliminations + addContext dom $ ohAddBV "x" dom . fmap (Lam i . mkAbs "x") <$> + forceEtaExpansion cod body es + + Proj o f -> do + + -- Force a to be the right record type for projection by f + reportSDoc "rewriting.confluence.eta" 40 $ fsep + [ "Forcing" , prettyTCM v , ":" , prettyTCM a , "to be projectible by" , prettyTCM f ] + r <- fromMaybe __IMPOSSIBLE__ <$> getRecordOfField f + rdef <- getConstInfo r + let ra = defType rdef + pars <- newArgsMeta ra + s <- ra `piApplyM` pars >>= \s -> ifIsSort s return __IMPOSSIBLE__ + equalType a $ El s (Def r $ map Apply pars) + + -- Eta-expand v at record type r, and get field corresponding to f + (_ , c , ci , fields) <- etaExpandRecord_ r pars (theDef rdef) v + let fs = map argFromDom $ recFields $ theDef rdef + i = fromMaybe __IMPOSSIBLE__ $ elemIndex f $ map unArg fs + fContent = unArg $ fromMaybe __IMPOSSIBLE__ $ fields !!! i + fUpdate w = Con c ci $ map Apply $ updateAt i (w <$) fields + + -- Get type of field corresponding to f + ~(Just (El _ (Pi b c))) <- getDefType f =<< reduce a + let fa = c `absApp` v + + -- Continue with remaining eliminations + fmap fUpdate <$> forceEtaExpansion fa fContent es + + IApply{} -> __IMPOSSIBLE__ -- Not yet implemented + +-- ^ Instances for @AllHoles@ + +instance AllHoles p => AllHoles (Arg p) where + type PType (Arg p) = Dom (PType p) + allHoles a x = fmap (x $>) <$> allHoles (unDom a) (unArg x) + +instance AllHoles p => AllHoles (Dom p) where + type PType (Dom p) = PType p + allHoles a x = fmap (x $>) <$> allHoles a (unDom x) + +instance AllHoles (Abs Term) where + type PType (Abs Term) = (Dom Type , Abs Type) + allHoles (dom , a) x = addContext (absName x , dom) $ + ohAddBV (absName a) dom . fmap (mkAbs $ absName x) <$> + allHoles (absBody a) (absBody x) + +instance AllHoles (Abs Type) where + type PType (Abs Type) = Dom Type + allHoles dom a = addContext (absName a , dom) $ + ohAddBV (absName a) dom . fmap (mkAbs $ absName a) <$> + allHoles_ (absBody a) + +instance AllHoles Elims where + type PType Elims = (Type , Elims -> Term) + allHoles (a,hd) [] = empty + allHoles (a,hd) (e:es) = do + reportSDoc "rewriting.confluence.hole" 65 $ fsep + [ "Head symbol" , prettyTCM (hd []) , ":" , prettyTCM a + , "is eliminated by" , prettyTCM e + ] + case e of + Apply x -> do + ~(Pi b c) <- unEl <$> reduce a + let a' = c `absApp` unArg x + hd' = hd . (e:) + (fmap ((:es) . Apply) <$> allHoles b x) + <|> (fmap (e:) <$> allHoles (a' , hd') es) + Proj o f -> do + ~(Just (El _ (Pi b c))) <- getDefType f =<< reduce a + let a' = c `absApp` hd [] + hd' <- applyE <$> applyDef o f (argFromDom b $> hd []) + fmap (e:) <$> allHoles (a' , hd') es + IApply x y u -> __IMPOSSIBLE__ -- Not yet implemented + +instance AllHoles Type where + type PType Type = () + allHoles _ (El s a) = workOnTypes $ + fmap (El s) <$> allHoles (sort s) a + +instance AllHoles Term where + type PType Term = Type + allHoles a u = do + reportSDoc "rewriting.confluence.hole" 60 $ fsep + [ "Getting holes of term" , prettyTCM u , ":" , prettyTCM a ] + case u of + Var i es -> do + ai <- typeOfBV i + fmap (Var i) <$> allHoles (ai , Var i) es + Lam i u -> do + ~(Pi b c) <- unEl <$> reduce a + fmap (Lam i) <$> allHoles (b,c) u + Lit l -> empty + v@(Def f es) -> do + fa <- defType <$> getConstInfo f + pure (idHole a v) + <|> (fmap (Def f) <$> allHoles (fa , Def f) es) + v@(Con c ci es) -> do + ca <- snd . fromMaybe __IMPOSSIBLE__ <$> do + getFullyAppliedConType c =<< reduce a + pure (idHole a v) + <|> (fmap (Con c ci) <$> allHoles (ca , Con c ci) es) + Pi a b -> + (fmap (\a -> Pi a b) <$> allHoles_ a) <|> + (fmap (\b -> Pi a b) <$> allHoles a b) + Sort s -> fmap Sort <$> allHoles_ s + Level l -> fmap Level <$> allHoles_ l + MetaV{} -> __IMPOSSIBLE__ + DontCare{} -> empty + Dummy{} -> empty + +instance AllHoles Sort where + type PType Sort = () + allHoles _ = \case + Type l -> fmap Type <$> allHoles_ l + Prop l -> fmap Prop <$> allHoles_ l + Inf -> empty + SizeUniv -> empty + PiSort{} -> __IMPOSSIBLE__ + FunSort{} -> __IMPOSSIBLE__ + UnivSort{} -> __IMPOSSIBLE__ + MetaS{} -> __IMPOSSIBLE__ + DefS f es -> do + fa <- defType <$> getConstInfo f + fmap (DefS f) <$> allHoles (fa , Def f) es + DummyS{} -> empty + +instance AllHoles Level where + type PType Level = () + allHoles _ (Max n ls) = fmap (Max n) <$> allHoles_ ls + +instance AllHoles [PlusLevel] where + type PType [PlusLevel] = () + allHoles _ [] = empty + allHoles _ (l:ls) = + (fmap (:ls) <$> allHoles_ l) + <|> (fmap (l:) <$> allHoles_ ls) + +instance AllHoles PlusLevel where + type PType PlusLevel = () + allHoles _ (Plus n l) = fmap (Plus n) <$> allHoles_ l + +instance AllHoles LevelAtom where + type PType LevelAtom = () + allHoles _ l = do + la <- levelType + case l of + MetaLevel{} -> __IMPOSSIBLE__ + BlockedLevel{} -> __IMPOSSIBLE__ + NeutralLevel b u -> fmap (NeutralLevel b) <$> allHoles la u + UnreducedLevel u -> fmap UnreducedLevel <$> allHoles la u + + +-- | Convert metavariables to normal variables. Warning: doesn't +-- convert sort metas. +class MetasToVars a where + metasToVars + :: (MonadReader (MetaId -> Maybe Nat) m , HasBuiltins m) + => a -> m a + + default metasToVars + :: ( MetasToVars a', Traversable f, a ~ f a' + , MonadReader (MetaId -> Maybe Nat) m , HasBuiltins m) + => a -> m a + metasToVars = traverse metasToVars + +instance MetasToVars a => MetasToVars [a] where +instance MetasToVars a => MetasToVars (Arg a) where +instance MetasToVars a => MetasToVars (Dom a) where +instance MetasToVars a => MetasToVars (Elim' a) where + +instance MetasToVars a => MetasToVars (Abs a) where + metasToVars (Abs i x) = Abs i <$> local (fmap succ .) (metasToVars x) + metasToVars (NoAbs i x) = NoAbs i <$> metasToVars x + +instance MetasToVars Term where + metasToVars = \case + Var i es -> Var i <$> metasToVars es + Lam i u -> Lam i <$> metasToVars u + Lit l -> Lit <$> pure l + Def f es -> Def f <$> metasToVars es + Con c i es -> Con c i <$> metasToVars es + Pi a b -> Pi <$> metasToVars a <*> metasToVars b + Sort s -> Sort <$> metasToVars s + Level l -> Level <$> metasToVars l + MetaV x es -> ($ x) <$> ask >>= \case + Just i -> Var i <$> metasToVars es + Nothing -> MetaV x <$> metasToVars es + DontCare u -> DontCare <$> metasToVars u + Dummy s es -> Dummy s <$> metasToVars es + +instance MetasToVars Type where + metasToVars (El s t) = El <$> metasToVars s <*> metasToVars t + +instance MetasToVars Sort where + metasToVars = \case + Type l -> Type <$> metasToVars l + Prop l -> Prop <$> metasToVars l + Inf -> pure Inf + SizeUniv -> pure SizeUniv + PiSort s t -> PiSort <$> metasToVars s <*> metasToVars t + FunSort s t -> FunSort <$> metasToVars s <*> metasToVars t + UnivSort s -> UnivSort <$> metasToVars s + MetaS x es -> MetaS x <$> metasToVars es + DefS f es -> DefS f <$> metasToVars es + DummyS s -> pure $ DummyS s + +instance MetasToVars Level where + metasToVars (Max n ls) = Max n <$> metasToVars ls + +instance MetasToVars PlusLevel where + metasToVars (Plus n x) = Plus n <$> metasToVars x + +instance MetasToVars LevelAtom where + metasToVars = \case + MetaLevel m es -> NeutralLevel mempty <$> metasToVars (MetaV m es) + BlockedLevel _ u -> UnreducedLevel <$> metasToVars u + NeutralLevel nb u -> NeutralLevel nb <$> metasToVars u + UnreducedLevel u -> UnreducedLevel <$> metasToVars u + +instance MetasToVars a => MetasToVars (Tele a) where + metasToVars EmptyTel = pure EmptyTel + metasToVars (ExtendTel a tel) = ExtendTel <$> metasToVars a <*> metasToVars tel + +instance (MetasToVars a, MetasToVars b) => MetasToVars (a,b) where + metasToVars (x,y) = (,) <$> metasToVars x <*> metasToVars y + +instance (MetasToVars a, MetasToVars b, MetasToVars c) => MetasToVars (a,b,c) where + metasToVars (x,y,z) = (,,) <$> metasToVars x <*> metasToVars y <*> metasToVars z + +instance (MetasToVars a, MetasToVars b, MetasToVars c, MetasToVars d) => MetasToVars (a,b,c,d) where + metasToVars (x,y,z,w) = (,,,) <$> metasToVars x <*> metasToVars y <*> metasToVars z <*> metasToVars w diff --git a/src/full/Agda/TypeChecking/Rewriting/NonLinMatch.hs b/src/full/Agda/TypeChecking/Rewriting/NonLinMatch.hs --- a/src/full/Agda/TypeChecking/Rewriting/NonLinMatch.hs +++ b/src/full/Agda/TypeChecking/Rewriting/NonLinMatch.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE NondecreasingIndentation #-} {-# LANGUAGE UndecidableInstances #-} @@ -24,38 +23,29 @@ import Prelude hiding (null, sequence) -import Control.Arrow (first, second) import Control.Monad.State -import Debug.Trace -import System.IO.Unsafe - import Data.Maybe -import Data.Monoid -import Data.Traversable (Traversable,traverse) import Data.IntMap (IntMap) import qualified Data.IntMap as IntMap import Data.IntSet (IntSet) import qualified Data.IntSet as IntSet -import Data.Monoid -import qualified Data.Set as Set -import Data.Set (Set) import Agda.Syntax.Common -import qualified Agda.Syntax.Common as C import Agda.Syntax.Internal +import Agda.Syntax.Internal.MetaVars +import Agda.TypeChecking.Conversion.Pure import Agda.TypeChecking.Datatypes -import Agda.TypeChecking.EtaContract import Agda.TypeChecking.Free import Agda.TypeChecking.Free.Reduce +import Agda.TypeChecking.Irrelevance (workOnTypes, isPropM) import Agda.TypeChecking.Level -import Agda.TypeChecking.Monad -import Agda.TypeChecking.Monad.Builtin (getBuiltin', builtinLevel, primLevelSuc, primLevelMax) +import Agda.TypeChecking.Monad hiding (constructorForm) import Agda.TypeChecking.Pretty import Agda.TypeChecking.Records import Agda.TypeChecking.Reduce -import Agda.TypeChecking.Reduce.Monad as Red +import Agda.TypeChecking.Reduce.Monad import Agda.TypeChecking.Substitute import Agda.TypeChecking.Telescope @@ -68,145 +58,10 @@ import Agda.Utils.Monad import Agda.Utils.Null import Agda.Utils.Permutation -import Agda.Utils.Singleton import Agda.Utils.Size -#include "undefined.h" import Agda.Utils.Impossible --- | Turn a term into a non-linear pattern, treating the --- free variables as pattern variables. --- The first argument indicates the relevance we are working under: if this --- is Irrelevant, then we construct a pattern that never fails to match. --- The second argument is the number of bound variables (from pattern lambdas). --- The third argument is the type of the term. - -class PatternFrom t a b where - patternFrom :: Relevance -> Int -> t -> a -> TCM b - -instance (PatternFrom t a b) => PatternFrom (Dom t) (Arg a) (Arg b) where - patternFrom r k t u = let r' = r `composeRelevance` getRelevance u - in traverse (patternFrom r' k $ unDom t) u - -instance PatternFrom (Type, Term) Elims [Elim' NLPat] where - patternFrom r k (t,hd) = \case - [] -> return [] - (Apply u : es) -> do - ~(Pi a b) <- reduce $ unEl t - p <- patternFrom r k a u - t' <- t `piApplyM` u - let hd' = hd `apply` [ u ] - ps <- patternFrom r k (t',hd') es - return $ Apply p : ps - (IApply x y u : es) -> __IMPOSSIBLE__ -- TODO - (Proj o f : es) -> do - ~(Just (El _ (Pi a b))) <- getDefType f =<< reduce t - let t' = b `absApp` hd - hd' <- applyDef o f (argFromDom a $> hd) - ps <- patternFrom r k (t',hd') es - return $ Proj o f : ps - -instance (PatternFrom t a b) => PatternFrom t (Dom a) (Dom b) where - patternFrom r k t = traverse $ patternFrom r k t - -instance PatternFrom () Type NLPType where - patternFrom r k _ a = NLPType <$> patternFrom r k () (getSort a) - <*> patternFrom r k (sort $ getSort a) (unEl a) - -instance PatternFrom () Sort NLPat where - patternFrom r k _ s = do - s <- reduce s - let done = return PWild - case s of - Type l -> do - t <- levelType - patternFrom Irrelevant k t (Level l) - Prop l -> done --TODO - Inf -> done - SizeUniv -> done - PiSort _ _ -> __IMPOSSIBLE__ - UnivSort _ -> __IMPOSSIBLE__ - MetaS{} -> __IMPOSSIBLE__ - DefS{} -> done - DummyS s -> do - reportSLn "impossible" 10 $ unlines - [ "patternFrom: hit dummy sort with content:" - , s - ] - __IMPOSSIBLE__ - -instance PatternFrom Type Term NLPat where - patternFrom r k t v = do - t <- reduce t - etaRecord <- isEtaRecordType t - v <- unLevel =<< reduce v - reportSDoc "rewriting.build" 60 $ sep - [ "building a pattern from term v = " <+> prettyTCM v - , " of type " <+> prettyTCM t - ] - let done = if isIrrelevant r then - return PWild - else - return $ PTerm v - case (unEl t , v) of - (Pi a b , _) -> do - let body = raise 1 v `apply` [ Arg (domInfo a) $ var 0 ] - p <- addContext a (patternFrom r (k+1) (absBody b) body) - return $ PLam (domInfo a) $ Abs (absName b) p - (_ , Var i es) - | i < k -> do - t <- typeOfBV i - PBoundVar i <$> patternFrom r k (t , var i) es - -- The arguments of `var i` should be distinct bound variables - -- in order to build a Miller pattern - | Just vs <- allApplyElims es -> do - TelV tel _ <- telView =<< typeOfBV i - unless (size tel >= size vs) __IMPOSSIBLE__ - let ts = applySubst (parallelS $ reverse $ map unArg vs) $ map unDom $ flattenTel tel - mbvs <- forM (zip ts vs) $ \(t , v) -> do - isEtaVar (unArg v) t >>= \case - Just j | j < k -> return $ Just $ v $> j - _ -> return Nothing - case sequence mbvs of - Just bvs | fastDistinct bvs -> do - let allBoundVars = IntSet.fromList (downFrom k) - ok = not (isIrrelevant r) || - IntSet.fromList (map unArg bvs) == allBoundVars - if ok then return (PVar i bvs) else done - _ -> done - | otherwise -> done - (_ , _ ) | Just (d, pars) <- etaRecord -> do - def <- theDef <$> getConstInfo d - (tel, c, ci, vs) <- etaExpandRecord_ d pars def v - caseMaybeM (getFullyAppliedConType c t) __IMPOSSIBLE__ $ \ (_ , ct) -> do - PDef (conName c) <$> patternFrom r k (ct , Con c ci []) (map Apply vs) - (_ , Lam i t) -> __IMPOSSIBLE__ - (_ , Lit{}) -> done - (_ , Def f es) | isIrrelevant r -> done - (_ , Def f es) -> do - Def lsuc [] <- primLevelSuc - Def lmax [] <- primLevelMax - case es of - [x] | f == lsuc -> done - [x , y] | f == lmax -> done - _ -> do - ft <- defType <$> getConstInfo f - PDef f <$> patternFrom r k (ft , Def f []) es - (_ , Con c ci vs) | isIrrelevant r -> done - (_ , Con c ci vs) -> - caseMaybeM (getFullyAppliedConType c t) __IMPOSSIBLE__ $ \ (_ , ct) -> do - PDef (conName c) <$> patternFrom r k (ct , Con c ci []) vs - (_ , Pi a b) | isIrrelevant r -> done - (_ , Pi a b) -> do - pa <- patternFrom r k () a - pb <- addContext a (patternFrom r (k+1) () $ absBody b) - return $ PPi pa (Abs (absName b) pb) - (_ , Sort s) -> done - (_ , Level l) -> __IMPOSSIBLE__ - (_ , DontCare{}) -> return PWild - (_ , MetaV{}) -> __IMPOSSIBLE__ - (_ , Dummy s) -> __IMPOSSIBLE_VERBOSE__ s - -- | Monad for non-linear matching. type NLM = ExceptT Blocked_ (StateT NLMState ReduceM) @@ -235,23 +90,23 @@ matchingBlocked :: Blocked_ -> NLM () matchingBlocked = throwError --- | Add substitution @i |-> v@ to result of matching. -tellSub :: Relevance -> Int -> Term -> NLM () -tellSub r i v = do +-- | Add substitution @i |-> v : a@ to result of matching. +tellSub :: Relevance -> Int -> Type -> Term -> NLM () +tellSub r i a v = do old <- IntMap.lookup i <$> use nlmSub case old of Nothing -> nlmSub %= IntMap.insert i (r,v) Just (r',v') | isIrrelevant r -> return () | isIrrelevant r' -> nlmSub %= IntMap.insert i (r,v) - | otherwise -> whenJustM (equal v v') matchingBlocked + | otherwise -> whenJustM (equal a v v') matchingBlocked -tellEq :: Telescope -> Telescope -> Term -> Term -> NLM () -tellEq gamma k u v = do +tellEq :: Telescope -> Telescope -> Type -> Term -> Term -> NLM () +tellEq gamma k a u v = do traceSDoc "rewriting.match" 30 (sep [ "adding equality between" <+> addContext (gamma `abstract` k) (prettyTCM u) , " and " <+> addContext k (prettyTCM v) ]) $ do - nlmEqs %= (PostponedEquation k u v:) + nlmEqs %= (PostponedEquation k a u v:) type Sub = IntMap (Relevance, Term) @@ -260,6 +115,7 @@ -- the substitution computed by matching. data PostponedEquation = PostponedEquation { eqFreeVars :: Telescope -- ^ Telescope of free variables in the equation + , eqType :: Type -- ^ Type of the equation, living in same context as the rhs. , eqLhs :: Term -- ^ Term from pattern, living in pattern context. , eqRhs :: Term -- ^ Term from scrutinee, living in context where matching was invoked. } @@ -287,16 +143,16 @@ match r gamma k (t, hd) _ [] = matchingBlocked $ NotBlocked ReallyNotBlocked () match r gamma k (t, hd) (p:ps) (v:vs) = case (p,v) of (Apply p, Apply v) -> do - ~(Pi a b) <- reduce $ unEl t + ~(Pi a b) <- unEl <$> reduce t match r gamma k a p v - t' <- Red.addCtxTel k $ t `piApplyM` v + t' <- addContext k $ t `piApplyM` v let hd' = hd `apply` [ v ] match r gamma k (t',hd') ps vs (Proj o f, Proj o' f') | f == f' -> do ~(Just (El _ (Pi a b))) <- getDefType f =<< reduce t let t' = b `absApp` hd - hd' <- Red.addCtxTel k $ applyDef o f (argFromDom a $> hd) + hd' <- addContext k $ applyDef o f (argFromDom a $> hd) match r gamma k (t',hd') ps vs (Proj _ f, Proj _ f') | otherwise -> do @@ -311,19 +167,38 @@ (_ , IApply{} ) -> __IMPOSSIBLE__ -- TODO instance Match t a b => Match t (Dom a) (Dom b) where - match r gamma k t p v = match r gamma k t (C.unDom p) (C.unDom v) + match r gamma k t p v = match r gamma k t (unDom p) (unDom v) instance Match () NLPType Type where - match r gamma k _ (NLPType lp p) (El s a) = do - match r gamma k () lp s + match r gamma k _ (NLPType sp p) (El s a) = workOnTypes $ do + match r gamma k () sp s match r gamma k (sort s) p a -instance Match () NLPat Sort where - match r gamma k _ p s = case (p , s) of - (PWild , _ ) -> return () - (p , Type l) -> match Irrelevant gamma k () p l - _ -> matchingBlocked $ NotBlocked ReallyNotBlocked () +instance Match () NLPSort Sort where + match r gamma k _ p s = do + bs <- reduceB s + let b = void bs + s = ignoreBlocking bs + yes = return () + no = matchingBlocked $ NotBlocked ReallyNotBlocked () + traceSDoc "rewriting.match" 30 (sep + [ "matching pattern " <+> addContext (gamma `abstract` k) (prettyTCM p) + , " with sort " <+> addContext k (prettyTCM s) ]) $ do + case (p , s) of + (PType lp , Type l ) -> match r gamma k () lp l + (PProp lp , Prop l ) -> match r gamma k () lp l + (PInf , Inf ) -> yes + (PSizeUniv , SizeUniv) -> yes + -- blocked cases + (_ , UnivSort{}) -> matchingBlocked b + (_ , PiSort{} ) -> matchingBlocked b + (_ , FunSort{} ) -> matchingBlocked b + (_ , MetaS m _ ) -> matchingBlocked $ Blocked m () + + -- all other cases do not match + (_ , _) -> no + instance Match () NLPat Level where match r gamma k _ p l = do t <- El (mkType 0) . fromMaybe __IMPOSSIBLE__ <$> getBuiltin' builtinLevel @@ -331,15 +206,17 @@ match r gamma k t p v instance Match Type NLPat Term where - match r gamma k t p v = do - vbt <- Red.addCtxTel k $ reduceB (v,t) - etaRecord <- Red.addCtxTel k $ isEtaRecordType t + match r0 gamma k t p v = do + vbt <- addContext k $ reduceB (v,t) let n = size k b = void vbt (v,t) = ignoreBlocking vbt prettyPat = withShowAllArguments $ addContext (gamma `abstract` k) (prettyTCM p) prettyTerm = withShowAllArguments $ addContext k $ prettyTCM v prettyType = withShowAllArguments $ addContext k $ prettyTCM t + etaRecord <- addContext k $ isEtaRecordType t + prop <- addContext k $ isPropM t + let r = if prop then Irrelevant else r0 traceSDoc "rewriting.match" 30 (sep [ "matching pattern " <+> prettyPat , " with term " <+> prettyTerm @@ -352,7 +229,7 @@ [ "pattern vars: " <+> prettyTCM gamma , "bound vars: " <+> prettyTCM k ]) $ do let yes = return () - no msg = do + no msg = if r == Irrelevant then yes else do traceSDoc "rewriting.match" 10 (sep [ "mismatch between" <+> prettyPat , " and " <+> prettyTerm @@ -361,15 +238,17 @@ traceSDoc "rewriting.match" 30 (sep [ "blocking tag from reduction: " <+> text (show b) ]) $ do matchingBlocked b - block b' = do + block b' = if r == Irrelevant then yes else do traceSDoc "rewriting.match" 10 (sep [ "matching blocked on meta" , text (show b') ]) $ do traceSDoc "rewriting.match" 30 (sep [ "blocking tag from reduction: " <+> text (show b') ]) $ do matchingBlocked (b `mappend` b') + maybeBlock w = case w of + MetaV m es -> matchingBlocked $ Blocked m () + _ -> no "" case p of - PWild -> yes PVar i bvs -> traceSDoc "rewriting.match" 60 ("matching a PVar: " <+> text (show i)) $ do let allowedVars :: IntSet allowedVars = IntSet.fromList (map unArg bvs) @@ -379,24 +258,25 @@ perm = Perm n $ reverse $ map unArg $ bvs tel :: Telescope tel = permuteTel perm k - ok <- Red.addCtxTel k $ reallyFree badVars v + ok <- addContext k $ reallyFree badVars v case ok of Left b -> block b Right Nothing -> no "" - Right (Just v) -> tellSub r (i-n) $ teleLam tel $ renameP __IMPOSSIBLE__ perm v - - _ | MetaV m es <- v -> matchingBlocked $ Blocked m () + Right (Just v) -> + let t' = telePi tel $ renameP __IMPOSSIBLE__ perm t + v' = teleLam tel $ renameP __IMPOSSIBLE__ perm v + in tellSub r (i-n) t' v' PDef f ps -> traceSDoc "rewriting.match" 60 ("matching a PDef: " <+> prettyTCM f) $ do - v <- Red.addCtxTel k $ constructorForm =<< unLevel v + v <- addContext k $ constructorForm =<< unLevel v case v of Def f' es | f == f' -> do - ft <- Red.addCtxTel k $ defType <$> getConstInfo f + ft <- addContext k $ defType <$> getConstInfo f match r gamma k (ft , Def f []) ps es Con c ci vs | f == conName c -> do - ~(Just (_ , ct)) <- Red.addCtxTel k $ getFullyAppliedConType c t + ~(Just (_ , ct)) <- addContext k $ getFullyAppliedConType c t match r gamma k (ct , Con c ci []) ps vs _ | Pi a b <- unEl t -> do let ai = domInfo a @@ -408,10 +288,10 @@ -- If v is not of record constructor form but we are matching at record -- type, e.g., we eta-expand both v to (c vs) and -- the pattern (p = PDef f ps) to @c (p .f1) ... (p .fn)@. - def <- Red.addCtxTel k $ theDef <$> getConstInfo d - (tel, c, ci, vs) <- Red.addCtxTel k $ etaExpandRecord_ d pars def v - ~(Just (_ , ct)) <- Red.addCtxTel k $ getFullyAppliedConType c t - let flds = recFields def + def <- addContext k $ theDef <$> getConstInfo d + (tel, c, ci, vs) <- addContext k $ etaExpandRecord_ d pars def v + ~(Just (_ , ct)) <- addContext k $ getFullyAppliedConType c t + let flds = map argFromDom $ recFields def mkField fld = PDef f (ps ++ [Proj ProjSystem fld]) -- Issue #3335: when matching against the record constructor, -- don't add projections but take record field directly. @@ -421,39 +301,43 @@ match r gamma k (ct, Con c ci []) ps' (map Apply vs) MetaV m es -> do matchingBlocked $ Blocked m () - _ -> no "" + v -> maybeBlock v PLam i p' -> case unEl t of Pi a b -> do let body = raise 1 v `apply` [Arg i (var 0)] k' = ExtendTel a (Abs (absName b) k) match r gamma k' (absBody b) (absBody p') body - _ -> no "" + MetaV m es -> matchingBlocked $ Blocked m () + v -> maybeBlock v PPi pa pb -> case v of Pi a b -> do match r gamma k () pa a let k' = ExtendTel a (Abs (absName b) k) match r gamma k' () (absBody pb) (absBody b) - _ -> no "" + v -> maybeBlock v + PSort ps -> case v of + Sort s -> match r gamma k () ps s + v -> maybeBlock v PBoundVar i ps -> case v of Var i' es | i == i' -> do let ti = unDom $ indexWithDefault __IMPOSSIBLE__ (flattenTel k) i match r gamma k (ti , var i) ps es _ | Pi a b <- unEl t -> do let ai = domInfo a - pbody = PBoundVar i $ raise 1 ps ++ [ Apply $ Arg ai $ PTerm $ var 0 ] + pbody = PBoundVar (1+i) $ raise 1 ps ++ [ Apply $ Arg ai $ PTerm $ var 0 ] body = raise 1 v `apply` [ Arg ai $ var 0 ] k' = ExtendTel a (Abs (absName b) k) match r gamma k' (absBody b) pbody body _ | Just (d, pars) <- etaRecord -> do - def <- Red.addCtxTel k $ theDef <$> getConstInfo d - (tel, c, ci, vs) <- Red.addCtxTel k $ etaExpandRecord_ d pars def v - ~(Just (_ , ct)) <- Red.addCtxTel k $ getFullyAppliedConType c t - let flds = recFields def + def <- addContext k $ theDef <$> getConstInfo d + (tel, c, ci, vs) <- addContext k $ etaExpandRecord_ d pars def v + ~(Just (_ , ct)) <- addContext k $ getFullyAppliedConType c t + let flds = map argFromDom $ recFields def ps' = map (fmap $ \fld -> PBoundVar i (ps ++ [Proj ProjSystem fld])) flds match r gamma k (ct, Con c ci []) (map Apply ps') (map Apply vs) - _ -> no "" + v -> maybeBlock v PTerm u -> traceSDoc "rewriting.match" 60 ("matching a PTerm" <+> addContext (gamma `abstract` k) (prettyTCM u)) $ - tellEq gamma k u v + tellEq gamma k t u v -- Checks if the given term contains any free variables that satisfy the -- given condition on their DBI, possibly reducing the term in the process. @@ -468,7 +352,7 @@ MaybeFree ms | null ms -> return $ Right Nothing | otherwise -> return $ Left $ - Set.foldr (\m -> mappend $ Blocked m ()) (notBlocked ()) ms + foldrMetaSet (\ m -> mappend $ Blocked m ()) (notBlocked ()) ms NotFree -> return $ Right (Just v') where @@ -493,18 +377,18 @@ Just (_ , v) -> Just v Nothing -> Nothing -checkPostponedEquations :: (MonadReduce m, HasConstInfo m, MonadDebug m) +checkPostponedEquations :: (MonadReduce m, MonadAddContext m, HasConstInfo m, HasBuiltins m, MonadDebug m) => Substitution -> PostponedEquations -> m (Maybe Blocked_) checkPostponedEquations sub eqs = forM' eqs $ - \ (PostponedEquation k lhs rhs) -> do + \ (PostponedEquation k a lhs rhs) -> do let lhs' = applySubst (liftS (size k) sub) lhs traceSDoc "rewriting.match" 30 (sep [ "checking postponed equality between" , addContext k (prettyTCM lhs') , " and " , addContext k (prettyTCM rhs) ]) $ do - Red.addCtxTel k $ equal lhs' rhs + addContext k $ equal a lhs' rhs -- main function -nonLinMatch :: (MonadReduce m, HasConstInfo m, MonadDebug m, Match t a b) +nonLinMatch :: (MonadReduce m, MonadAddContext m, HasConstInfo m, HasBuiltins m, MonadDebug m, Match t a b) => Telescope -> t -> a -> b -> m (Either Blocked_ Substitution) nonLinMatch gamma t p v = do let no msg b = traceSDoc "rewriting.match" 10 (sep @@ -519,22 +403,20 @@ Nothing -> return $ Right sub Just b -> no "checking of postponed equations" b --- | Untyped βη-equality, does not handle things like empty record types. +-- | Typed βη-equality, also handles empty record types. -- Returns `Nothing` if the terms are equal, or `Just b` if the terms are not -- (where b contains information about possible metas blocking the comparison) - --- TODO: implement a type-directed, lazy version of this function. -equal :: (MonadReduce m, HasConstInfo m) - => Term -> Term -> m (Maybe Blocked_) -equal u v = do - (u, v) <- etaContract =<< normalise (u, v) - let ok = u == v - block = caseMaybe (firstMeta (u, v)) - (NotBlocked ReallyNotBlocked ()) - (\ m -> Blocked m ()) - if ok then return Nothing else do - traceSDoc "rewriting.match" 10 (sep +equal :: (MonadReduce m, MonadAddContext m, HasConstInfo m, HasBuiltins m) + => Type -> Term -> Term -> m (Maybe Blocked_) +equal a u v = pureEqualTerm a u v >>= \case + True -> return Nothing + False -> traceSDoc "rewriting.match" 10 (sep [ "mismatch between " <+> prettyTCM u , " and " <+> prettyTCM v ]) $ do return $ Just block + + where + block = caseMaybe (firstMeta (u, v)) + (NotBlocked ReallyNotBlocked ()) + (\m -> Blocked m ()) diff --git a/src/full/Agda/TypeChecking/Rewriting/NonLinPattern.hs b/src/full/Agda/TypeChecking/Rewriting/NonLinPattern.hs new file mode 100644 --- /dev/null +++ b/src/full/Agda/TypeChecking/Rewriting/NonLinPattern.hs @@ -0,0 +1,330 @@ +{-# LANGUAGE NondecreasingIndentation #-} +{-# LANGUAGE TypeFamilies #-} + +{- | Various utility functions dealing with the non-linear, higher-order + patterns used for rewrite rules. +-} + +module Agda.TypeChecking.Rewriting.NonLinPattern where + +import Control.Monad.Reader + +import Data.IntSet (IntSet) +import qualified Data.IntSet as IntSet + +import Agda.Syntax.Common +import Agda.Syntax.Internal +import Agda.Syntax.Internal.Defs + +import Agda.TypeChecking.Datatypes +import Agda.TypeChecking.Free +import Agda.TypeChecking.Free.Lazy +import Agda.TypeChecking.Irrelevance (workOnTypes, isPropM) +import Agda.TypeChecking.Level +import Agda.TypeChecking.Monad +import Agda.TypeChecking.Monad.Builtin +import Agda.TypeChecking.Pretty +import Agda.TypeChecking.Records +import Agda.TypeChecking.Reduce +import Agda.TypeChecking.Substitute +import Agda.TypeChecking.Telescope + +import Agda.Utils.Functor +import Agda.Utils.Impossible +import Agda.Utils.List +import Agda.Utils.Maybe +import Agda.Utils.Monad +import Agda.Utils.Null +import Agda.Utils.Singleton +import Agda.Utils.Size + +-- | Turn a term into a non-linear pattern, treating the +-- free variables as pattern variables. +-- The first argument indicates the relevance we are working under: if this +-- is Irrelevant, then we construct a pattern that never fails to match. +-- The second argument is the number of bound variables (from pattern lambdas). +-- The third argument is the type of the term. + +class PatternFrom t a b where + patternFrom :: Relevance -> Int -> t -> a -> TCM b + +instance (PatternFrom t a b) => PatternFrom (Dom t) (Arg a) (Arg b) where + patternFrom r k t u = let r' = r `composeRelevance` getRelevance u + in traverse (patternFrom r' k $ unDom t) u + +instance PatternFrom (Type, Term) Elims [Elim' NLPat] where + patternFrom r k (t,hd) = \case + [] -> return [] + (Apply u : es) -> do + ~(Pi a b) <- unEl <$> reduce t + p <- patternFrom r k a u + t' <- t `piApplyM` u + let hd' = hd `apply` [ u ] + ps <- patternFrom r k (t',hd') es + return $ Apply p : ps + (IApply x y u : es) -> typeError $ GenericError $ + "Rewrite rules with cubical are not yet supported" + (Proj o f : es) -> do + ~(Just (El _ (Pi a b))) <- getDefType f =<< reduce t + let t' = b `absApp` hd + hd' <- applyDef o f (argFromDom a $> hd) + ps <- patternFrom r k (t',hd') es + return $ Proj o f : ps + +instance (PatternFrom t a b) => PatternFrom t (Dom a) (Dom b) where + patternFrom r k t = traverse $ patternFrom r k t + +instance PatternFrom () Type NLPType where + patternFrom r k _ a = workOnTypes $ + NLPType <$> patternFrom r k () (getSort a) + <*> patternFrom r k (sort $ getSort a) (unEl a) + +instance PatternFrom () Sort NLPSort where + patternFrom r k _ s = do + s <- reduce s + case s of + Type l -> PType <$> patternFrom r k () l + Prop l -> PProp <$> patternFrom r k () l + Inf -> return PInf + SizeUniv -> return PSizeUniv + PiSort _ _ -> __IMPOSSIBLE__ + FunSort _ _ -> __IMPOSSIBLE__ + UnivSort _ -> __IMPOSSIBLE__ + MetaS{} -> __IMPOSSIBLE__ + DefS{} -> __IMPOSSIBLE__ + DummyS s -> do + reportS "impossible" 10 + [ "patternFrom: hit dummy sort with content:" + , s + ] + __IMPOSSIBLE__ + +instance PatternFrom () Level NLPat where + patternFrom r k _ l = do + t <- levelType + v <- reallyUnLevelView l + patternFrom r k t v + +instance PatternFrom Type Term NLPat where + patternFrom r0 k t v = do + t <- reduce t + etaRecord <- isEtaRecordType t + prop <- isPropM t + let r = if prop then Irrelevant else r0 + v <- unLevel =<< reduce v + reportSDoc "rewriting.build" 60 $ sep + [ "building a pattern from term v = " <+> prettyTCM v + , " of type " <+> prettyTCM t + ] + let done = return $ PTerm v + case (unEl t , stripDontCare v) of + (Pi a b , _) -> do + let body = raise 1 v `apply` [ Arg (domInfo a) $ var 0 ] + p <- addContext a (patternFrom r (k+1) (absBody b) body) + return $ PLam (domInfo a) $ Abs (absName b) p + (_ , Var i es) + | i < k -> do + t <- typeOfBV i + PBoundVar i <$> patternFrom r k (t , var i) es + -- The arguments of `var i` should be distinct bound variables + -- in order to build a Miller pattern + | Just vs <- allApplyElims es -> do + TelV tel _ <- telView =<< typeOfBV i + unless (size tel >= size vs) __IMPOSSIBLE__ + let ts = applySubst (parallelS $ reverse $ map unArg vs) $ map unDom $ flattenTel tel + mbvs <- forM (zip ts vs) $ \(t , v) -> do + isEtaVar (unArg v) t >>= \case + Just j | j < k -> return $ Just $ v $> j + _ -> return Nothing + case sequence mbvs of + Just bvs | fastDistinct bvs -> do + let allBoundVars = IntSet.fromList (downFrom k) + ok = not (isIrrelevant r) || + IntSet.fromList (map unArg bvs) == allBoundVars + if ok then return (PVar i bvs) else done + _ -> done + | otherwise -> done + (_ , _ ) | Just (d, pars) <- etaRecord -> do + def <- theDef <$> getConstInfo d + (tel, c, ci, vs) <- etaExpandRecord_ d pars def v + caseMaybeM (getFullyAppliedConType c t) __IMPOSSIBLE__ $ \ (_ , ct) -> do + PDef (conName c) <$> patternFrom r k (ct , Con c ci []) (map Apply vs) + (_ , Lam i t) -> __IMPOSSIBLE__ + (_ , Lit{}) -> done + (_ , Def f es) | isIrrelevant r -> done + (_ , Def f es) -> do + Def lsuc [] <- primLevelSuc + Def lmax [] <- primLevelMax + case es of + [x] | f == lsuc -> done + [x , y] | f == lmax -> done + _ -> do + ft <- defType <$> getConstInfo f + PDef f <$> patternFrom r k (ft , Def f []) es + (_ , Con c ci vs) | isIrrelevant r -> done + (_ , Con c ci vs) -> + caseMaybeM (getFullyAppliedConType c t) __IMPOSSIBLE__ $ \ (_ , ct) -> do + PDef (conName c) <$> patternFrom r k (ct , Con c ci []) vs + (_ , Pi a b) | isIrrelevant r -> done + (_ , Pi a b) -> do + pa <- patternFrom r k () a + pb <- addContext a (patternFrom r (k+1) () $ absBody b) + return $ PPi pa (Abs (absName b) pb) + (_ , Sort s) -> PSort <$> patternFrom r k () s + (_ , Level l) -> __IMPOSSIBLE__ + (_ , DontCare{}) -> __IMPOSSIBLE__ + (_ , MetaV{}) -> __IMPOSSIBLE__ + (_ , Dummy s _) -> __IMPOSSIBLE_VERBOSE__ s + +-- | Convert from a non-linear pattern to a term. + +class NLPatToTerm p a where + nlPatToTerm + :: (MonadReduce m, HasBuiltins m, HasConstInfo m, MonadDebug m) + => p -> m a + + default nlPatToTerm :: + ( NLPatToTerm p' a', Traversable f, p ~ f p', a ~ f a' + , MonadReduce m, HasBuiltins m, HasConstInfo m, MonadDebug m + ) => p -> m a + nlPatToTerm = traverse nlPatToTerm + +instance NLPatToTerm p a => NLPatToTerm [p] [a] where +instance NLPatToTerm p a => NLPatToTerm (Arg p) (Arg a) where +instance NLPatToTerm p a => NLPatToTerm (Dom p) (Dom a) where +instance NLPatToTerm p a => NLPatToTerm (Elim' p) (Elim' a) where +instance NLPatToTerm p a => NLPatToTerm (Abs p) (Abs a) where + +instance NLPatToTerm Nat Term where + nlPatToTerm = return . var + +instance NLPatToTerm NLPat Term where + nlPatToTerm = \case + PVar i xs -> Var i . map Apply <$> nlPatToTerm xs + PTerm u -> return u + PDef f es -> (theDef <$> getConstInfo f) >>= \case + Constructor{ conSrcCon = c } -> Con c ConOSystem <$> nlPatToTerm es + _ -> Def f <$> nlPatToTerm es + PLam i u -> Lam i <$> nlPatToTerm u + PPi a b -> Pi <$> nlPatToTerm a <*> nlPatToTerm b + PSort s -> Sort <$> nlPatToTerm s + PBoundVar i es -> Var i <$> nlPatToTerm es + +instance NLPatToTerm NLPat Level where + nlPatToTerm = nlPatToTerm >=> levelView + +instance NLPatToTerm NLPType Type where + nlPatToTerm (NLPType s a) = El <$> nlPatToTerm s <*> nlPatToTerm a + +instance NLPatToTerm NLPSort Sort where + nlPatToTerm (PType l) = Type <$> nlPatToTerm l + nlPatToTerm (PProp l) = Prop <$> nlPatToTerm l + nlPatToTerm PInf = return Inf + nlPatToTerm PSizeUniv = return SizeUniv + +-- | Gather the set of pattern variables of a non-linear pattern +class NLPatVars a where + nlPatVarsUnder :: Int -> a -> IntSet + + nlPatVars :: a -> IntSet + nlPatVars = nlPatVarsUnder 0 + +instance {-# OVERLAPPABLE #-} (Foldable f, NLPatVars a) => NLPatVars (f a) where + nlPatVarsUnder k = foldMap $ nlPatVarsUnder k + +instance NLPatVars NLPType where + nlPatVarsUnder k (NLPType l a) = nlPatVarsUnder k (l, a) + +instance NLPatVars NLPSort where + nlPatVarsUnder k = \case + PType l -> nlPatVarsUnder k l + PProp l -> nlPatVarsUnder k l + PInf -> empty + PSizeUniv -> empty + +instance NLPatVars NLPat where + nlPatVarsUnder k = \case + PVar i _ -> singleton $ i - k + PDef _ es -> nlPatVarsUnder k es + PLam _ p -> nlPatVarsUnder k p + PPi a b -> nlPatVarsUnder k (a, b) + PSort s -> nlPatVarsUnder k s + PBoundVar _ es -> nlPatVarsUnder k es + PTerm{} -> empty + +instance (NLPatVars a, NLPatVars b) => NLPatVars (a,b) where + nlPatVarsUnder k (a,b) = nlPatVarsUnder k a `mappend` nlPatVarsUnder k b + +instance NLPatVars a => NLPatVars (Abs a) where + nlPatVarsUnder k = \case + Abs _ v -> nlPatVarsUnder (k+1) v + NoAbs _ v -> nlPatVarsUnder k v + +-- | Get all symbols that a non-linear pattern matches against +class GetMatchables a where + getMatchables :: a -> [QName] + + default getMatchables :: (Foldable f, GetMatchables a', a ~ f a') => a -> [QName] + getMatchables = foldMap getMatchables + +instance GetMatchables a => GetMatchables [a] where +instance GetMatchables a => GetMatchables (Arg a) where +instance GetMatchables a => GetMatchables (Dom a) where +instance GetMatchables a => GetMatchables (Elim' a) where +instance GetMatchables a => GetMatchables (Abs a) where + +instance (GetMatchables a, GetMatchables b) => GetMatchables (a,b) where + getMatchables (x,y) = getMatchables x ++ getMatchables y + +instance GetMatchables NLPat where + getMatchables p = + case p of + PVar _ _ -> empty + PDef f _ -> singleton f + PLam _ x -> getMatchables x + PPi a b -> getMatchables (a,b) + PSort s -> getMatchables s + PBoundVar i es -> getMatchables es + PTerm u -> getMatchables u + +instance GetMatchables NLPType where + getMatchables = getMatchables . nlpTypeUnEl + +instance GetMatchables NLPSort where + getMatchables = \case + PType l -> getMatchables l + PProp l -> getMatchables l + PInf -> empty + PSizeUniv -> empty + +instance GetMatchables Term where + getMatchables = getDefs' __IMPOSSIBLE__ singleton + +instance GetMatchables RewriteRule where + getMatchables = getMatchables . rewPats + +-- | Only computes free variables that are not bound (see 'nlPatVars'), +-- i.e., those in a 'PTerm'. + +instance Free NLPat where + freeVars' = \case + PVar _ _ -> mempty + PDef _ es -> freeVars' es + PLam _ u -> freeVars' u + PPi a b -> freeVars' (a,b) + PSort s -> freeVars' s + PBoundVar _ es -> freeVars' es + PTerm t -> freeVars' t + +instance Free NLPType where + freeVars' (NLPType s a) = + ifM ((IgnoreNot ==) <$> asks feIgnoreSorts) + {- then -} (freeVars' (s, a)) + {- else -} (freeVars' a) + +instance Free NLPSort where + freeVars' = \case + PType l -> freeVars' l + PProp l -> freeVars' l + PInf -> mempty + PSizeUniv -> mempty diff --git a/src/full/Agda/TypeChecking/Rules/Application.hs b/src/full/Agda/TypeChecking/Rules/Application.hs --- a/src/full/Agda/TypeChecking/Rules/Application.hs +++ b/src/full/Agda/TypeChecking/Rules/Application.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE NondecreasingIndentation #-} module Agda.TypeChecking.Rules.Application @@ -9,19 +8,17 @@ , checkProjAppToKnownPrincipalArg ) where -#if MIN_VERSION_base(4,11,0) -import Prelude hiding ( (<>), null ) -#else import Prelude hiding ( null ) -#endif -import Control.Arrow (first, second) +import Control.Arrow (first) import Control.Monad.Trans import Control.Monad.Trans.Maybe import Control.Monad.Reader import Data.Maybe import qualified Data.List as List +import Data.List.NonEmpty (NonEmpty(..)) +import qualified Data.List.NonEmpty as NonEmpty import Data.Either (partitionEithers) import Data.Traversable (sequenceA) import Data.Void @@ -43,6 +40,7 @@ import Agda.TypeChecking.Constraints import Agda.TypeChecking.Datatypes import Agda.TypeChecking.Free +import Agda.TypeChecking.Free.Lazy (VarMap, lookupVarMap) import Agda.TypeChecking.Implicit import Agda.TypeChecking.Injectivity import Agda.TypeChecking.Irrelevance @@ -54,7 +52,6 @@ import Agda.TypeChecking.Primitive import Agda.TypeChecking.Monad import Agda.TypeChecking.Monad.Builtin -import Agda.TypeChecking.Pretty import Agda.TypeChecking.Records import Agda.TypeChecking.Reduce import Agda.TypeChecking.Rules.Def @@ -70,12 +67,10 @@ import Agda.Utils.Maybe import Agda.Utils.Monad import Agda.Utils.Null -import Agda.Utils.NonemptyList import Agda.Utils.Pretty ( prettyShow ) import Agda.Utils.Size import Agda.Utils.Tuple -#include "undefined.h" import Agda.Utils.Impossible ----------------------------------------------------------------------------- @@ -92,7 +87,9 @@ -- (and continues to 'checkConstructorApplication') -- and resolves pattern synonyms. checkApplication :: Comparison -> A.Expr -> A.Args -> A.Expr -> Type -> TCM Term -checkApplication cmp hd args e t = postponeInstanceConstraints $ do +checkApplication cmp hd args e t = + turnOffExpandLastIfExistingMeta hd $ + postponeInstanceConstraints $ do reportSDoc "tc.check.app" 20 $ vcat [ "checkApplication" , nest 2 $ "hd = " <+> prettyA hd @@ -181,7 +178,7 @@ -- Subcase: unquote A.Unquote _ | [arg] <- args -> do - (_, hole) <- newValueMeta RunMetaOccursCheck t + (_, hole) <- newValueMeta RunMetaOccursCheck CmpLeq t unquoteM (namedArg arg) hole t return hole | arg : args <- args -> do @@ -197,7 +194,7 @@ -- a b : (x : X) (y : Y x) let rho = reverse (map unArg vs) ++# IdS -- [x := a, y := b] equalType (applySubst rho target) t -- Z a b == A - (_, hole) <- newValueMeta RunMetaOccursCheck holeType + (_, hole) <- newValueMeta RunMetaOccursCheck CmpLeq holeType unquoteM (namedArg arg) hole holeType return $ apply hole vs where @@ -245,10 +242,11 @@ inferHeadDef :: ProjOrigin -> QName -> TCM (Elims -> Term, Type) inferHeadDef o x = do proj <- isProjection x + rel <- getRelevance . defArgInfo <$> getConstInfo x let app = case proj of Nothing -> \ args -> Def x $ map Apply args - Just p -> \ args -> projDropParsApply p o args + Just p -> \ args -> projDropParsApply p o rel args mapFst applyE <$> inferDef app x -- | Infer the type of a head thing (variable, function symbol, or constructor). @@ -266,8 +264,17 @@ ] unless (usableRelevance a) $ typeError $ VariableIsIrrelevant x - unless (usableQuantity a) $ + -- Andreas, 2019-06-18, LAIM 2019, issue #3855: + -- Conor McBride style quantity judgement: + -- The available quantity for variable x must be below + -- the required quantity to construct the term x. + -- Note: this whole thing does not work for linearity, where we need some actual arithmetics. + unlessM ((getQuantity a `moreQuantity`) <$> asksTC getQuantity) $ typeError $ VariableIsErased x + + unless (usableCohesion a) $ + typeError $ VariableIsOfUnusableCohesion x (getCohesion a) + return (applyE u, unDom a) A.Def x -> inferHeadDef ProjPrefix x @@ -306,9 +313,14 @@ traceCall (InferDef x) $ do -- getConstInfo retrieves the *absolute* (closed) type of x -- instantiateDef relativizes it to the current context - d <- instantiateDef =<< getConstInfo x - -- irrelevant defs are only allowed in irrelevant position - checkRelevance x d + d0 <- getConstInfo x + d <- instantiateDef d0 + reportSDoc "tc.term.def" 10 $ "inferDef" <+> prettyTCM x + reportSDoc "tc.term.def" 30 $ " absolute type: " <+> inTopContext (prettyTCM $ defType d0) + reportSDoc "tc.term.def" 30 $ " instantiated type:" <+> prettyTCM (defType d) + -- Irrelevant defs are only allowed in irrelevant position. + -- Erased defs are only allowed in erased position (see #3855). + checkModality x d case theDef d of GeneralizableVar{} -> do -- Generalizable variables corresponds to metas created @@ -324,8 +336,16 @@ -- since x is considered living in the top-level, we have to -- apply it to the current context vs <- freeVarsToApply x + reportSDoc "tc.term.def" 30 $ " free vars:" <+> prettyList_ (map prettyTCM vs) let t = defType d v = mkTerm vs -- applies x to vs, dropping parameters + + -- Andrea 2019-07-16, Check that the supplied arguments + -- respect the cohesion modalities of the current context. + -- Cohesion is purely based on left-division, so it does not + -- rely on "position" like Relevance/Quantity. + checkCohesionArgs vs + debug vs t v return (v, t) where @@ -338,22 +358,38 @@ , nest 2 $ ":" <+> prettyTCM t , nest 2 $ "-->" <+> prettyTCM v ] --- | The second argument is the definition of the first. -checkRelevance :: QName -> Definition -> TCM () -checkRelevance x def = maybe (return ()) typeError =<< checkRelevance' x def +checkCohesionArgs :: Args -> TCM () +checkCohesionArgs vs = do + let + vmap :: VarMap + vmap = freeVars vs + -- we iterate over all vars in the context and their ArgInfo, + -- checking for each that "vs" uses them as allowed. + as <- getContextArgs + forM_ as $ \ (Arg avail t) -> do + let m = do + v <- deBruijnView t + varModality <$> lookupVarMap v vmap + whenJust m $ \ used -> do + unless (getCohesion avail `moreCohesion` getCohesion used) $ + (genericDocError =<<) $ fsep $ + ["Variable" , prettyTCM t] + ++ pwords "is used as" ++ [text $ show $ getCohesion used] + ++ pwords "but only available as" ++ [text $ show $ getCohesion avail] + -- | The second argument is the definition of the first. -- Returns 'Nothing' if ok, otherwise the error message. checkRelevance' :: QName -> Definition -> TCM (Maybe TypeError) checkRelevance' x def = do - case defRelevance def of + case getRelevance def of Relevant -> return Nothing -- relevance functions can be used in any context. drel -> do -- Andreas,, 2018-06-09, issue #2170 -- irrelevant projections are only allowed if --irrelevant-projections ifM (return (isJust $ isProjection_ $ theDef def) `and2M` (not .optIrrelevantProjections <$> pragmaOptions)) {-then-} needIrrProj {-else-} $ do - rel <- asksTC envRelevance + rel <- asksTC getRelevance reportSDoc "tc.irr" 50 $ vcat [ "declaration relevance =" <+> text (show drel) , "context relevance =" <+> text (show rel) @@ -365,7 +401,33 @@ , " Turn on option --irrelevant-projections to use it (unsafe)." ] +-- | The second argument is the definition of the first. +-- Returns 'Nothing' if ok, otherwise the error message. +checkQuantity' :: QName -> Definition -> TCM (Maybe TypeError) +checkQuantity' x def = do + case getQuantity def of + Quantityω{} -> return Nothing -- Abundant definitions can be used in any context. + dq -> do + q <- asksTC getQuantity + reportSDoc "tc.irr" 50 $ vcat + [ "declaration quantity =" <+> text (show dq) + , "context quantity =" <+> text (show q) + ] + return $ if (dq `moreQuantity` q) then Nothing else Just $ DefinitionIsErased x +-- | The second argument is the definition of the first. +checkModality' :: QName -> Definition -> TCM (Maybe TypeError) +checkModality' x def = do + checkRelevance' x def >>= \case + Nothing -> checkQuantity' x def + err@Just{} -> return err + +-- | The second argument is the definition of the first. +checkModality :: QName -> Definition -> TCM () +checkModality x def = justToError $ checkModality' x def + where + justToError m = maybe (return ()) typeError =<< m + -- | @checkHeadApplication e t hd args@ checks that @e@ has type @t@, -- assuming that @e@ has the form @hd args@. The corresponding -- type-checked term is returned. @@ -386,6 +448,7 @@ pHComp <- getNameOfConstrained builtinHComp pTrans <- getNameOfConstrained builtinTrans mglue <- getNameOfConstrained builtin_glue + mglueU <- getNameOfConstrained builtin_glueU case hd of -- Type checking #. The # that the user can write will be a Def, but the -- sharp we generate in the body of the wrapper is a Con. @@ -398,6 +461,7 @@ A.Def c | Just c == conId -> defaultResult' $ Just $ checkConId c A.Def c | Just c == pOr -> defaultResult' $ Just $ checkPOr c A.Def c | Just c == mglue -> defaultResult' $ Just $ check_glue c + A.Def c | Just c == mglueU -> defaultResult' $ Just $ check_glueU c _ -> defaultResult where @@ -420,6 +484,19 @@ v <- unfoldInlined (f vs) coerce' cmp checkedTarget v t1 t +-- Issue #3019 and #4170: Don't insert trailing implicits when checking arguments to existing +-- metavariables. +turnOffExpandLastIfExistingMeta :: A.Expr -> TCM a -> TCM a +turnOffExpandLastIfExistingMeta hd + | isExistingMeta = reallyDontExpandLast + | otherwise = id + where + isExistingMeta = isJust $ A.metaNumber =<< metaInfo hd + metaInfo (A.QuestionMark i _) = Just i + metaInfo (A.Underscore i) = Just i + metaInfo (A.ScopedExpr _ e) = metaInfo e + metaInfo _ = Nothing + ----------------------------------------------------------------------------- -- * Spines ----------------------------------------------------------------------------- @@ -457,10 +534,10 @@ -> ExceptT (MaybeRanges, Elims, [NamedArg A.Expr], Type) TCM (MaybeRanges, Elims, Type, CheckedTarget) -- Case: no arguments, do not insert trailing hidden arguments: We are done. -checkArgumentsE' chk DontExpandLast _ [] t0 _ = return ([], [], t0, chk) +checkArgumentsE' chk exh _ [] t0 _ | isDontExpandLast exh = return ([], [], t0, chk) -- Case: no arguments, but need to insert trailing hiddens. -checkArgumentsE' chk ExpandLast r [] t0 mt1 = +checkArgumentsE' chk _ExpandLast r [] t0 mt1 = traceCallE (CheckArguments r [] t0 mt1) $ lift $ do mt1' <- traverse (unEl <.> reduce) mt1 (us, t) <- implicitArgs (-1) (expand mt1') t0 @@ -486,7 +563,8 @@ ] -- First, insert implicit arguments, depending on current argument @arg@. let hx = getHiding info -- hiding of current argument - mx = fmap rangedThing $ nameOf e -- name of current argument + mx :: Maybe ArgName + mx = bareNameOf e -- name of current argument -- do not insert visible arguments expand NotHidden y = False -- insert a hidden argument if arg is not hidden or has different name @@ -509,7 +587,7 @@ t <- lift $ forcePiUsingInjectivity t -- We are done inserting implicit args. Now, try to check @arg@. - ifBlockedType t (\ m t -> throwError (replicate (length us) Nothing, us, args0, t)) $ \ _ t0' -> do + ifBlocked t (\ m t -> throwError (replicate (length us) Nothing, us, args0, t)) $ \ _ t0' -> do -- What can go wrong? @@ -522,7 +600,7 @@ | null xs = lift $ typeError $ ShouldBePi t0' -- c) We did insert implicits, but we ran out of implicit function types. -- Then, we should inform the user that we did not find his one. - | otherwise = lift $ typeError $ WrongNamedArgument arg + | otherwise = lift $ typeError $ WrongNamedArgument arg xs -- 2. We have a function type left, but it is the wrong one. -- Our argument must be implicit, case a) is impossible. @@ -531,7 +609,7 @@ -- b) We have not inserted any implicits. | null xs = lift $ typeError $ WrongHidingInApplication t0' -- c) We inserted implicits, but did not find his one. - | otherwise = lift $ typeError $ WrongNamedArgument arg + | otherwise = lift $ typeError $ WrongNamedArgument arg xs viewPath <- lift pathView' @@ -582,9 +660,9 @@ -- t0' <- lift $ forcePi (getHiding info) (maybe "_" rangedThing $ nameOf e) t0' case unEl t0' of Pi (Dom{domInfo = info', domName = dname, unDom = a}) b - | let name = maybe "_" rangedThing dname, + | let name = bareNameWithDefault "_" dname, sameHiding info info' - && (visible info || maybe True ((name ==) . rangedThing) (nameOf e)) -> do + && (visible info || maybe True (name ==) mx) -> do u <- lift $ applyModalityToContext info' $ do -- Andreas, 2014-05-30 experiment to check non-dependent arguments -- after the spine has been processed. Allows to propagate type info @@ -706,7 +784,8 @@ -- Issue 661: t maybe an evaluated form of d .., so we evaluate d -- as well and then check wether we deal with the same datatype t0 <- reduce (Def d []) - case (t0, unEl t) of -- Only fully applied constructors get special treatment + tReduced <- reduce t + case (t0, unEl tReduced) of -- Only fully applied constructors get special treatment (Def d0 _, Def d' es) -> do let ~(Just vs) = allApplyElims es reportSDoc "tc.term.con" 50 $ nest 2 $ "d0 =" <+> prettyTCM d0 @@ -770,7 +849,7 @@ Just ps' <- unnamedPar h ps = dropArgs ps' args' | otherwise = args where - name = fmap rangedThing . nameOf $ unArg arg + name = bareNameOf arg h = getHiding arg namedPar x = dropPar ((x ==) . unDom) @@ -781,7 +860,7 @@ dropPar _ [] = Nothing -- | Returns an unblocking action in case of failure. -disambiguateConstructor :: NonemptyList QName -> Type -> TCM (Either (TCM Bool) ConHead) +disambiguateConstructor :: NonEmpty QName -> Type -> TCM (Either (TCM Bool) ConHead) disambiguateConstructor cs0 t = do reportSLn "tc.check.term.con" 40 $ "Ambiguous constructor: " ++ prettyShow cs0 @@ -795,12 +874,12 @@ -- See issue 279. -- Andreas, 2017-08-13, issue #2686: ignore abstract constructors (cs, cons) <- unzip . snd . partitionEithers <$> do - forM (toList cs0) $ \ c -> mapRight (c,) <$> getConForm c + forM (NonEmpty.toList cs0) $ \ c -> mapRight (c,) <$> getConForm c reportSLn "tc.check.term.con" 40 $ " reduced: " ++ prettyShow cons case cons of - [] -> typeError $ AbstractConstructorNotInScope $ headNe cs0 + [] -> typeError $ AbstractConstructorNotInScope $ NonEmpty.head cs0 [con] -> do - let c = setConName (fromMaybe __IMPOSSIBLE__ $ headMaybe cs) con + let c = setConName (headWithDefault __IMPOSSIBLE__ cs) con reportSLn "tc.check.term.con" 40 $ " only one non-abstract constructor: " ++ prettyShow c storeDisambiguatedName $ conName c return (Right c) @@ -808,15 +887,15 @@ dcs <- zipWithM (\ c con -> (, setConName c con) . getData . theDef <$> getConInfo con) cs cons -- Type error let badCon t = typeError $ flip DoesNotConstructAnElementOf t $ - fromMaybe __IMPOSSIBLE__ $ headMaybe cs + headWithDefault __IMPOSSIBLE__ cs -- Lets look at the target type at this point let getCon :: TCM (Maybe ConHead) getCon = do - TelV tel t1 <- telView t + TelV tel t1 <- telViewPath t addContext tel $ do reportSDoc "tc.check.term.con" 40 $ nest 2 $ "target type: " <+> prettyTCM t1 - ifBlockedType t1 (\ m t -> return Nothing) $ \ _ t' -> + ifBlocked t1 (\ m t -> return Nothing) $ \ _ t' -> caseMaybeM (isDataOrRecord $ unEl t') (badCon t') $ \ d -> case [ c | (d', c) <- dcs, d == d' ] of [c] -> do @@ -836,7 +915,7 @@ -- | Inferring the type of an overloaded projection application. -- See 'inferOrCheckProjApp'. -inferProjApp :: A.Expr -> ProjOrigin -> NonemptyList QName -> A.Args -> TCM (Term, Type) +inferProjApp :: A.Expr -> ProjOrigin -> NonEmpty QName -> A.Args -> TCM (Term, Type) inferProjApp e o ds args0 = do (v, t, _) <- inferOrCheckProjApp e o ds args0 Nothing return (v, t) @@ -844,7 +923,7 @@ -- | Checking the type of an overloaded projection application. -- See 'inferOrCheckProjApp'. -checkProjApp :: Comparison -> A.Expr -> ProjOrigin -> NonemptyList QName -> A.Args -> Type -> TCM Term +checkProjApp :: Comparison -> A.Expr -> ProjOrigin -> NonEmpty QName -> A.Args -> Type -> TCM Term checkProjApp cmp e o ds args0 t = do (v, ti, targetCheck) <- inferOrCheckProjApp e o ds args0 (Just (cmp, t)) coerce' cmp targetCheck v ti t @@ -852,7 +931,7 @@ -- | Checking the type of an overloaded projection application. -- See 'inferOrCheckProjAppToKnownPrincipalArg'. -checkProjAppToKnownPrincipalArg :: Comparison -> A.Expr -> ProjOrigin -> NonemptyList QName -> A.Args -> Type -> Int -> Term -> Type -> TCM Term +checkProjAppToKnownPrincipalArg :: Comparison -> A.Expr -> ProjOrigin -> NonEmpty QName -> A.Args -> Type -> Int -> Term -> Type -> TCM Term checkProjAppToKnownPrincipalArg cmp e o ds args0 t k v0 pt = do (v, ti, targetCheck) <- inferOrCheckProjAppToKnownPrincipalArg e o ds args0 (Just (cmp, t)) k v0 pt coerce' cmp targetCheck v ti t @@ -867,7 +946,7 @@ -- ^ The whole expression which constitutes the application. -> ProjOrigin -- ^ The origin of the projection involved in this projection application. - -> NonemptyList QName + -> NonEmpty QName -- ^ The projection name (potentially ambiguous). -> A.Args -- ^ The arguments to the projection. @@ -909,13 +988,13 @@ -- If we have the type, we can try to get the type of the principal argument. -- It is the first visible argument. TelV _ptel core <- telViewUpTo' (-1) (not . visible) t - ifBlockedType core (\ m _ -> postpone m) $ {-else-} \ _ core -> do + ifBlocked core (\ m _ -> postpone m) $ {-else-} \ _ core -> do ifNotPiType core (\ _ -> refuseProjNotApplied ds) $ {-else-} \ dom _b -> do - ifBlockedType (unDom dom) (\ m _ -> postpone m) $ {-else-} \ _ ta -> do + ifBlocked (unDom dom) (\ m _ -> postpone m) $ {-else-} \ _ ta -> do caseMaybeM (isRecordType ta) (refuseProjNotRecordType ds) $ \ (_q, _pars, defn) -> do case defn of Record { recFields = fs } -> do - case forMaybe fs $ \ (Arg _ f) -> List.find (f ==) (toList ds) of + case forMaybe fs $ \ f -> List.find (unDom f ==) (NonEmpty.toList ds) of [] -> refuseProjNoMatching ds [d] -> do storeDisambiguatedName d @@ -937,7 +1016,7 @@ -- | Same arguments 'inferOrCheckProjApp' above but also gets the position, -- value and type of the principal argument. inferOrCheckProjAppToKnownPrincipalArg :: - A.Expr -> ProjOrigin -> NonemptyList QName -> A.Args -> Maybe (Comparison, Type) -> + A.Expr -> ProjOrigin -> NonEmpty QName -> A.Args -> Maybe (Comparison, Type) -> Int -> Term -> Type -> TCM (Term, Type, CheckedTarget) inferOrCheckProjAppToKnownPrincipalArg e o ds args mt k v0 ta = do let cmp = caseMaybe mt CmpEq fst @@ -948,7 +1027,7 @@ -- ta should be a record type (after introducing the hidden args in v0) (vargs, ta) <- implicitArgs (-1) (not . visible) ta let v = v0 `apply` vargs - ifBlockedType ta (\ m _ -> postpone m) {-else-} $ \ _ ta -> do + ifBlocked ta (\ m _ -> postpone m) {-else-} $ \ _ ta -> do caseMaybeM (isRecordType ta) (refuseProjNotRecordType ds) $ \ (q, _pars0, _) -> do -- try to project it with all of the possible projections @@ -1005,10 +1084,10 @@ -- the correct disambiguation. -- guard (size tel == size pars) - guard =<< do isNothing <$> do lift $ checkRelevance' d def + guard =<< do isNothing <$> do lift $ checkModality' d def return (orig, (d, (pars, (dom, u, tb)))) - cands <- groupOn fst . catMaybes <$> mapM (runMaybeT . try) (toList ds) + cands <- groupOn fst . catMaybes <$> mapM (runMaybeT . try) (NonEmpty.toList ds) case cands of [] -> refuseProjNoMatching ds [[]] -> refuseProjNoMatching ds @@ -1040,13 +1119,13 @@ return (v, tc, NotCheckedTarget) -refuseProj :: NonemptyList QName -> String -> TCM a +refuseProj :: NonEmpty QName -> String -> TCM a refuseProj ds reason = typeError $ GenericError $ "Cannot resolve overloaded projection " - ++ prettyShow (A.nameConcrete $ A.qnameName $ headNe ds) + ++ prettyShow (A.nameConcrete $ A.qnameName $ NonEmpty.head ds) ++ " because " ++ reason -refuseProjNotApplied, refuseProjNoMatching, refuseProjNotRecordType :: NonemptyList QName -> TCM a +refuseProjNotApplied, refuseProjNoMatching, refuseProjNotRecordType :: NonEmpty QName -> TCM a refuseProjNotApplied ds = refuseProj ds "it is not applied to a visible argument" refuseProjNoMatching ds = refuseProj ds "no matching candidate found" refuseProjNotRecordType ds = refuseProj ds "principal argument is not of record type" @@ -1076,19 +1155,21 @@ -- postpone checking of patterns when we don't know their types (Issue480). forcedType <- do lvl <- levelType - (_, l) <- newValueMeta RunMetaOccursCheck lvl + (_, l) <- newValueMeta RunMetaOccursCheck CmpLeq lvl lv <- levelView l - (_, a) <- newValueMeta RunMetaOccursCheck (sort $ Type lv) + (_, a) <- newValueMeta RunMetaOccursCheck CmpEq (sort $ Type lv) return $ El (Type lv) $ Def inf [Apply $ setHiding Hidden $ defaultArg l, Apply $ defaultArg a] - wrapper <- inFreshModuleIfFreeParams $ do + wrapper <- inFreshModuleIfFreeParams $ localTC (set eQuantity topQuantity) $ do + -- Andreas, 2019-10-12: create helper functions in non-erased mode. + -- Otherwise, they are not usable in meta-solutions in the term world. c' <- setRange (getRange c) <$> liftM2 qualify (killRange <$> currentModule) (freshName_ name) -- Define and type check the fresh function. - rel <- asksTC envRelevance - abs <- aModeToDef <$> asksTC envAbstractMode + mod <- asksTC getModality + abs <- asksTC (^. lensIsAbstract) let info = A.mkDefInfo (A.nameConcrete $ A.qnameName c') noFixity' PublicAccess abs noRange core = A.LHSProj { A.lhsDestructor = unambiguous flat @@ -1101,9 +1182,10 @@ i <- currentOrFreshMutualBlock -- If we are in irrelevant position, add definition irrelevantly. + -- If we are in erased position, add definition as erased. -- TODO: is this sufficient? addConstant c' =<< do - let ai = setRelevance rel defaultArgInfo + let ai = setModality mod defaultArgInfo useTerPragma $ (defaultDefn ai c' forcedType emptyFunction) { defMutual = i } @@ -1114,10 +1196,10 @@ def <- theDef <$> getConstInfo c' vcat $ [ "The coinductive wrapper" - , nest 2 $ prettyTCM rel <> prettyTCM c' <+> ":" + , nest 2 $ prettyTCM mod <> (prettyTCM c' <+> ":") , nest 4 $ prettyTCM t , nest 2 $ prettyA clause - , "The definition is" <+> text (show $ funDelayed def) <> + , ("The definition is" <+> text (show $ funDelayed def)) <> "." ] return c' @@ -1275,7 +1357,7 @@ -- → {T : Partial φ (Set ℓ')} → {e : PartialP φ (λ o → T o ≃ A)} -- → (t : PartialP φ T) → (a : A) → primGlue A T e@ -- --- Check @φ ⊢ a = t 1=1@ or actually the equivalent: @(\ _ → a) = t : PartialP φ T@ +-- Check @φ ⊢ a = e 1=1 (t 1=1)@ or actually the equivalent: @(\ _ → a) = (\ o -> e o (t o)) : PartialP φ A@ check_glue :: QName -> MaybeRanges -> Args -> Type -> TCM Args check_glue c rs vs _ = do case vs of @@ -1293,4 +1375,32 @@ ta <- el' (pure $ unArg la) (pure $ unArg bA) a <- blockArg ta (rs !!! 7) a $ equalTerm ty a' v return $ la : lb : bA : phi : bT : e : t : a : rest + _ -> typeError $ GenericError $ show c ++ " must be fully applied" + + +-- | @prim^glueU : ∀ {ℓ} {φ : I} +-- → {T : I → Partial φ (Set ℓ)} → {A : Set ℓ [ φ ↦ T i0 ]} +-- → (t : PartialP φ (T i1)) → (a : outS A) → hcomp T (outS A)@ +-- +-- Check @φ ⊢ a = transp (\ i -> T 1=1 (~ i)) i0 (t 1=1)@ or actually the equivalent: +-- @(\ _ → a) = (\o -> transp (\ i -> T o (~ i)) i0 (t o)) : PartialP φ (T i0)@ +check_glueU :: QName -> MaybeRanges -> Args -> Type -> TCM Args +check_glueU c rs vs _ = do + case vs of + -- WAS: [la, lb, bA, phi, bT, e, t, a] -> do + la : phi : bT : bA : t : a : rest -> do + let iinfo = setRelevance Irrelevant defaultArgInfo + v <- runNamesT [] $ do + [la, phi, bT, bA, t] <- mapM (open . unArg) [la, phi, bT, bA, t] + let f o = cl primTrans <#> (lam "i" $ const la) <@> (lam "i" $ \ i -> bT <@> (cl primINeg <@> i) <..> o) <@> cl primIZero + glam iinfo "o" $ \ o -> f o <@> (t <..> o) + ty <- runNamesT [] $ do + [la, phi, bT] <- mapM (open . unArg) [la, phi, bT] + pPi' "o" phi $ \ o -> el' la (bT <@> cl primIZero <..> o) + let a' = Lam iinfo (NoAbs "o" $ unArg a) + ta <- runNamesT [] $ do + [la, phi, bT, bA] <- mapM (open . unArg) [la, phi, bT, bA] + el' la (cl primSubOut <#> (cl primLevelSuc <@> la) <#> (Sort . tmSort <$> la) <#> phi <#> (bT <@> cl primIZero) <@> bA) + a <- blockArg ta (rs !!! 5) a $ equalTerm ty a' v + return $ la : phi : bT : bA : t : a : rest _ -> typeError $ GenericError $ show c ++ " must be fully applied" diff --git a/src/full/Agda/TypeChecking/Rules/Application.hs-boot b/src/full/Agda/TypeChecking/Rules/Application.hs-boot --- a/src/full/Agda/TypeChecking/Rules/Application.hs-boot +++ b/src/full/Agda/TypeChecking/Rules/Application.hs-boot @@ -1,12 +1,13 @@ module Agda.TypeChecking.Rules.Application where +import Data.List.NonEmpty (NonEmpty) + import Agda.Syntax.Common (NamedArg, ProjOrigin) import qualified Agda.Syntax.Abstract as A import Agda.Syntax.Internal import Agda.Syntax.Position import Agda.TypeChecking.Monad.Base -import Agda.Utils.NonemptyList checkArguments :: ExpandHidden -> Range -> [NamedArg A.Expr] -> Type -> Type -> ([Maybe Range] -> Elims -> Type -> CheckedTarget -> TCM Term) -> TCM Term @@ -18,4 +19,4 @@ inferApplication :: ExpandHidden -> A.Expr -> A.Args -> A.Expr -> TCM (Term, Type) -checkProjAppToKnownPrincipalArg :: Comparison -> A.Expr -> ProjOrigin -> NonemptyList QName -> A.Args -> Type -> Int -> Term -> Type -> TCM Term +checkProjAppToKnownPrincipalArg :: Comparison -> A.Expr -> ProjOrigin -> NonEmpty QName -> A.Args -> Type -> Int -> Term -> Type -> TCM Term diff --git a/src/full/Agda/TypeChecking/Rules/Builtin.hs b/src/full/Agda/TypeChecking/Rules/Builtin.hs --- a/src/full/Agda/TypeChecking/Rules/Builtin.hs +++ b/src/full/Agda/TypeChecking/Rules/Builtin.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE NondecreasingIndentation #-} module Agda.TypeChecking.Rules.Builtin @@ -10,17 +9,13 @@ , bindUntypedBuiltin ) where -import Control.Applicative hiding (empty) import Control.Monad -import Control.Monad.Reader (ask) -import Control.Monad.State (get) import Data.List (find, sortBy) +import Data.List.NonEmpty (NonEmpty(..)) +import qualified Data.List.NonEmpty as NonEmpty import Data.Function (on) -import Agda.Interaction.Options (optSizedTypes) - import qualified Agda.Syntax.Abstract as A -import qualified Agda.Syntax.Abstract.Views as A import Agda.Syntax.Common import Agda.Syntax.Internal import Agda.Syntax.Position @@ -53,12 +48,9 @@ import Agda.Utils.List import Agda.Utils.Maybe import Agda.Utils.Monad -import Agda.Utils.NonemptyList import Agda.Utils.Null -import Agda.Utils.Permutation import Agda.Utils.Size -#include "undefined.h" import Agda.Utils.Impossible --------------------------------------------------------------------------- @@ -76,282 +68,303 @@ coreBuiltins :: [BuiltinInfo] coreBuiltins = - [ (builtinList |-> BuiltinData (tset --> tset) [builtinNil, builtinCons]) - , (builtinArg |-> BuiltinData (tset --> tset) [builtinArgArg]) - , (builtinAbs |-> BuiltinData (tset --> tset) [builtinAbsAbs]) - , (builtinArgInfo |-> BuiltinData tset [builtinArgArgInfo]) - , (builtinBool |-> BuiltinData tset [builtinTrue, builtinFalse]) - , (builtinNat |-> BuiltinData tset [builtinZero, builtinSuc]) - , (builtinSigma |-> BuiltinData (runNamesT [] $ - hPi' "la" (el $ cl primLevel) $ \ a -> - hPi' "lb" (el $ cl primLevel) $ \ b -> - nPi' "A" (sort . tmSort <$> a) $ \bA -> - nPi' "B" (el' a bA --> (sort . tmSort <$> b)) $ \bB -> - ((sort . tmSort) <$> (cl primLevelMax <@> a <@> b)) - ) - ["SIGMACON"]) - , (builtinUnit |-> BuiltinData tset [builtinUnitUnit]) -- actually record, but they are treated the same - , (builtinAgdaLiteral |-> BuiltinData tset [builtinAgdaLitNat, builtinAgdaLitWord64, builtinAgdaLitFloat, - builtinAgdaLitChar, builtinAgdaLitString, - builtinAgdaLitQName, builtinAgdaLitMeta]) - , (builtinAgdaPattern |-> BuiltinData tset [builtinAgdaPatVar, builtinAgdaPatCon, builtinAgdaPatDot, - builtinAgdaPatLit, builtinAgdaPatProj, builtinAgdaPatAbsurd]) - , (builtinAgdaPatVar |-> BuiltinDataCons (tstring --> tpat)) - , (builtinAgdaPatCon |-> BuiltinDataCons (tqname --> tlist (targ tpat) --> tpat)) - , (builtinAgdaPatDot |-> BuiltinDataCons tpat) - , (builtinAgdaPatLit |-> BuiltinDataCons (tliteral --> tpat)) - , (builtinAgdaPatProj |-> BuiltinDataCons (tqname --> tpat)) - , (builtinAgdaPatAbsurd |-> BuiltinDataCons tpat) - , (builtinLevel |-> builtinPostulate tset) - , (builtinWord64 |-> builtinPostulate tset) - , (builtinInteger |-> BuiltinData tset [builtinIntegerPos, builtinIntegerNegSuc]) - , (builtinIntegerPos |-> BuiltinDataCons (tnat --> tinteger)) - , (builtinIntegerNegSuc |-> BuiltinDataCons (tnat --> tinteger)) - , (builtinFloat |-> builtinPostulate tset) - , (builtinChar |-> builtinPostulate tset) - , (builtinString |-> builtinPostulate tset) - , (builtinQName |-> builtinPostulate tset) - , (builtinAgdaMeta |-> builtinPostulate tset) - , (builtinIO |-> builtinPostulate (tset --> tset)) - , (builtinPath |-> BuiltinUnknown - (Just $ requireCubical >> - (hPi "a" (el primLevel) $ - hPi "A" (return $ sort $ varSort 0) $ - (El (varSort 1) <$> varM 0) --> - (El (varSort 1) <$> varM 0) --> - return (sort $ varSort 1))) - verifyPath) - , (builtinPathP |-> builtinPostulateC (hPi "a" (el primLevel) $ - nPi "A" (tinterval --> (return $ sort $ varSort 0)) $ - (El (varSort 1) <$> varM 0 <@> primIZero) --> - (El (varSort 1) <$> varM 0 <@> primIOne) --> - return (sort $ varSort 1))) - , (builtinInterval |-> BuiltinData (requireCubical >> return (sort Inf)) [builtinIZero,builtinIOne]) - , (builtinSub |-> builtinPostulateC (runNamesT [] $ hPi' "a" (el $ cl primLevel) $ \ a -> - nPi' "A" (el' (cl primLevelSuc <@> a) (Sort . tmSort <$> a)) $ \ bA -> - nPi' "φ" (elInf $ cl primInterval) $ \ phi -> - elInf (cl primPartial <#> a <@> phi <@> bA) --> (return $ sort Inf) - )) - , (builtinSubIn |-> builtinPostulateC (runNamesT [] $ - hPi' "a" (el $ cl primLevel) $ \ a -> - hPi' "A" (el' (cl primLevelSuc <@> a) (Sort . tmSort <$> a)) $ \ bA -> - hPi' "φ" (elInf $ cl primInterval) $ \ phi -> - nPi' "x" (el' (Sort . tmSort <$> a) bA) $ \ x -> - elInf $ cl primSub <#> a <@> bA <@> phi <@> (lam "o" $ \ _ -> x))) - , (builtinIZero |-> BuiltinDataCons (elInf primInterval)) - , (builtinIOne |-> BuiltinDataCons (elInf primInterval)) - , (builtinPartial |-> BuiltinPrim "primPartial" (const $ return ())) - , (builtinPartialP |-> BuiltinPrim "primPartialP" (const $ return ())) - , (builtinIsOne |-> builtinPostulateC (tinterval --> return (sort $ Inf))) - , (builtinItIsOne |-> builtinPostulateC (elInf $ primIsOne <@> primIOne)) - , (builtinIsOne1 |-> builtinPostulateC (runNamesT [] $ - nPi' "i" (cl tinterval) $ \ i -> - nPi' "j" (cl tinterval) $ \ j -> - nPi' "i1" (elInf $ cl primIsOne <@> i) $ \ i1 -> - (elInf $ cl primIsOne <@> (cl primIMax <@> i <@> j)))) - , (builtinIsOne2 |-> builtinPostulateC (runNamesT [] $ - nPi' "i" (cl tinterval) $ \ i -> - nPi' "j" (cl tinterval) $ \ j -> - nPi' "j1" (elInf $ cl primIsOne <@> j) $ \ j1 -> - (elInf $ cl primIsOne <@> (cl primIMax <@> i <@> j)))) - , (builtinIsOneEmpty |-> builtinPostulateC (runNamesT [] $ - hPi' "l" (el $ cl primLevel) $ \ l -> - hPi' "A" (pPi' "o" (cl primIZero) $ \ _ -> - el' (cl primLevelSuc <@> l) (Sort . tmSort <$> l)) $ \ bA -> - pPi' "o" (cl primIZero) (\ o -> el' l $ gApply' (setRelevance Irrelevant defaultArgInfo) bA o))) + [ (builtinList |-> BuiltinData (tset --> tset) [builtinNil, builtinCons]) + , (builtinArg |-> BuiltinData (tset --> tset) [builtinArgArg]) + , (builtinAbs |-> BuiltinData (tset --> tset) [builtinAbsAbs]) + , (builtinArgInfo |-> BuiltinData tset [builtinArgArgInfo]) + , (builtinBool |-> BuiltinData tset [builtinTrue, builtinFalse]) + , (builtinNat |-> BuiltinData tset [builtinZero, builtinSuc]) + , (builtinSigma |-> BuiltinData (runNamesT [] $ + hPi' "la" (el $ cl primLevel) $ \ a -> + hPi' "lb" (el $ cl primLevel) $ \ b -> + nPi' "A" (sort . tmSort <$> a) $ \bA -> + nPi' "B" (el' a bA --> (sort . tmSort <$> b)) $ \bB -> + ((sort . tmSort) <$> (cl primLevelMax <@> a <@> b)) + ) + ["SIGMACON"]) + , (builtinUnit |-> BuiltinData tset [builtinUnitUnit]) -- actually record, but they are treated the same + , (builtinAgdaLiteral |-> BuiltinData tset [builtinAgdaLitNat, builtinAgdaLitWord64, builtinAgdaLitFloat, + builtinAgdaLitChar, builtinAgdaLitString, + builtinAgdaLitQName, builtinAgdaLitMeta]) + , (builtinAgdaPattern |-> BuiltinData tset [builtinAgdaPatVar, builtinAgdaPatCon, builtinAgdaPatDot, + builtinAgdaPatLit, builtinAgdaPatProj, builtinAgdaPatAbsurd]) + , (builtinAgdaPatVar |-> BuiltinDataCons (tstring --> tpat)) + , (builtinAgdaPatCon |-> BuiltinDataCons (tqname --> tlist (targ tpat) --> tpat)) + , (builtinAgdaPatDot |-> BuiltinDataCons tpat) + , (builtinAgdaPatLit |-> BuiltinDataCons (tliteral --> tpat)) + , (builtinAgdaPatProj |-> BuiltinDataCons (tqname --> tpat)) + , (builtinAgdaPatAbsurd |-> BuiltinDataCons tpat) + , (builtinLevel |-> builtinPostulate tset) + , (builtinWord64 |-> builtinPostulate tset) + , (builtinInteger |-> BuiltinData tset [builtinIntegerPos, builtinIntegerNegSuc]) + , (builtinIntegerPos |-> BuiltinDataCons (tnat --> tinteger)) + , (builtinIntegerNegSuc |-> BuiltinDataCons (tnat --> tinteger)) + , (builtinFloat |-> builtinPostulate tset) + , (builtinChar |-> builtinPostulate tset) + , (builtinString |-> builtinPostulate tset) + , (builtinQName |-> builtinPostulate tset) + , (builtinAgdaMeta |-> builtinPostulate tset) + , (builtinIO |-> builtinPostulate (tset --> tset)) + , (builtinPath |-> BuiltinUnknown + (Just $ requireCubical >> + (hPi "a" (el primLevel) $ + hPi "A" (return $ sort $ varSort 0) $ + (El (varSort 1) <$> varM 0) --> + (El (varSort 1) <$> varM 0) --> + return (sort $ varSort 1))) + verifyPath) + , (builtinPathP |-> builtinPostulateC (hPi "a" (el primLevel) $ + nPi "A" (tinterval --> (return $ sort $ varSort 0)) $ + (El (varSort 1) <$> varM 0 <@> primIZero) --> + (El (varSort 1) <$> varM 0 <@> primIOne) --> + return (sort $ varSort 1))) + , (builtinInterval |-> BuiltinData (requireCubical >> return (sort Inf)) [builtinIZero,builtinIOne]) + , (builtinSub |-> builtinPostulateC (runNamesT [] $ hPi' "a" (el $ cl primLevel) $ \ a -> + nPi' "A" (el' (cl primLevelSuc <@> a) (Sort . tmSort <$> a)) $ \ bA -> + nPi' "φ" (elInf $ cl primInterval) $ \ phi -> + elInf (cl primPartial <#> a <@> phi <@> bA) --> (return $ sort Inf) + )) + , (builtinSubIn |-> builtinPostulateC (runNamesT [] $ + hPi' "a" (el $ cl primLevel) $ \ a -> + hPi' "A" (el' (cl primLevelSuc <@> a) (Sort . tmSort <$> a)) $ \ bA -> + hPi' "φ" (elInf $ cl primInterval) $ \ phi -> + nPi' "x" (el' (Sort . tmSort <$> a) bA) $ \ x -> + elInf $ cl primSub <#> a <@> bA <@> phi <@> (lam "o" $ \ _ -> x))) + , (builtinIZero |-> BuiltinDataCons (elInf primInterval)) + , (builtinIOne |-> BuiltinDataCons (elInf primInterval)) + , (builtinPartial |-> BuiltinPrim "primPartial" (const $ return ())) + , (builtinPartialP |-> BuiltinPrim "primPartialP" (const $ return ())) + , (builtinIsOne |-> builtinPostulateC (tinterval --> return (sort $ Inf))) + , (builtinItIsOne |-> builtinPostulateC (elInf $ primIsOne <@> primIOne)) + , (builtinIsOne1 |-> builtinPostulateC (runNamesT [] $ + nPi' "i" (cl tinterval) $ \ i -> + nPi' "j" (cl tinterval) $ \ j -> + nPi' "i1" (elInf $ cl primIsOne <@> i) $ \ i1 -> + (elInf $ cl primIsOne <@> (cl primIMax <@> i <@> j)))) + , (builtinIsOne2 |-> builtinPostulateC (runNamesT [] $ + nPi' "i" (cl tinterval) $ \ i -> + nPi' "j" (cl tinterval) $ \ j -> + nPi' "j1" (elInf $ cl primIsOne <@> j) $ \ j1 -> + (elInf $ cl primIsOne <@> (cl primIMax <@> i <@> j)))) + , (builtinIsOneEmpty |-> builtinPostulateC (runNamesT [] $ + hPi' "l" (el $ cl primLevel) $ \ l -> + hPi' "A" (pPi' "o" (cl primIZero) $ \ _ -> + el' (cl primLevelSuc <@> l) (Sort . tmSort <$> l)) $ \ bA -> + pPi' "o" (cl primIZero) (\ o -> + el' l $ gApply' (setRelevance Irrelevant defaultArgInfo) bA o))) - , (builtinId |-> builtinPostulateC (hPi "a" (el primLevel) $ - hPi "A" (return $ sort $ varSort 0) $ - (El (varSort 1) <$> varM 0) --> - (El (varSort 1) <$> varM 0) --> - return (sort $ varSort 1))) - , (builtinConId |-> builtinPostulateC (hPi "a" (el primLevel) $ - hPi "A" (return $ sort $ varSort 0) $ - hPi "x" (El (varSort 1) <$> varM 0) $ - hPi "y" (El (varSort 2) <$> varM 1) $ - tinterval --> (El (varSort 3) <$> primPath <#> varM 3 <#> varM 2 <@> varM 1 <@> varM 0) --> - (El (varSort 3) <$> primId <#> varM 3 <#> varM 2 <@> varM 1 <@> varM 0))) - , (builtinEquiv |-> BuiltinUnknown (Just $ requireCubical >> runNamesT [] ( - hPi' "l" (el $ cl primLevel) $ \ a -> - hPi' "l'" (el $ cl primLevel) $ \ b -> - nPi' "A" (sort . tmSort <$> a) $ \bA -> - nPi' "B" (sort . tmSort <$> b) $ \bB -> - ((sort . tmSort) <$> (cl primLevelMax <@> a <@> b)) - )) - (const $ const $ return ())) - , (builtinEquivFun |-> BuiltinUnknown (Just $ requireCubical >> runNamesT [] ( - hPi' "l" (el $ cl primLevel) $ \ a -> - hPi' "l'" (el $ cl primLevel) $ \ b -> - hPi' "A" (sort . tmSort <$> a) $ \bA -> - hPi' "B" (sort . tmSort <$> b) $ \bB -> - el' (cl primLevelMax <@> a <@> b) (cl primEquiv <#> a <#> b <@> bA <@> bB) --> (el' a bA --> el' b bB) - )) - (const $ const $ return ())) - , (builtinEquivProof |-> BuiltinUnknown (Just $ requireCubical >> runNamesT [] ( - hPi' "l" (el $ cl primLevel) $ \ la -> - hPi' "l'" (el $ cl primLevel) $ \ lb -> - nPi' "A" (sort . tmSort <$> la) $ \ bA -> - nPi' "B" (sort . tmSort <$> lb) $ \ bB -> - nPi' "e" (el' (cl primLevelMax <@> la <@> lb) (cl primEquiv <#> la <#> lb <@> bA <@> bB)) $ \ e -> do - nPi' "b" (el' lb bB) $ \ b -> do - let f = cl primEquivFun <#> la <#> lb <#> bA <#> bB <@> e - fiber = el' (cl primLevelMax <@> la <@> lb) (cl primSigma <#> la <#> lb - <@> bA - <@> (lam "a" $ \ a -> cl primPath <#> lb <#> bB <@> (f <@> a) <@> b)) - nPi' "φ" (cl tinterval) $ \ phi -> - (pPi' "o" phi $ \ o -> fiber) --> fiber - )) - (const $ const $ return ())) - , (builtinPathToEquiv |-> BuiltinUnknown - (Just $ requireCubical >> runNamesT [] ( - hPi' "l" (cl tinterval --> (el $ cl primLevel)) $ \ a -> - nPi' "E" (nPi' "i" (cl tinterval) $ \ i -> (sort . tmSort <$> (a <@> i))) $ \bE -> - el' (cl primLevelMax <@> (a <@> cl primIZero) <@> (a <@> cl primIOne)) - (cl primEquiv <#> (a <@> cl primIZero) <#> (a <@> cl primIOne) <@> (bE <@> cl primIZero) <@> (bE <@> cl primIOne) - ))) - (const $ const $ return ())) - , (builtinAgdaSort |-> BuiltinData tset [builtinAgdaSortSet, builtinAgdaSortLit, builtinAgdaSortUnsupported]) - , (builtinAgdaTerm |-> BuiltinData tset - [ builtinAgdaTermVar, builtinAgdaTermLam, builtinAgdaTermExtLam - , builtinAgdaTermDef, builtinAgdaTermCon - , builtinAgdaTermPi, builtinAgdaTermSort - , builtinAgdaTermLit, builtinAgdaTermMeta - , builtinAgdaTermUnsupported]) - , builtinAgdaErrorPart |-> BuiltinData tset [ builtinAgdaErrorPartString, builtinAgdaErrorPartTerm, builtinAgdaErrorPartName ] - , builtinAgdaErrorPartString |-> BuiltinDataCons (tstring --> terrorpart) - , builtinAgdaErrorPartTerm |-> BuiltinDataCons (tterm --> terrorpart) - , builtinAgdaErrorPartName |-> BuiltinDataCons (tqname --> terrorpart) + , (builtinId |-> builtinPostulateC (hPi "a" (el primLevel) $ + hPi "A" (return $ sort $ varSort 0) $ + (El (varSort 1) <$> varM 0) --> + (El (varSort 1) <$> varM 0) --> + return (sort $ varSort 1))) + , (builtinConId |-> builtinPostulateC (hPi "a" (el primLevel) $ + hPi "A" (return $ sort $ varSort 0) $ + hPi "x" (El (varSort 1) <$> varM 0) $ + hPi "y" (El (varSort 2) <$> varM 1) $ + tinterval --> + (El (varSort 3) <$> primPath <#> varM 3 <#> varM 2 <@> varM 1 <@> varM 0) --> + (El (varSort 3) <$> primId <#> varM 3 <#> varM 2 <@> varM 1 <@> varM 0))) + , (builtinEquiv |-> BuiltinUnknown (Just $ requireCubical >> runNamesT [] ( + hPi' "l" (el $ cl primLevel) $ \ a -> + hPi' "l'" (el $ cl primLevel) $ \ b -> + nPi' "A" (sort . tmSort <$> a) $ \bA -> + nPi' "B" (sort . tmSort <$> b) $ \bB -> + ((sort . tmSort) <$> (cl primLevelMax <@> a <@> b)) + )) + (const $ const $ return ())) + , (builtinEquivFun |-> BuiltinUnknown (Just $ requireCubical >> runNamesT [] ( + hPi' "l" (el $ cl primLevel) $ \ a -> + hPi' "l'" (el $ cl primLevel) $ \ b -> + hPi' "A" (sort . tmSort <$> a) $ \bA -> + hPi' "B" (sort . tmSort <$> b) $ \bB -> + el' (cl primLevelMax <@> a <@> b) (cl primEquiv <#> a <#> b <@> bA <@> bB) --> + (el' a bA --> el' b bB) + )) + (const $ const $ return ())) + , (builtinEquivProof |-> BuiltinUnknown (Just $ requireCubical >> runNamesT [] ( + hPi' "l" (el $ cl primLevel) $ \ la -> + hPi' "l'" (el $ cl primLevel) $ \ lb -> + nPi' "A" (sort . tmSort <$> la) $ \ bA -> + nPi' "B" (sort . tmSort <$> lb) $ \ bB -> + nPi' "e" (el' (cl primLevelMax <@> la <@> lb) + (cl primEquiv <#> la <#> lb <@> bA <@> bB)) $ \ e -> do + nPi' "b" (el' lb bB) $ \ b -> do + let f = cl primEquivFun <#> la <#> lb <#> bA <#> bB <@> e + fiber = el' (cl primLevelMax <@> la <@> lb) + (cl primSigma <#> la <#> lb + <@> bA + <@> (lam "a" $ \ a -> + cl primPath <#> lb <#> bB <@> (f <@> a) <@> b)) + nPi' "φ" (cl tinterval) $ \ phi -> + (pPi' "o" phi $ \ o -> fiber) --> fiber + )) + (const $ const $ return ())) + , (builtinTranspProof |-> BuiltinUnknown (Just $ requireCubical >> runNamesT [] ( + hPi' "l" (el $ cl primLevel) $ \ la -> do + nPi' "e" (cl tinterval --> (sort . tmSort <$> la)) $ \ e -> do + let lb = la; bA = e <@> cl primIZero; bB = e <@> cl primIOne + nPi' "φ" (cl tinterval) $ \ phi -> do + nPi' "a" (pPi' "o" phi (\ _ -> el' la bA)) $ \ a -> do + let f = cl primTrans <#> (lam "i" $ \ _ -> la) <@> e <@> cl primIZero + z = ilam "o" $ \ o -> f <@> (a <@> o) + nPi' "b" (elInf (cl primSub <#> lb <@> bB <@> phi <@> z)) $ \ b' -> do + let b = cl primSubOut <#> lb <#> bB <#> phi <#> z <@> b' + fiber = el' la + (cl primSigma <#> la <#> lb + <@> bA + <@> (lam "a" $ \ a -> + cl primPath <#> lb <#> bB <@> (f <@> a) <@> b)) + fiber + )) + (const $ const $ return ())) + , (builtinAgdaSort |-> BuiltinData tset [builtinAgdaSortSet, builtinAgdaSortLit, builtinAgdaSortUnsupported]) + , (builtinAgdaTerm |-> BuiltinData tset + [ builtinAgdaTermVar, builtinAgdaTermLam, builtinAgdaTermExtLam + , builtinAgdaTermDef, builtinAgdaTermCon + , builtinAgdaTermPi, builtinAgdaTermSort + , builtinAgdaTermLit, builtinAgdaTermMeta + , builtinAgdaTermUnsupported]) + , builtinAgdaErrorPart |-> BuiltinData tset [ builtinAgdaErrorPartString, builtinAgdaErrorPartTerm, builtinAgdaErrorPartName ] + , builtinAgdaErrorPartString |-> BuiltinDataCons (tstring --> terrorpart) + , builtinAgdaErrorPartTerm |-> BuiltinDataCons (tterm --> terrorpart) + , builtinAgdaErrorPartName |-> BuiltinDataCons (tqname --> terrorpart) -- Andreas, 2017-01-12, issue #2386: special handling of builtinEquality - -- , (builtinEquality |-> BuiltinData (hPi "a" (el primLevel) $ - -- hPi "A" (return $ sort $ varSort 0) $ - -- (El (varSort 1) <$> varM 0) --> - -- (El (varSort 1) <$> varM 0) --> - -- return (sort $ varSort 1)) - -- [builtinRefl]) - , (builtinHiding |-> BuiltinData tset [builtinHidden, builtinInstance, builtinVisible]) + -- , (builtinEquality |-> BuiltinData (hPi "a" (el primLevel) $ + -- hPi "A" (return $ sort $ varSort 0) $ + -- (El (varSort 1) <$> varM 0) --> + -- (El (varSort 1) <$> varM 0) --> + -- return (sort $ varSort 1)) + -- [builtinRefl]) + , (builtinHiding |-> BuiltinData tset [builtinHidden, builtinInstance, builtinVisible]) -- Relevance - , (builtinRelevance |-> BuiltinData tset [builtinRelevant, builtinIrrelevant]) - , (builtinRelevant |-> BuiltinDataCons trelevance) - , (builtinIrrelevant |-> BuiltinDataCons trelevance) + , (builtinRelevance |-> BuiltinData tset [builtinRelevant, builtinIrrelevant]) + , (builtinRelevant |-> BuiltinDataCons trelevance) + , (builtinIrrelevant |-> BuiltinDataCons trelevance) -- Associativity - , builtinAssoc |-> BuiltinData tset [builtinAssocLeft, builtinAssocRight, builtinAssocNon] - , builtinAssocLeft |-> BuiltinDataCons tassoc - , builtinAssocRight |-> BuiltinDataCons tassoc - , builtinAssocNon |-> BuiltinDataCons tassoc + , builtinAssoc |-> BuiltinData tset [builtinAssocLeft, builtinAssocRight, builtinAssocNon] + , builtinAssocLeft |-> BuiltinDataCons tassoc + , builtinAssocRight |-> BuiltinDataCons tassoc + , builtinAssocNon |-> BuiltinDataCons tassoc -- Precedence - , builtinPrecedence |-> BuiltinData tset [builtinPrecRelated, builtinPrecUnrelated] - , builtinPrecRelated |-> BuiltinDataCons (tint --> tprec) - , builtinPrecUnrelated |-> BuiltinDataCons tprec + , builtinPrecedence |-> BuiltinData tset [builtinPrecRelated, builtinPrecUnrelated] + , builtinPrecRelated |-> BuiltinDataCons (tfloat --> tprec) + , builtinPrecUnrelated |-> BuiltinDataCons tprec -- Fixity - , builtinFixity |-> BuiltinData tset [builtinFixityFixity] - , builtinFixityFixity |-> BuiltinDataCons (tassoc --> tprec --> tfixity) + , builtinFixity |-> BuiltinData tset [builtinFixityFixity] + , builtinFixityFixity |-> BuiltinDataCons (tassoc --> tprec --> tfixity) -- Andreas, 2017-01-12, issue #2386: special handling of builtinEquality - -- , (builtinRefl |-> BuiltinDataCons (hPi "a" (el primLevel) $ - -- hPi "A" (return $ sort $ varSort 0) $ - -- hPi "x" (El (varSort 1) <$> varM 0) $ - -- El (varSort 2) <$> primEquality <#> varM 2 <#> varM 1 <@> varM 0 <@> varM 0)) - , (builtinRewrite |-> BuiltinUnknown Nothing verifyBuiltinRewrite) - , (builtinNil |-> BuiltinDataCons (hPi "A" tset (el (list v0)))) - , (builtinCons |-> BuiltinDataCons (hPi "A" tset (tv0 --> el (list v0) --> el (list v0)))) - , (builtinZero |-> BuiltinDataCons tnat) - , (builtinSuc |-> BuiltinDataCons (tnat --> tnat)) - , (builtinTrue |-> BuiltinDataCons tbool) - , (builtinFalse |-> BuiltinDataCons tbool) - , (builtinArgArg |-> BuiltinDataCons (hPi "A" tset (targinfo --> tv0 --> targ tv0))) - , (builtinAbsAbs |-> BuiltinDataCons (hPi "A" tset (tstring --> tv0 --> tabs tv0))) - , (builtinArgArgInfo |-> BuiltinDataCons (thiding --> trelevance --> targinfo)) - , (builtinAgdaTermVar |-> BuiltinDataCons (tnat --> targs --> tterm)) - , (builtinAgdaTermLam |-> BuiltinDataCons (thiding --> tabs tterm --> tterm)) - , (builtinAgdaTermExtLam |-> BuiltinDataCons (tlist tclause --> targs --> tterm)) - , (builtinAgdaTermDef |-> BuiltinDataCons (tqname --> targs --> tterm)) - , (builtinAgdaTermCon |-> BuiltinDataCons (tqname --> targs --> tterm)) - , (builtinAgdaTermPi |-> BuiltinDataCons (targ ttype --> tabs ttype --> tterm)) - , (builtinAgdaTermSort |-> BuiltinDataCons (tsort --> tterm)) - , (builtinAgdaTermLit |-> BuiltinDataCons (tliteral --> tterm)) - , (builtinAgdaTermMeta |-> BuiltinDataCons (tmeta --> targs --> tterm)) - , (builtinAgdaTermUnsupported|-> BuiltinDataCons tterm) - , (builtinAgdaLitNat |-> BuiltinDataCons (tnat --> tliteral)) - , (builtinAgdaLitWord64 |-> BuiltinDataCons (tword64 --> tliteral)) - , (builtinAgdaLitFloat |-> BuiltinDataCons (tfloat --> tliteral)) - , (builtinAgdaLitChar |-> BuiltinDataCons (tchar --> tliteral)) - , (builtinAgdaLitString |-> BuiltinDataCons (tstring --> tliteral)) - , (builtinAgdaLitQName |-> BuiltinDataCons (tqname --> tliteral)) - , (builtinAgdaLitMeta |-> BuiltinDataCons (tmeta --> tliteral)) - , (builtinHidden |-> BuiltinDataCons thiding) - , (builtinInstance |-> BuiltinDataCons thiding) - , (builtinVisible |-> BuiltinDataCons thiding) - , (builtinSizeUniv |-> builtinPostulate tSizeUniv) -- SizeUniv : SizeUniv + -- , (builtinRefl |-> BuiltinDataCons (hPi "a" (el primLevel) $ + -- hPi "A" (return $ sort $ varSort 0) $ + -- hPi "x" (El (varSort 1) <$> varM 0) $ + -- El (varSort 2) <$> primEquality <#> varM 2 <#> varM 1 <@> varM 0 <@> varM 0)) + , (builtinRewrite |-> BuiltinUnknown Nothing verifyBuiltinRewrite) + , (builtinNil |-> BuiltinDataCons (hPi "A" tset (el (list v0)))) + , (builtinCons |-> BuiltinDataCons (hPi "A" tset (tv0 --> el (list v0) --> el (list v0)))) + , (builtinZero |-> BuiltinDataCons tnat) + , (builtinSuc |-> BuiltinDataCons (tnat --> tnat)) + , (builtinTrue |-> BuiltinDataCons tbool) + , (builtinFalse |-> BuiltinDataCons tbool) + , (builtinArgArg |-> BuiltinDataCons (hPi "A" tset (targinfo --> tv0 --> targ tv0))) + , (builtinAbsAbs |-> BuiltinDataCons (hPi "A" tset (tstring --> tv0 --> tabs tv0))) + , (builtinArgArgInfo |-> BuiltinDataCons (thiding --> trelevance --> targinfo)) + , (builtinAgdaTermVar |-> BuiltinDataCons (tnat --> targs --> tterm)) + , (builtinAgdaTermLam |-> BuiltinDataCons (thiding --> tabs tterm --> tterm)) + , (builtinAgdaTermExtLam |-> BuiltinDataCons (tlist tclause --> targs --> tterm)) + , (builtinAgdaTermDef |-> BuiltinDataCons (tqname --> targs --> tterm)) + , (builtinAgdaTermCon |-> BuiltinDataCons (tqname --> targs --> tterm)) + , (builtinAgdaTermPi |-> BuiltinDataCons (targ ttype --> tabs ttype --> tterm)) + , (builtinAgdaTermSort |-> BuiltinDataCons (tsort --> tterm)) + , (builtinAgdaTermLit |-> BuiltinDataCons (tliteral --> tterm)) + , (builtinAgdaTermMeta |-> BuiltinDataCons (tmeta --> targs --> tterm)) + , (builtinAgdaTermUnsupported |-> BuiltinDataCons tterm) + , (builtinAgdaLitNat |-> BuiltinDataCons (tnat --> tliteral)) + , (builtinAgdaLitWord64 |-> BuiltinDataCons (tword64 --> tliteral)) + , (builtinAgdaLitFloat |-> BuiltinDataCons (tfloat --> tliteral)) + , (builtinAgdaLitChar |-> BuiltinDataCons (tchar --> tliteral)) + , (builtinAgdaLitString |-> BuiltinDataCons (tstring --> tliteral)) + , (builtinAgdaLitQName |-> BuiltinDataCons (tqname --> tliteral)) + , (builtinAgdaLitMeta |-> BuiltinDataCons (tmeta --> tliteral)) + , (builtinHidden |-> BuiltinDataCons thiding) + , (builtinInstance |-> BuiltinDataCons thiding) + , (builtinVisible |-> BuiltinDataCons thiding) + , (builtinSizeUniv |-> builtinPostulate tSizeUniv) -- SizeUniv : SizeUniv -- See comment on tSizeUniv: the following does not work currently. --- , (builtinSizeUniv |-> builtinPostulate tSetOmega) -- SizeUniv : Setω - , (builtinSize |-> builtinPostulate tSizeUniv) - , (builtinSizeLt |-> builtinPostulate (tsize ..--> tSizeUniv)) - , (builtinSizeSuc |-> builtinPostulate (tsize --> tsize)) - , (builtinSizeInf |-> builtinPostulate tsize) +-- , (builtinSizeUniv |-> builtinPostulate tSetOmega) -- SizeUniv : Setω + , (builtinSize |-> builtinPostulate tSizeUniv) + , (builtinSizeLt |-> builtinPostulate (tsize ..--> tSizeUniv)) + , (builtinSizeSuc |-> builtinPostulate (tsize --> tsize)) + , (builtinSizeInf |-> builtinPostulate tsize) -- postulate max : {i : Size} -> Size< i -> Size< i -> Size< i - , (builtinSizeMax |-> builtinPostulate (tsize --> tsize --> tsize)) + , (builtinSizeMax |-> builtinPostulate (tsize --> tsize --> tsize)) -- (hPi "i" tsize $ let a = el $ primSizeLt <@> v0 in (a --> a --> a))) - , (builtinAgdaSortSet |-> BuiltinDataCons (tterm --> tsort)) - , (builtinAgdaSortLit |-> BuiltinDataCons (tnat --> tsort)) - , (builtinAgdaSortUnsupported|-> BuiltinDataCons tsort) - , (builtinNatPlus |-> BuiltinPrim "primNatPlus" verifyPlus) - , (builtinNatMinus |-> BuiltinPrim "primNatMinus" verifyMinus) - , (builtinNatTimes |-> BuiltinPrim "primNatTimes" verifyTimes) - , (builtinNatDivSucAux |-> BuiltinPrim "primNatDivSucAux" verifyDivSucAux) - , (builtinNatModSucAux |-> BuiltinPrim "primNatModSucAux" verifyModSucAux) - , (builtinNatEquals |-> BuiltinPrim "primNatEquality" verifyEquals) - , (builtinNatLess |-> BuiltinPrim "primNatLess" verifyLess) - , (builtinLevelZero |-> BuiltinPrim "primLevelZero" (const $ return ())) - , (builtinLevelSuc |-> BuiltinPrim "primLevelSuc" (const $ return ())) - , (builtinLevelMax |-> BuiltinPrim "primLevelMax" verifyMax) - , (builtinSetOmega |-> BuiltinPrim "primSetOmega" (const $ return ())) - , (builtinAgdaClause |-> BuiltinData tset [builtinAgdaClauseClause, builtinAgdaClauseAbsurd]) - , (builtinAgdaClauseClause |-> BuiltinDataCons (tlist (targ tpat) --> tterm --> tclause)) - , (builtinAgdaClauseAbsurd |-> BuiltinDataCons (tlist (targ tpat) --> tclause)) - , (builtinAgdaDefinition |-> BuiltinData tset [builtinAgdaDefinitionFunDef - ,builtinAgdaDefinitionDataDef - ,builtinAgdaDefinitionDataConstructor - ,builtinAgdaDefinitionRecordDef - ,builtinAgdaDefinitionPostulate - ,builtinAgdaDefinitionPrimitive]) - , (builtinAgdaDefinitionFunDef |-> BuiltinDataCons (tlist tclause --> tdefn)) - , (builtinAgdaDefinitionDataDef |-> BuiltinDataCons (tnat --> tlist tqname --> tdefn)) - , (builtinAgdaDefinitionDataConstructor |-> BuiltinDataCons (tqname --> tdefn)) - , (builtinAgdaDefinitionRecordDef |-> BuiltinDataCons (tqname --> tlist (targ tqname) --> tdefn)) - , (builtinAgdaDefinitionPostulate |-> BuiltinDataCons tdefn) - , (builtinAgdaDefinitionPrimitive |-> BuiltinDataCons tdefn) - , builtinAgdaTCM |-> builtinPostulate (hPi "a" tlevel $ tsetL 0 --> tsetL 0) - , builtinAgdaTCMReturn |-> builtinPostulate (hPi "a" tlevel $ - hPi "A" (tsetL 0) $ - elV 1 (varM 0) --> tTCM 1 (varM 0)) - , builtinAgdaTCMBind |-> builtinPostulate (hPi "a" tlevel $ hPi "b" tlevel $ - hPi "A" (tsetL 1) $ hPi "B" (tsetL 1) $ - tTCM 3 (varM 1) --> (elV 3 (varM 1) --> tTCM 2 (varM 0)) --> tTCM 2 (varM 0)) - , builtinAgdaTCMUnify |-> builtinPostulate (tterm --> tterm --> tTCM_ primUnit) - , builtinAgdaTCMTypeError |-> builtinPostulate (hPi "a" tlevel $ hPi "A" (tsetL 0) $ tlist terrorpart --> tTCM 1 (varM 0)) - , builtinAgdaTCMInferType |-> builtinPostulate (tterm --> tTCM_ primAgdaTerm) - , builtinAgdaTCMCheckType |-> builtinPostulate (tterm --> ttype --> tTCM_ primAgdaTerm) - , builtinAgdaTCMNormalise |-> builtinPostulate (tterm --> tTCM_ primAgdaTerm) - , builtinAgdaTCMReduce |-> builtinPostulate (tterm --> tTCM_ primAgdaTerm) - , builtinAgdaTCMCatchError |-> builtinPostulate (hPi "a" tlevel $ hPi "A" (tsetL 0) $ tTCM 1 (varM 0) --> tTCM 1 (varM 0) --> tTCM 1 (varM 0)) - , builtinAgdaTCMGetContext |-> builtinPostulate (tTCM_ (unEl <$> tlist (targ ttype))) - , builtinAgdaTCMExtendContext |-> builtinPostulate (hPi "a" tlevel $ hPi "A" (tsetL 0) $ targ ttype --> tTCM 1 (varM 0) --> tTCM 1 (varM 0)) - , builtinAgdaTCMInContext |-> builtinPostulate (hPi "a" tlevel $ hPi "A" (tsetL 0) $ tlist (targ ttype) --> tTCM 1 (varM 0) --> tTCM 1 (varM 0)) - , builtinAgdaTCMFreshName |-> builtinPostulate (tstring --> tTCM_ primQName) - , builtinAgdaTCMDeclareDef |-> builtinPostulate (targ tqname --> ttype --> tTCM_ primUnit) - , builtinAgdaTCMDeclarePostulate |-> builtinPostulate (targ tqname --> ttype --> tTCM_ primUnit) - , builtinAgdaTCMDefineFun |-> builtinPostulate (tqname --> tlist tclause --> tTCM_ primUnit) - , builtinAgdaTCMGetType |-> builtinPostulate (tqname --> tTCM_ primAgdaTerm) - , builtinAgdaTCMGetDefinition |-> builtinPostulate (tqname --> tTCM_ primAgdaDefinition) - , builtinAgdaTCMQuoteTerm |-> builtinPostulate (hPi "a" tlevel $ hPi "A" (tsetL 0) $ elV 1 (varM 0) --> tTCM_ primAgdaTerm) - , builtinAgdaTCMUnquoteTerm |-> builtinPostulate (hPi "a" tlevel $ hPi "A" (tsetL 0) $ tterm --> tTCM 1 (varM 0)) - , builtinAgdaTCMBlockOnMeta |-> builtinPostulate (hPi "a" tlevel $ hPi "A" (tsetL 0) $ tmeta --> tTCM 1 (varM 0)) - , builtinAgdaTCMCommit |-> builtinPostulate (tTCM_ primUnit) - , builtinAgdaTCMIsMacro |-> builtinPostulate (tqname --> tTCM_ primBool) - , builtinAgdaTCMWithNormalisation |-> builtinPostulate (hPi "a" tlevel $ hPi "A" (tsetL 0) $ tbool --> tTCM 1 (varM 0) --> tTCM 1 (varM 0)) - , builtinAgdaTCMDebugPrint |-> builtinPostulate (tstring --> tnat --> tlist terrorpart --> tTCM_ primUnit) - , builtinAgdaTCMNoConstraints |-> builtinPostulate (hPi "a" tlevel $ hPi "A" (tsetL 0) $ tTCM 1 (varM 0) --> tTCM 1 (varM 0)) - , builtinAgdaTCMRunSpeculative |-> builtinPostulate (hPi "a" tlevel $ hPi "A" (tsetL 0) $ - tTCM 1 (primSigma <#> varM 1 <#> primLevelZero <@> varM 0 <@> (Lam defaultArgInfo . Abs "_" <$> primBool)) --> tTCM 1 (varM 0)) + , (builtinAgdaSortSet |-> BuiltinDataCons (tterm --> tsort)) + , (builtinAgdaSortLit |-> BuiltinDataCons (tnat --> tsort)) + , (builtinAgdaSortUnsupported |-> BuiltinDataCons tsort) + , (builtinNatPlus |-> BuiltinPrim "primNatPlus" verifyPlus) + , (builtinNatMinus |-> BuiltinPrim "primNatMinus" verifyMinus) + , (builtinNatTimes |-> BuiltinPrim "primNatTimes" verifyTimes) + , (builtinNatDivSucAux |-> BuiltinPrim "primNatDivSucAux" verifyDivSucAux) + , (builtinNatModSucAux |-> BuiltinPrim "primNatModSucAux" verifyModSucAux) + , (builtinNatEquals |-> BuiltinPrim "primNatEquality" verifyEquals) + , (builtinNatLess |-> BuiltinPrim "primNatLess" verifyLess) + , (builtinLevelZero |-> BuiltinPrim "primLevelZero" (const $ return ())) + , (builtinLevelSuc |-> BuiltinPrim "primLevelSuc" (const $ return ())) + , (builtinLevelMax |-> BuiltinPrim "primLevelMax" verifyMax) + , (builtinSetOmega |-> BuiltinPrim "primSetOmega" (const $ return ())) + , (builtinAgdaClause |-> BuiltinData tset [builtinAgdaClauseClause, builtinAgdaClauseAbsurd]) + , (builtinAgdaClauseClause |-> BuiltinDataCons (tlist (targ tpat) --> tterm --> tclause)) + , (builtinAgdaClauseAbsurd |-> BuiltinDataCons (tlist (targ tpat) --> tclause)) + , (builtinAgdaDefinition |-> BuiltinData tset [builtinAgdaDefinitionFunDef + ,builtinAgdaDefinitionDataDef + ,builtinAgdaDefinitionDataConstructor + ,builtinAgdaDefinitionRecordDef + ,builtinAgdaDefinitionPostulate + ,builtinAgdaDefinitionPrimitive]) + , (builtinAgdaDefinitionFunDef |-> BuiltinDataCons (tlist tclause --> tdefn)) + , (builtinAgdaDefinitionDataDef |-> BuiltinDataCons (tnat --> tlist tqname --> tdefn)) + , (builtinAgdaDefinitionDataConstructor |-> BuiltinDataCons (tqname --> tdefn)) + , (builtinAgdaDefinitionRecordDef |-> BuiltinDataCons (tqname --> tlist (targ tqname) --> tdefn)) + , (builtinAgdaDefinitionPostulate |-> BuiltinDataCons tdefn) + , (builtinAgdaDefinitionPrimitive |-> BuiltinDataCons tdefn) + , builtinAgdaTCM |-> builtinPostulate (hPi "a" tlevel $ tsetL 0 --> tsetL 0) + , builtinAgdaTCMReturn |-> builtinPostulate (hPi "a" tlevel $ + hPi "A" (tsetL 0) $ + elV 1 (varM 0) --> tTCM 1 (varM 0)) + , builtinAgdaTCMBind |-> builtinPostulate (hPi "a" tlevel $ hPi "b" tlevel $ + hPi "A" (tsetL 1) $ hPi "B" (tsetL 1) $ + tTCM 3 (varM 1) --> (elV 3 (varM 1) --> tTCM 2 (varM 0)) --> tTCM 2 (varM 0)) + , builtinAgdaTCMUnify |-> builtinPostulate (tterm --> tterm --> tTCM_ primUnit) + , builtinAgdaTCMTypeError |-> builtinPostulate (hPi "a" tlevel $ hPi "A" (tsetL 0) $ tlist terrorpart --> tTCM 1 (varM 0)) + , builtinAgdaTCMInferType |-> builtinPostulate (tterm --> tTCM_ primAgdaTerm) + , builtinAgdaTCMCheckType |-> builtinPostulate (tterm --> ttype --> tTCM_ primAgdaTerm) + , builtinAgdaTCMNormalise |-> builtinPostulate (tterm --> tTCM_ primAgdaTerm) + , builtinAgdaTCMReduce |-> builtinPostulate (tterm --> tTCM_ primAgdaTerm) + , builtinAgdaTCMCatchError |-> builtinPostulate (hPi "a" tlevel $ hPi "A" (tsetL 0) $ + tTCM 1 (varM 0) --> tTCM 1 (varM 0) --> tTCM 1 (varM 0)) + , builtinAgdaTCMGetContext |-> builtinPostulate (tTCM_ (unEl <$> tlist (targ ttype))) + , builtinAgdaTCMExtendContext |-> builtinPostulate (hPi "a" tlevel $ hPi "A" (tsetL 0) $ + targ ttype --> tTCM 1 (varM 0) --> tTCM 1 (varM 0)) + , builtinAgdaTCMInContext |-> builtinPostulate (hPi "a" tlevel $ hPi "A" (tsetL 0) $ + tlist (targ ttype) --> tTCM 1 (varM 0) --> tTCM 1 (varM 0)) + , builtinAgdaTCMFreshName |-> builtinPostulate (tstring --> tTCM_ primQName) + , builtinAgdaTCMDeclareDef |-> builtinPostulate (targ tqname --> ttype --> tTCM_ primUnit) + , builtinAgdaTCMDeclarePostulate |-> builtinPostulate (targ tqname --> ttype --> tTCM_ primUnit) + , builtinAgdaTCMDefineFun |-> builtinPostulate (tqname --> tlist tclause --> tTCM_ primUnit) + , builtinAgdaTCMGetType |-> builtinPostulate (tqname --> tTCM_ primAgdaTerm) + , builtinAgdaTCMGetDefinition |-> builtinPostulate (tqname --> tTCM_ primAgdaDefinition) + , builtinAgdaTCMQuoteTerm |-> builtinPostulate (hPi "a" tlevel $ hPi "A" (tsetL 0) $ elV 1 (varM 0) --> tTCM_ primAgdaTerm) + , builtinAgdaTCMUnquoteTerm |-> builtinPostulate (hPi "a" tlevel $ hPi "A" (tsetL 0) $ tterm --> tTCM 1 (varM 0)) + , builtinAgdaTCMBlockOnMeta |-> builtinPostulate (hPi "a" tlevel $ hPi "A" (tsetL 0) $ tmeta --> tTCM 1 (varM 0)) + , builtinAgdaTCMCommit |-> builtinPostulate (tTCM_ primUnit) + , builtinAgdaTCMIsMacro |-> builtinPostulate (tqname --> tTCM_ primBool) + , builtinAgdaTCMWithNormalisation |-> builtinPostulate (hPi "a" tlevel $ hPi "A" (tsetL 0) $ tbool --> tTCM 1 (varM 0) --> tTCM 1 (varM 0)) + , builtinAgdaTCMDebugPrint |-> builtinPostulate (tstring --> tnat --> tlist terrorpart --> tTCM_ primUnit) + , builtinAgdaTCMNoConstraints |-> builtinPostulate (hPi "a" tlevel $ hPi "A" (tsetL 0) $ tTCM 1 (varM 0) --> tTCM 1 (varM 0)) + , builtinAgdaTCMRunSpeculative |-> builtinPostulate (hPi "a" tlevel $ hPi "A" (tsetL 0) $ + tTCM 1 (primSigma <#> varM 1 <#> primLevelZero <@> varM 0 <@> + (Lam defaultArgInfo . Abs "_" <$> primBool)) --> + tTCM 1 (varM 0)) ] where (|->) = BuiltinInfo @@ -382,9 +395,7 @@ tterm = el primAgdaTerm terrorpart = el primAgdaErrorPart tnat = el primNat - tint = el primInteger tword64 = el primWord64 - tunit = el primUnit tinteger = el primInteger tfloat = el primFloat tchar = el primChar @@ -542,7 +553,7 @@ def <- getConstInfo q let yes = return (q, def) case theDef def of - Datatype { dataInduction = Inductive, dataCons = cs } + Datatype { dataCons = cs } | length cs == n -> yes | otherwise -> no Record { recInduction = ind } | n == 1 && ind /= Just CoInductive -> yes @@ -587,8 +598,8 @@ bindAndSetHaskellCode :: String -> String -> Term -> TCM () bindAndSetHaskellCode b hs t = do d <- fromMaybe __IMPOSSIBLE__ <$> getDef t - addHaskellPragma d hs bindBuiltinName b t + addHaskellPragma d hs bindBuiltinBool :: Term -> TCM () bindBuiltinBool = bindAndSetHaskellCode builtinBool "= type Bool" @@ -656,7 +667,7 @@ -- | Bind BUILTIN EQUALITY and BUILTIN REFL. bindBuiltinEquality :: ResolvedName -> TCM () bindBuiltinEquality x = do - (v, _t) <- inferExpr (A.nameExpr x) + (v, _t) <- inferExpr (A.nameToExpr x) -- Equality needs to be a data type with 1 constructor (eq, def) <- inductiveCheck builtinEquality 1 v @@ -778,6 +789,7 @@ Axiom {} -> do builtinSizeHook s q t' -- And compilation pragmas for base types + when (s == builtinLevel) $ addHaskellPragma q "= type ()" when (s == builtinChar) $ addHaskellPragma q "= type Char" when (s == builtinString) $ addHaskellPragma q "= type Data.Text.Text" when (s == builtinFloat) $ addHaskellPragma q "= type Double" @@ -810,7 +822,7 @@ -- Get the non-empty list of AbstractName for x xs <- case x of VarName{} -> failure - DefinedName _ x -> return $ x :! [] + DefinedName _ x -> return $ x :| [] FieldName xs -> return xs ConstructorName xs -> return xs PatternSynResName xs -> failure @@ -830,7 +842,7 @@ | b == builtinSharp -> bindBuiltinSharp x | b == builtinFlat -> bindBuiltinFlat x | b == builtinEquality -> bindBuiltinEquality x - | Just i <- findBuiltinInfo b -> bindBuiltinInfo i (A.nameExpr x) + | Just i <- findBuiltinInfo b -> bindBuiltinInfo i (A.nameToExpr x) | otherwise -> typeError $ NoSuchBuiltinName b where now new b = warning $ OldBuiltin b new @@ -841,7 +853,7 @@ bindUntypedBuiltin :: String -> ResolvedName -> TCM () bindUntypedBuiltin b = \case DefinedName _ x -> bindBuiltinName b (Def (anameName x) []) - FieldName (x :! []) -> bindBuiltinName b (Def (anameName x) []) + FieldName (x :| []) -> bindBuiltinName b (Def (anameName x) []) _ -> genericError $ "The argument to BUILTIN " ++ b ++ " must be a defined unambiguous name" -- | Bind a builtin thing to a new name. @@ -854,6 +866,7 @@ when (b `elem` sizeBuiltins) $ unlessM sizedTypesOption $ genericError $ "Cannot declare size BUILTIN " ++ b ++ " with option --no-sized-types" case builtinDesc <$> findBuiltinInfo b of + Just (BuiltinPostulate rel mt) -> do -- We start by adding the corresponding postulate t <- mt @@ -873,6 +886,7 @@ , funTerminates = Just True } | otherwise = Axiom + Just (BuiltinPrim name axioms) -> do PrimImpl t pf <- lookupPrimitiveFunction name bindPrimitive name $ pf { primFunName = q } @@ -886,16 +900,28 @@ addConstant q $ defaultDefn defaultArgInfo q t def axioms v bindBuiltinName b v + Just (BuiltinDataCons mt) -> do t <- mt d <- return $! getPrimName $ unEl t let ch = ConHead q Inductive [] - def = Constructor 0 0 ch d ConcreteDef Inductive (emptyCompKit, Nothing) [] [] -- Andrea TODO: fix zeros - + def = Constructor + { conPars = 0 -- Andrea TODO: fix zeros + , conArity = 0 + , conSrcCon = ch + , conData = d + , conAbstr = ConcreteDef + , conInd = Inductive + , conComp = emptyCompKit + , conProj = Nothing + , conForced = [] + , conErased = Nothing + } addConstant q $ defaultDefn defaultArgInfo q t def addDataCons d [q] bindBuiltinName b $ Con ch ConOSystem [] + Just (BuiltinData mt cs) -> do t <- mt addConstant q $ defaultDefn defaultArgInfo q t def @@ -904,7 +930,6 @@ def = Datatype { dataPars = 0 , dataIxs = 0 - , dataInduction = Inductive , dataClause = Nothing , dataCons = [] -- Constructors are added later , dataSort = Inf @@ -912,18 +937,17 @@ , dataMutual = Nothing , dataPathCons = [] } + Just{} -> __IMPOSSIBLE__ Nothing -> __IMPOSSIBLE__ -- typeError $ NoSuchBuiltinName b -builtinKindOfName :: String -> TCM (Maybe KindOfName) -builtinKindOfName b = - case find ((b ==) . builtinName) coreBuiltins of - Nothing -> return Nothing - Just d -> return . Just $ - case builtinDesc d of - BuiltinDataCons{} -> ConName - BuiltinData{} -> DefName - BuiltinPrim{} -> DefName - BuiltinPostulate{} -> DefName - BuiltinUnknown{} -> DefName +builtinKindOfName :: String -> Maybe KindOfName +builtinKindOfName b = distinguish <$> find ((b ==) . builtinName) coreBuiltins + where + distinguish d = case builtinDesc d of + BuiltinDataCons{} -> ConName + BuiltinData{} -> DataName + BuiltinPrim{} -> PrimName + BuiltinPostulate{} -> AxiomName + BuiltinUnknown{} -> OtherDefName diff --git a/src/full/Agda/TypeChecking/Rules/Builtin/Coinduction.hs b/src/full/Agda/TypeChecking/Rules/Builtin/Coinduction.hs --- a/src/full/Agda/TypeChecking/Rules/Builtin/Coinduction.hs +++ b/src/full/Agda/TypeChecking/Rules/Builtin/Coinduction.hs @@ -1,4 +1,3 @@ --- {-# LANGUAGE CPP #-} ------------------------------------------------------------------------ -- | Handling of the INFINITY, SHARP and FLAT builtins. @@ -6,9 +5,6 @@ module Agda.TypeChecking.Rules.Builtin.Coinduction where -import qualified Data.Map as Map -import qualified Data.Set as Set - import qualified Agda.Syntax.Abstract as A import Agda.Syntax.Common import Agda.Syntax.Internal @@ -27,8 +23,6 @@ import Agda.TypeChecking.Rules.Builtin import Agda.TypeChecking.Rules.Term -import Agda.Utils.Permutation - -- | The type of @∞@. typeOfInf :: TCM Type @@ -99,9 +93,10 @@ , conData = defName infDefn , conAbstr = ConcreteDef , conInd = CoInductive - , conComp = (emptyCompKit, Nothing) + , conComp = emptyCompKit + , conProj = Nothing , conForced = [] - , conErased = [] + , conErased = Nothing } } return sharpE @@ -139,7 +134,9 @@ , clauseBody = Just $ var 0 , clauseType = Just $ defaultArg $ El (varSort 2) $ var 1 , clauseCatchall = False + , clauseRecursive = Just False , clauseUnreachable = Just False + , clauseEllipsis = NoEllipsis } cc = Case (defaultArg 0) $ conCase sharp False $ WithArity 1 $ Done [defaultArg "x"] $ var 0 projection = Projection @@ -152,13 +149,13 @@ addConstant flat $ flatDefn { defPolarity = [] , defArgOccurrences = [StrictPos] -- changing that to [Mixed] destroys monotonicity of 'Rec' in test/succeed/GuardednessPreservingTypeConstructors + , defCopatternLHS = hasProjectionPatterns cc , theDef = emptyFunction { funClauses = [clause] , funCompiled = Just $ cc , funProjection = Just projection , funMutual = Just [] , funTerminates = Just True - , funCopatternLHS = hasProjectionPatterns cc } } @@ -166,7 +163,7 @@ modifySignature $ updateDefinition sharp $ updateTheDef $ \ def -> def { conSrcCon = sharpCon } modifySignature $ updateDefinition inf $ updateTheDef $ \ def -> - def { recConHead = sharpCon, recFields = [defaultArg flat] } + def { recConHead = sharpCon, recFields = [defaultDom flat] } return flatE -- The coinductive primitives. diff --git a/src/full/Agda/TypeChecking/Rules/Data.hs b/src/full/Agda/TypeChecking/Rules/Data.hs --- a/src/full/Agda/TypeChecking/Rules/Data.hs +++ b/src/full/Agda/TypeChecking/Rules/Data.hs @@ -1,15 +1,15 @@ -{-# LANGUAGE CPP #-} -{-# LANGUAGE MultiWayIf #-} {-# LANGUAGE NondecreasingIndentation #-} module Agda.TypeChecking.Rules.Data where +import Prelude hiding (null) + import Control.Monad +import Control.Monad.Trans +import Control.Monad.Trans.Maybe -import Data.List (genericTake) +import Data.Foldable (traverse_) import Data.Maybe (fromMaybe, catMaybes, isJust) -import Control.Monad.Trans.Maybe -import Control.Monad.Trans import Data.Set (Set) import qualified Data.Set as Set @@ -26,7 +26,6 @@ import {-# SOURCE #-} Agda.TypeChecking.CompiledClause.Compile import Agda.TypeChecking.Monad import Agda.TypeChecking.Monad.Builtin -- (primLevel) -import Agda.TypeChecking.Constraints import Agda.TypeChecking.Conversion import Agda.TypeChecking.Substitute import Agda.TypeChecking.Generalize @@ -34,26 +33,24 @@ import Agda.TypeChecking.MetaVars import Agda.TypeChecking.Names import Agda.TypeChecking.Reduce +import Agda.TypeChecking.Positivity.Occurrence (Occurrence(StrictPos)) import Agda.TypeChecking.Pretty import Agda.TypeChecking.Primitive hiding (Nat) import Agda.TypeChecking.Free import Agda.TypeChecking.Forcing import Agda.TypeChecking.Irrelevance import Agda.TypeChecking.Telescope -import Agda.TypeChecking.ProjectionLike import {-# SOURCE #-} Agda.TypeChecking.Rules.Term ( isType_ ) -import Agda.Interaction.Options - import Agda.Utils.Except import Agda.Utils.List import Agda.Utils.Maybe import Agda.Utils.Monad +import Agda.Utils.Null import qualified Agda.Utils.Pretty as P import Agda.Utils.Size -#include "undefined.h" import Agda.Utils.Impossible --------------------------------------------------------------------------- @@ -62,7 +59,7 @@ -- | Type check a datatype definition. Assumes that the type has already been -- checked. -checkDataDef :: Info.DefInfo -> QName -> UniverseCheck -> A.DataDefParams -> [A.Constructor] -> TCM () +checkDataDef :: A.DefInfo -> QName -> UniverseCheck -> A.DataDefParams -> [A.Constructor] -> TCM () checkDataDef i name uc (A.DataDefParams gpars ps) cs = traceCall (CheckDataDef (getRange name) name ps cs) $ do @@ -124,7 +121,10 @@ let s' = case s of Prop l -> Type l _ -> s - whenM withoutKOption $ checkIndexSorts s' ixTel + -- Andreas, 2019-07-16, issue #3916: + -- NoUniverseCheck should also disable the index sort check! + unless (uc == NoUniverseCheck) $ + whenM withoutKOption $ checkIndexSorts s' ixTel reportSDoc "tc.data.sort" 20 $ vcat [ "checking datatype" <+> prettyTCM name @@ -143,7 +143,6 @@ let dataDef = Datatype { dataPars = npars , dataIxs = nofIxs - , dataInduction = Inductive , dataClause = Nothing , dataCons = [] -- Constructors are added later , dataSort = s @@ -152,7 +151,7 @@ , dataPathCons = [] -- Path constructors are added later } - escapeContext npars $ do + escapeContext __IMPOSSIBLE__ npars $ do addConstant name $ defaultDefn defaultArgInfo name t dataDef -- polarity and argOcc.s determined by the positivity checker @@ -213,10 +212,16 @@ Relevant -> return () Irrelevant -> typeError $ GenericError $ "Irrelevant constructors are not supported" NonStrict -> typeError $ GenericError $ "Shape-irrelevant constructors are not supported" + case getQuantity ai of + Quantityω{} -> return () + Quantity0{} -> typeError $ GenericError $ "Erased constructors are not supported" + Quantity1{} -> typeError $ GenericError $ "Quantity-restricted constructors are not supported" -- check that the type of the constructor is well-formed (t, isPathCons) <- checkConstructorType e d - -- compute which constructor arguments are forced - forcedArgs <- computeForcingAnnotations c t + -- compute which constructor arguments are forced (only point constructors) + forcedArgs <- if isPathCons == PointCons + then computeForcingAnnotations c t + else return [] -- check that the sort (universe level) of the constructor type -- is contained in the sort of the data type -- (to avoid impredicative existential types) @@ -237,29 +242,34 @@ -- of the datatype in an empty context (c.f. getContextSize above). params <- getContextTelescope - -- add parameters to constructor type and put into signature - let con = ConHead c Inductive [] -- data constructors have no projectable fields and are always inductive - escapeContext (size tel) $ do + -- Cannot compose indexed inductive types yet. + (con, comp, projNames) <- if nofIxs /= 0 || (Info.defAbstract i == AbstractDef) + then return (ConHead c Inductive [], emptyCompKit, Nothing) + else do + -- Name for projection of ith field of constructor c is just c-i + names <- forM [0 .. size fields - 1] $ \ i -> + freshAbstractQName'_ $ P.prettyShow (A.qnameName c) ++ "-" ++ show i - cnames <- if nofIxs /= 0 || (Info.defAbstract i == AbstractDef) then return (emptyCompKit, Nothing) else do - inTopContext $ do - names <- forM [0 .. size fields - 1] (\ i -> freshAbstractQName'_ (P.prettyShow (A.qnameName c) ++ "-" ++ show i)) + -- nofIxs == 0 means the data type can be reconstructed + -- by appling the QName d to the parameters. + let dataT = El s $ Def d $ map Apply $ teleArgs params - -- nofIxs == 0 means the data type can be reconstructed - -- by appling the QName d to the parameters. - dataT <- El s <$> (pure $ Def d $ map Apply $ teleArgs params) + reportSDoc "tc.data.con.comp" 5 $ inTopContext $ vcat $ + [ "params =" <+> pretty params + , "dataT =" <+> pretty dataT + , "fields =" <+> pretty fields + , "names =" <+> pretty names + ] - reportSDoc "tc.data.con.comp" 5 $ vcat $ - [ "params =" <+> pretty params - , "dataT =" <+> pretty dataT - , "fields =" <+> pretty fields - , "names =" <+> pretty names - ] + let con = ConHead c Inductive $ zipWith (<$) names $ map argFromDom $ telToList fields - defineProjections d con params names fields dataT - comp <- defineCompData d con params names fields dataT boundary - return $ (comp, Just names) + defineProjections d con params names fields dataT + comp <- inTopContext $ defineCompData d con params names fields dataT boundary + return (con, comp, Just names) + -- add parameters to constructor type and put into signature + escapeContext __IMPOSSIBLE__ (size tel) $ do + addConstant c $ defaultDefn defaultArgInfo c (telePi tel t) $ Constructor { conPars = size tel @@ -268,18 +278,23 @@ , conData = d , conAbstr = Info.defAbstract i , conInd = Inductive - , conComp = cnames + , conComp = comp + , conProj = projNames , conForced = forcedArgs - , conErased = [] -- computed during compilation to treeless + , conErased = Nothing -- computed during compilation to treeless } - case snd cnames of - Nothing -> return () - Just names -> mapM_ makeProjection names - -- Add the constructor to the instance table, if needed - when (Info.defInstance i == InstanceDef) $ do - addNamedInstance c d + case Info.defInstance i of + InstanceDef _r -> setCurrentRange c $ do + -- Including the range of the @instance@ keyword, like + -- @(getRange (r,c))@, does not produce good results. + -- Andreas, 2020-01-28, issue #4360: + -- Use addTypedInstance instead of addNamedInstance + -- to detect unusable instances. + addTypedInstance c t + -- addNamedInstance c d + NotInstanceDef -> pure () return isPathCons @@ -355,8 +370,8 @@ -- Δ^I, i : I |- sub Δ : Δ sub tel = parallelS [ var n `apply` [Arg defaultArgInfo $ var 0] | n <- [1..size tel] ] withArgInfo tel = zipWith Arg (map domInfo . telToList $ tel) - defineTranspOrHCompD cmd d con params names fsT t boundary - = do + + defineTranspOrHCompD cmd d con params names fsT t boundary = do let project = (\ t p -> apply (Def p []) [argN t]) stuff <- defineTranspOrHCompForFields cmd (guard (not $ null boundary) >> (Just $ Con con ConOSystem $ teleElims fsT boundary)) @@ -495,7 +510,7 @@ -- Δ.Φ ⊢ u = Con con ConOSystem $ teleElims fsT boundary : R δ -- u = Con con ConOSystem $ teleElims fsT boundary - up = ConP con (ConPatternInfo Nothing False Nothing False) $ + up = ConP con (ConPatternInfo defaultPatternInfo False False Nothing False) $ telePatterns (d0 `applySubst` fsT) (liftS (size fsT) d0 `applySubst` boundary) -- gamma' = telFromList $ take (size gamma - 1) $ telToList gamma @@ -506,32 +521,25 @@ -- (tel',theta) = (abstract gamma' (d0 `applySubst` fsT), (liftS (size fsT) d0 `applySubst` u) `consS` raiseS (size fsT)) let - clause | null boundary - = Clause - { clauseTel = gamma - , clauseType = Just . argN $ ty - , namedClausePats = teleNamedArgs gamma - , clauseFullRange = noRange - , clauseLHSRange = noRange - , clauseCatchall = False - , clauseBody = Just $ body - , clauseUnreachable = Just False - } - - | otherwise - = Clause - { clauseTel = gamma - , clauseType = Just . argN $ ty - , namedClausePats = take (size gamma - size fsT) (teleNamedArgs gamma) ++ [argN $ unnamed $ up] - , clauseFullRange = noRange - , clauseLHSRange = noRange - , clauseCatchall = False - , clauseBody = Just $ body - , clauseUnreachable = Just False - } + pats | null boundary = teleNamedArgs gamma + | otherwise = take (size gamma - size fsT) (teleNamedArgs gamma) ++ [argN $ unnamed $ up] + clause = Clause + { clauseTel = gamma + , clauseType = Just . argN $ ty + , namedClausePats = pats + , clauseFullRange = noRange + , clauseLHSRange = noRange + , clauseCatchall = False + , clauseBody = Just $ body + , clauseRecursive = Nothing + -- Andreas 2020-02-06 TODO + -- Or: Just False; is it known to be non-recursive? + , clauseUnreachable = Just False + , clauseEllipsis = NoEllipsis + } cs = [clause] addClauses theName cs - (mst, cc) <- inTopContext (compileClauses Nothing cs) + (mst, _, cc) <- inTopContext (compileClauses Nothing cs) whenJust mst $ setSplitTree theName setCompiledClauses theName cc setTerminates theName True @@ -543,6 +551,10 @@ if all isJust xs then m else return Nothing -- Andrea: TODO handle Irrelevant fields somehow. +-- | Define projections for non-indexed data types (families don't work yet). +-- Of course, these projections are partial functions in general. +-- +-- Precondition: we are in the context Γ of the data type parameters. defineProjections :: QName -- datatype name -> ConHead -> Telescope -- Γ parameters @@ -550,51 +562,66 @@ -> Telescope -- Γ ⊢ Φ field types -> Type -- Γ ⊢ T target type -> TCM () -defineProjections dataname con params names fsT t = do +defineProjections dataName con params names fsT t = do let -- Γ , (d : T) ⊢ Φ[n ↦ proj n d] fieldTypes = ([ Def f [] `apply` [argN $ var 0] | f <- reverse names ] ++# raiseS 1) `applySubst` flattenTel fsT -- Γ , Φ ⊢ Φ -- ⊢ Γ , (d : T) - projTel = abstract params (ExtendTel (defaultDom t) (Abs "d" EmptyTel)) + projTel = abstract params (ExtendTel (defaultDom t) (Abs "d" EmptyTel)) + np = size params + forM_ (zip3 (downFrom (size fieldTypes)) names fieldTypes) $ \ (i,projName,ty) -> do let projType = abstract projTel <$> ty - - inTopContext $ do - reportSDoc "tc.data.proj" 20 $ sep [ "proj" <+> prettyTCM (i,ty) , nest 2 $ prettyTCM projType ] - - let - cpi = ConPatternInfo Nothing False (Just $ argN $ raise (size fsT) t) False - conp = defaultArg $ ConP con cpi $ teleNamedArgs fsT - clause = Clause - { clauseTel = abstract params fsT - , clauseType = Just . argN $ ([Con con ConOSystem (map Apply $ teleArgs fsT)] ++# raiseS (size fsT)) `applySubst` unDom ty - , namedClausePats = raise (size fsT) (teleNamedArgs params) ++ [Named Nothing <$> conp] - , clauseFullRange = noRange - , clauseLHSRange = noRange - , clauseCatchall = False - , clauseBody = Just $ var i + cpi = ConPatternInfo defaultPatternInfo False False (Just $ argN $ raise (size fsT) t) False + conp = defaultNamedArg $ ConP con cpi $ teleNamedArgs fsT + sigma = Con con ConOSystem (map Apply $ teleArgs fsT) `consS` raiseS (size fsT) + clause = empty + { clauseTel = abstract params fsT + , namedClausePats = [ conp ] + , clauseBody = Just $ var i + , clauseType = Just $ argN $ applySubst sigma $ unDom ty + , clauseRecursive = Just False -- non-recursive , clauseUnreachable = Just False } + reportSDoc "tc.data.proj" 20 $ inTopContext $ sep + [ "proj" <+> prettyTCM (i,ty) + , nest 2 $ sep [ prettyTCM projName, ":", prettyTCM projType ] + ] + + -- Andreas, 2020-02-14, issue #4437 + -- Define data projections as projection-like from the start. noMutualBlock $ do - let cs = [clause] - (mst , cc) <- inTopContext $ compileClauses Nothing cs + let cs = [ clause ] + (mst, _, cc) <- compileClauses Nothing cs let fun = emptyFunction - { funClauses = cs + { funClauses = cs + , funCompiled = Just cc + , funSplitTree = mst + , funProjection = Just $ Projection + { projProper = Nothing + , projOrig = projName + , projFromType = Arg (getArgInfo ty) dataName + , projIndex = np + 1 + , projLams = ProjLams $ map (argFromDom . fmap fst) $ telToList projTel + } + , funMutual = Just [] , funTerminates = Just True - , funCompiled = Just cc - , funSplitTree = mst - , funMutual = Just [] } - addConstant projName $ + inTopContext $ addConstant projName $ (defaultDefn defaultArgInfo projName (unDom projType) fun) - { defNoCompilation = True } - inTopContext $ do - reportSDoc "tc.data.proj.fun" 60 $ sep [ "proj" <+> prettyTCM i, nest 2 $ pretty fun ] + { defNoCompilation = True + , defArgOccurrences = [StrictPos] + } + reportSDoc "tc.data.proj.fun" 60 $ inTopContext $ vcat + [ "proj" <+> prettyTCM i + , nest 2 $ pretty fun + ] + freshAbstractQName'_ :: String -> TCM QName freshAbstractQName'_ s = freshAbstractQName noFixity' (C.Name noRange C.InScope [C.Id $ s]) @@ -1029,7 +1056,7 @@ , text (absName b) <+> text ":" <+> prettyTCM (unDom a) ] _ -> __IMPOSSIBLE__ -bindParameters npars par@(A.DomainFull (A.TBind _ xs e) : bs) a ret = +bindParameters npars par@(A.DomainFull (A.TBind _ _ xs e) : bs) a ret = setCurrentRange par $ typeError . GenericDocError =<< do let s | length xs > 1 = "s" @@ -1038,16 +1065,16 @@ bindParameters _ (A.DomainFull A.TLet{} : _) _ _ = __IMPOSSIBLE__ -bindParameters _ (par@(A.DomainFree arg) : ps) _ _ +bindParameters _ (par@(A.DomainFree _ arg) : ps) _ _ | getModality arg /= defaultModality = setCurrentRange par $ typeError . GenericDocError =<< do text "Unexpected modality/relevance annotation in" <+> prettyA par -bindParameters npars ps0@(par@(A.DomainFree arg) : ps) t ret = do +bindParameters npars ps0@(par@(A.DomainFree _ arg) : ps) t ret = do let x = namedArg arg TelV tel _ = telView' t case insertImplicit arg $ telToList tel of - NoInsertNeeded -> continue ps $ A.unBind x + NoInsertNeeded -> continue ps $ A.unBind $ A.binderName x ImpInsert _ -> continue ps0 =<< freshName_ (absName b) BadImplicits -> setCurrentRange par $ typeError . GenericDocError =<< do @@ -1210,8 +1237,7 @@ Axiom {} -> return (Just False) DataOrRecSig{} -> return Nothing Function {} -> return Nothing - Datatype { dataInduction = CoInductive } -> return (Just True) - Datatype { dataInduction = Inductive } -> return (Just False) + Datatype {} -> return (Just False) Record { recInduction = Just CoInductive } -> return (Just True) Record { recInduction = _ } -> return (Just False) GeneralizableVar{} -> __IMPOSSIBLE__ @@ -1227,4 +1253,4 @@ Sort {} -> return (Just False) MetaV {} -> return Nothing DontCare{} -> __IMPOSSIBLE__ - Dummy s -> __IMPOSSIBLE_VERBOSE__ s + Dummy s _ -> __IMPOSSIBLE_VERBOSE__ s diff --git a/src/full/Agda/TypeChecking/Rules/Decl.hs b/src/full/Agda/TypeChecking/Rules/Decl.hs --- a/src/full/Agda/TypeChecking/Rules/Decl.hs +++ b/src/full/Agda/TypeChecking/Rules/Decl.hs @@ -1,64 +1,49 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE NondecreasingIndentation #-} module Agda.TypeChecking.Rules.Decl where -#if MIN_VERSION_base(4,11,0) -import Prelude hiding ( (<>), null ) -#else import Prelude hiding ( null ) -#endif import Control.Monad -import Control.Monad.Reader -import Control.Monad.State (modify, gets, get) import Control.Monad.Writer (tell) import Data.Either (partitionEithers) import qualified Data.Foldable as Fold import qualified Data.List as List import Data.Maybe -import Data.Map (Map) -import qualified Data.Sequence as Seq import qualified Data.Set as Set import qualified Data.IntSet as IntSet -import qualified Data.Map as Map import Data.Set (Set) -import Agda.Interaction.Options import Agda.Interaction.Highlighting.Generate +import Agda.Interaction.Options import qualified Agda.Syntax.Abstract as A import Agda.Syntax.Abstract.Views (deepUnscopeDecl, deepUnscopeDecls) -import qualified Agda.Syntax.Concrete.Name as C import Agda.Syntax.Internal -import qualified Agda.Syntax.Reflected as R import qualified Agda.Syntax.Info as Info import Agda.Syntax.Position import Agda.Syntax.Common import Agda.Syntax.Literal -import Agda.Syntax.Translation.InternalToAbstract -import Agda.Syntax.Translation.ReflectedToAbstract import Agda.TypeChecking.Monad import Agda.TypeChecking.Monad.Builtin +import Agda.TypeChecking.Monad.Benchmark (MonadBench, Phase) import qualified Agda.TypeChecking.Monad.Benchmark as Bench -import Agda.TypeChecking.CheckInternal import Agda.TypeChecking.Constraints import Agda.TypeChecking.Conversion import Agda.TypeChecking.IApplyConfluence -import Agda.TypeChecking.Errors import Agda.TypeChecking.Generalize import Agda.TypeChecking.Injectivity import Agda.TypeChecking.Irrelevance +import Agda.TypeChecking.Level.Solve import Agda.TypeChecking.Positivity import Agda.TypeChecking.Positivity.Occurrence import Agda.TypeChecking.Polarity import Agda.TypeChecking.Pretty import Agda.TypeChecking.Primitive import Agda.TypeChecking.ProjectionLike -import Agda.TypeChecking.Quote import Agda.TypeChecking.Unquote import Agda.TypeChecking.Records import Agda.TypeChecking.RecordPatterns @@ -67,7 +52,6 @@ import Agda.TypeChecking.SizedTypes.Solve import Agda.TypeChecking.Substitute import Agda.TypeChecking.Telescope -import Agda.TypeChecking.Unquote import Agda.TypeChecking.Warnings import Agda.TypeChecking.Rules.Application @@ -80,18 +64,16 @@ import Agda.Termination.TermCheck -import Agda.Utils.Except import Agda.Utils.Functor -import Agda.Utils.Function -import qualified Agda.Utils.HashMap as HMap import Agda.Utils.Lens import Agda.Utils.Maybe import Agda.Utils.Monad import Agda.Utils.Null import Agda.Utils.Pretty (prettyShow) import Agda.Utils.Size +import Agda.Utils.Update +import qualified Agda.Utils.SmallSet as SmallSet -#include "undefined.h" import Agda.Utils.Impossible -- | Cached checkDecl @@ -136,11 +118,9 @@ compareDecl x y = x == y -- changes to CS inside a RecDef or Mutual ought not happen, -- but they do happen, so we discard them. - ignoreChanges m = do - cs <- getsTC $ stLoadedFileCache . stPersistentState + ignoreChanges m = localCache $ do cleanCachedLog - _ <- m - modifyPersistentState $ \st -> st{stLoadedFileCache = cs} + m checkDeclWrap d@A.RecDef{} = ignoreChanges $ checkDecl d checkDeclWrap d@A.Mutual{} = ignoreChanges $ checkDecl d checkDeclWrap d = checkDecl d @@ -150,8 +130,6 @@ checkDecls ds = do reportSLn "tc.decl" 45 $ "Checking " ++ show (length ds) ++ " declarations..." mapM_ checkDecl ds - -- Andreas, 2011-05-30, unfreezing moved to Interaction/Imports - -- whenM onTopLevel unfreezeMetas -- | Type check a single declaration. @@ -162,10 +140,6 @@ reportSDoc "tc.decl" 90 $ (text . show) (deepUnscopeDecl d) reportSDoc "tc.decl" 10 $ prettyA d -- Might loop, see e.g. Issue 1597 - -- Issue 418 fix: freeze metas before checking an abstract thing - -- when_ isAbstract freezeMetas -- WAS IN PLACE 2012-2016, but too crude - -- applyWhen isAbstract withFreezeMetas $ do -- WRONG - let -- What kind of final checks/computations should be performed -- if we're not inside a mutual block? none m = m $> Nothing -- skip all checks @@ -197,7 +171,7 @@ verboseS "tc.decl.mutual" 70 $ do current <- asksTC envMutualBlock unless (Just blockId == current) $ do - reportSLn "" 0 $ unlines + reportS "" 0 [ "mutual block id discrepancy for " ++ prettyShow x , " current mut. bl. = " ++ show current , " calculated mut. bl. = " ++ show blockId @@ -218,14 +192,22 @@ -- Open and PatternSynDef are just artifacts -- from the concrete syntax, retained for -- highlighting purposes. - A.UnquoteDecl mi i x e -> checkUnquoteDecl mi i x e - A.UnquoteDef i x e -> impossible $ checkUnquoteDef i x e + -- Andreas, 2019-08-19, issue #4010, observe @abstract@ also for unquoting. + -- TODO: is it possible that some of the unquoted declarations/definitions + -- are abstract and some are not? Then allowing all to look into abstract things, + -- as we do here, will leak information about the implementation of abstract things. + -- TODO: Benchmarking for unquote. + A.UnquoteDecl mi is xs e -> checkMaybeAbstractly is $ checkUnquoteDecl mi is xs e + A.UnquoteDef is xs e -> impossible $ checkMaybeAbstractly is $ checkUnquoteDef is xs e whenNothingM (asksTC envMutualBlock) $ do -- Syntax highlighting. highlight_ DontHightlightModuleContents d + -- Defaulting of levels (only when --cumulativity) + whenM (optCumulativity <$> pragmaOptions) $ defaultLevelsToZero metas + -- Post-typing checks. whenJust finalChecks $ \ theMutualChecks -> do reportSLn "tc.decl" 20 $ "Attempting to solve constraints before freezing." @@ -247,18 +229,22 @@ checkSig i x gtel t = checkTypeSignature' (Just gtel) $ A.Axiom A.NoFunSig i defaultArgInfo Nothing x t + -- | Switch maybe to abstract mode, benchmark, and debug print bracket. + check :: forall m i a + . ( MonadTCEnv m, MonadPretty m, MonadDebug m, MonadBench Phase m + , AnyIsAbstract i ) + => QName -> i -> m a -> m a check x i m = Bench.billTo [Bench.Definition x] $ do - reportSDoc "tc.decl" 5 $ "Checking" <+> prettyTCM x <> "." - reportSLn "tc.decl.abstract" 25 $ show (Info.defAbstract i) - r <- abstract (Info.defAbstract i) m - reportSDoc "tc.decl" 5 $ "Checked" <+> prettyTCM x <> "." + reportSDoc "tc.decl" 5 $ ("Checking" <+> prettyTCM x) <> "." + reportSLn "tc.decl.abstract" 25 $ show $ anyIsAbstract i + r <- checkMaybeAbstractly i m + reportSDoc "tc.decl" 5 $ ("Checked" <+> prettyTCM x) <> "." return r - isAbstract = fmap Info.defAbstract (A.getDefInfo d) == Just AbstractDef - - -- Concrete definitions cannot use information about abstract things. - abstract ConcreteDef = inConcreteMode - abstract AbstractDef = inAbstractMode + -- | Switch to AbstractMode if any of the i is AbstractDef. + checkMaybeAbstractly :: forall m i a . ( MonadTCEnv m , AnyIsAbstract i ) + => i -> m a -> m a + checkMaybeAbstractly = localTC . set lensIsAbstract . anyIsAbstract -- Some checks that should be run at the end of a mutual block. The -- set names contains the names defined in the mutual block. @@ -270,11 +256,12 @@ -- Andreas, 2017-03-23: check positivity before termination. -- This allows us to reuse the information about SCCs -- to skip termination of non-recursive functions. - modifyAllowedReductions (List.delete UnconfirmedReductions) $ + modifyAllowedReductions (SmallSet.delete UnconfirmedReductions) $ checkPositivity_ mi names -- Andreas, 2013-02-27: check termination before injectivity, -- to avoid making the injectivity checker loop. - localTC (\ e -> e { envMutualBlock = Just mid }) $ checkTermination_ d + localTC (\ e -> e { envMutualBlock = Just mid }) $ + checkTermination_ d revisitRecordPatternTranslation nameList -- Andreas, 2016-11-19 issue #2308 mapM_ checkIApplyConfluence_ nameList @@ -284,14 +271,21 @@ -- actual problem, and prevents interesting sound applications -- of sized types. -- checkCoinductiveRecords ds - -- Andreas, 2012-09-11: Injectivity check stores clauses - -- whose 'Relevance' is affected by polarity computation, - -- so do it here (again). - -- Andreas, 2015-07-01: In particular, 'UnusedArg's of local functions - -- are only recognized after the polarity computation. - -- See Issue 1366 for an example where injectivity of a local function - -- is used to solve metas. It fails if we do injectivity analysis - -- before polarity only. + + -- Andreas, 2019-07-11: The following remarks about injectivity + -- and polarity seem outdated, since the UnusedArg Relevance has + -- been removed. + -- -- Andreas, 2012-09-11: Injectivity check stores clauses + -- -- whose 'Relevance' is affected by polarity computation, + -- -- so do it here (again). + -- -- Andreas, 2015-07-01: In particular, 'UnusedArg's of local functions + -- -- are only recognized after the polarity computation. + -- -- See Issue 1366 for an example where injectivity of a local function + -- -- is used to solve metas. It fails if we do injectivity analysis + -- -- before polarity only. + -- However, we need to repeat injectivity checking after termination checking, + -- since more reductions are available after termination checking, thus, + -- more instances of injectivity can be recognized. checkInjectivity_ names checkProjectionLikeness_ names @@ -307,9 +301,10 @@ -- qccs: compiled clauses of definitions (rs, qccs) <- partitionEithers . catMaybes <$> mapM classify qs unless (null rs) $ forM_ qccs $ \(q,cc) -> do - cc <- translateCompiledClauses cc - modifySignature $ updateDefinition q $ updateTheDef $ - updateCompiledClauses $ const $ Just cc + (cc, recordExpressionBecameCopatternLHS) <- runChangeT $ translateCompiledClauses cc + modifySignature $ updateDefinition q + $ updateTheDef (updateCompiledClauses $ const $ Just cc) + . updateDefCopatternLHS (|| recordExpressionBecameCopatternLHS) where -- Walk through the definitions and return the set of inferred eta record types -- and the set of function definitions in the mutual block @@ -326,12 +321,12 @@ type FinalChecks = Maybe (TCM ()) -checkUnquoteDecl :: Info.MutualInfo -> [Info.DefInfo] -> [QName] -> A.Expr -> TCM FinalChecks +checkUnquoteDecl :: Info.MutualInfo -> [A.DefInfo] -> [QName] -> A.Expr -> TCM FinalChecks checkUnquoteDecl mi is xs e = do reportSDoc "tc.unquote.decl" 20 $ "Checking unquoteDecl" <+> sep (map prettyTCM xs) Nothing <$ unquoteTop xs e -checkUnquoteDef :: [Info.DefInfo] -> [QName] -> A.Expr -> TCM () +checkUnquoteDef :: [A.DefInfo] -> [QName] -> A.Expr -> TCM () checkUnquoteDef _ xs e = do reportSDoc "tc.unquote.decl" 20 $ "Checking unquoteDef" <+> sep (map prettyTCM xs) () <$ unquoteTop xs e @@ -434,11 +429,9 @@ checkTermination_ :: A.Declaration -> TCM () checkTermination_ d = Bench.billTo [Bench.Termination] $ do reportSLn "tc.decl" 20 $ "checkDecl: checking termination..." - termErrs <- termDecl d - -- If there are some termination errors, we collect them in the - -- state. The termination checker already marked non-terminating - -- functions as such. - unless (null termErrs) $ do + -- If there are some termination errors, we throw a warning. + -- The termination checker already marked non-terminating functions as such. + unlessNullM (termDecl d) $ \ termErrs -> do warning $ TerminationIssue termErrs -- | Check a set of mutual names for positivity. @@ -448,9 +441,8 @@ reportSLn "tc.decl" 20 $ "checkDecl: checking positivity..." checkStrictlyPositive mi names - -- Andreas, 2012-02-13: Polarity computation uses info from - -- positivity check, so it needs happen after positivity - -- check. + -- Andreas, 2012-02-13: Polarity computation uses information from the + -- positivity check, so it needs happen after the positivity check. computePolarity $ Set.toList names -- | Check that all coinductive records are actually recursive. @@ -483,17 +475,23 @@ -- I changed that in Monad.Signature.treatAbstractly', so we can see -- our own local definitions. case theDef def of - d@Function{ funClauses = cs, funTerminates = term } -> do - case term of - Just True -> do + d@Function{ funClauses = cs, funTerminates = term, funProjection = mproj } + | term /= Just True -> do + -- Not terminating, thus, running the injectivity check could get us into a loop. + reportSLn "tc.inj.check" 35 $ + prettyShow q ++ " is not verified as terminating, thus, not considered for injectivity" + | isProperProjection d -> do + reportSLn "tc.inj.check" 40 $ + prettyShow q ++ " is a projection, thus, not considered for injectivity" + | otherwise -> do + inv <- checkInjectivity q cs modifySignature $ updateDefinition q $ updateTheDef $ const $ d { funInv = inv } - _ -> reportSLn "tc.inj.check" 20 $ - prettyShow q ++ " is not verified as terminating, thus, not considered for injectivity" + _ -> do abstr <- asksTC envAbstractMode - reportSLn "tc.inj.check" 20 $ + reportSLn "tc.inj.check" 40 $ "we are in " ++ show abstr ++ " and " ++ prettyShow q ++ " is abstract or not a function, thus, not considered for injectivity" @@ -523,11 +521,13 @@ "mutual definitions are not considered for projection-likeness" -- | Freeze metas created by given computation if in abstract mode. -whenAbstractFreezeMetasAfter :: Info.DefInfo -> TCM a -> TCM a +whenAbstractFreezeMetasAfter :: A.DefInfo -> TCM a -> TCM a whenAbstractFreezeMetasAfter Info.DefInfo{ defAccess, defAbstract} m = do let pubAbs = defAccess == PublicAccess && defAbstract == AbstractDef if not pubAbs then m else do (a, ms) <- metasCreatedBy m + reportSLn "tc.decl" 20 $ "Attempting to solve constraints before freezing." + wakeupConstraints_ -- solve emptiness and instance constraints xs <- freezeMetas' $ (`IntSet.member` ms) . metaId reportSDoc "tc.decl.ax" 20 $ vcat [ "Abstract type signature produced new metas: " <+> sep (map prettyTCM $ IntSet.toList ms) @@ -535,9 +535,14 @@ ] return a -checkGeneralize :: Set QName -> Info.DefInfo -> ArgInfo -> QName -> A.Expr -> TCM () +checkGeneralize :: Set QName -> A.DefInfo -> ArgInfo -> QName -> A.Expr -> TCM () checkGeneralize s i info x e = do + reportSDoc "tc.decl.gen" 20 $ sep + [ "checking type signature of generalizable variable" <+> prettyTCM x <+> ":" + , nest 2 $ prettyTCM e + ] + -- Check the signature and collect the created metas. (telNames, tGen) <- generalizeType s $ locallyTC eGeneralizeMetas (const YesGeneralize) $ @@ -554,25 +559,41 @@ -- | Type check an axiom. -checkAxiom :: A.Axiom -> Info.DefInfo -> ArgInfo -> +checkAxiom :: A.Axiom -> A.DefInfo -> ArgInfo -> Maybe [Occurrence] -> QName -> A.Expr -> TCM () checkAxiom = checkAxiom' Nothing -- | Data and record type signatures need to remember the generalized -- parameters for when checking the corresponding definition, so for these we -- pass in the parameter telescope separately. -checkAxiom' :: Maybe A.GeneralizeTelescope -> A.Axiom -> Info.DefInfo -> ArgInfo -> +checkAxiom' :: Maybe A.GeneralizeTelescope -> A.Axiom -> A.DefInfo -> ArgInfo -> Maybe [Occurrence] -> QName -> A.Expr -> TCM () -checkAxiom' gentel funSig i info0 mp x e = whenAbstractFreezeMetasAfter i $ do +checkAxiom' gentel funSig i info0 mp x e = whenAbstractFreezeMetasAfter i $ defaultOpenLevelsToZero $ do -- Andreas, 2016-07-19 issues #418 #2102: -- We freeze metas in type signatures of abstract definitions, to prevent -- leakage of implementation details. - -- Andreas, 2012-04-18 if we are in irrelevant context, axioms is irrelevant + -- Andreas, 2012-04-18 if we are in irrelevant context, axioms are irrelevant -- even if not declared as such (Issue 610). - rel <- max (getRelevance info0) <$> asksTC envRelevance - let info = setRelevance rel info0 - -- rel <- ifM ((Irrelevant ==) <$> asksTC envRelevance) (return Irrelevant) (return rel0) + -- Andreas, 2019-06-17 also for erasure (issue #3855). + rel <- max (getRelevance info0) <$> asksTC getRelevance + q <- asksTC getQuantity <&> \case + q@Quantity0{} -> q + _ -> getQuantity info0 + + -- Andrea, 2019-07-16 Cohesion is purely based on left-division, it + -- does not take envModality into account. + let c = getCohesion info0 + let mod = Modality rel q c + let info = setModality mod info0 + applyCohesionToContext c $ do + + reportSDoc "tc.decl.ax" 20 $ sep + [ text $ "checking type signature" + , nest 2 $ (prettyTCM mod <> prettyTCM x) <+> ":" <+> prettyTCM e + , nest 2 $ caseMaybe gentel "(no gentel)" $ \ _ -> "(has gentel)" + ] + (genParams, npars, t) <- workOnTypes $ case gentel of Nothing -> ([], 0,) <$> isType_ e Just gentel -> @@ -582,7 +603,7 @@ reportSDoc "tc.decl.ax" 10 $ sep [ text $ "checked type signature" - , nest 2 $ prettyTCM rel <> prettyTCM x <+> ":" <+> prettyTCM t + , nest 2 $ (prettyTCM mod <> prettyTCM x) <+> ":" <+> prettyTCM t , nest 2 $ "of sort " <+> prettyTCM (getSort t) ] @@ -614,6 +635,12 @@ prettyShow occs ++ "\n " ++ prettyShow pols return (occs, pols) + + -- Set blocking tag to MissingClauses if we still expect clauses + let blk = case funSig of + A.FunSig{} -> NotBlocked MissingClauses () + A.NoFunSig{} -> NotBlocked ReallyNotBlocked () + -- Not safe. See Issue 330 -- t <- addForcingAnnotations t addConstant x =<< do @@ -626,11 +653,15 @@ { defArgOccurrences = occs , defPolarity = pols , defGeneralizedParams = genParams + , defBlocked = blk } -- Add the definition to the instance table, if needed - when (Info.defInstance i == InstanceDef) $ do - addTypedInstance x t + case Info.defInstance i of + InstanceDef _r -> setCurrentRange x $ addTypedInstance x t + -- Put highlighting on name only; including the instance keyword, + -- like @(getRange (r,x))@, does not produce good results. + NotInstanceDef -> pure () traceCall (IsType_ e) $ do -- need Range for error message -- Andreas, 2016-06-21, issue #2054 @@ -638,11 +669,8 @@ checkingWhere <- asksTC envCheckingWhere solveSizeConstraints $ if checkingWhere then DontDefaultToInfty else DefaultToInfty - -- Andreas, 2011-05-31, that freezing below is probably wrong: - -- when_ (Info.defAbstract i == AbstractDef) $ freezeMetas - -- | Type check a primitive function declaration. -checkPrimitive :: Info.DefInfo -> QName -> A.Expr -> TCM () +checkPrimitive :: A.DefInfo -> QName -> A.Expr -> TCM () checkPrimitive i x e = traceCall (CheckPrimitive (getRange i) x e) $ do (name, PrimImpl t' pf) <- lookupPrimitiveFunctionQ x @@ -661,7 +689,7 @@ , "primLevelMax" , "primSetOmega" ] - when (elem name builtinPrimitives) $ typeError $ NoSuchPrimitiveFunction name + when (name `elem` builtinPrimitives) $ typeError $ NoSuchPrimitiveFunction name t <- isType_ e noConstraints $ equalType t t' let s = prettyShow $ qnameName x @@ -674,25 +702,20 @@ , primInv = NotInjective , primCompiled = Nothing } -assertCurrentModule :: QName -> String -> TCM () -assertCurrentModule x err = - do def <- getConstInfo x - m <- currentModule - let m' = qnameModule $ defName def - unless (m == m' || isSubModuleOf m' m) $ typeError $ GenericError err - -- | Check a pragma. checkPragma :: Range -> A.Pragma -> TCM () checkPragma r p = traceCall (CheckPragma r p) $ case p of - A.BuiltinPragma x e -> bindBuiltin x e - A.BuiltinNoDefPragma b x -> bindBuiltinNoDef b x - A.RewritePragma q -> addRewriteRule q + A.BuiltinPragma x e -> bindBuiltin (rangedThing x) e + A.BuiltinNoDefPragma b x -> bindBuiltinNoDef (rangedThing b) x + A.RewritePragma _ qs -> addRewriteRules qs A.CompilePragma b x s -> do - assertCurrentModule x $ - "COMPILE pragmas must appear in the same module " ++ - "as their corresponding definitions," - addPragma b x s + -- Check that x resides in the same module (or a child) as the pragma. + x' <- defName <$> getConstInfo x -- Get the canonical name of x. + unlessM ((x' `isInModule`) <$> currentModule) $ + typeError $ GenericError $ + "COMPILE pragmas must appear in the same module as their corresponding definitions," + addPragma (rangedThing b) x s A.StaticPragma x -> do def <- getConstInfo x case theDef def of @@ -725,15 +748,15 @@ -- All definitions which have so far been assigned to the given mutual -- block are returned. checkMutual :: Info.MutualInfo -> [A.Declaration] -> TCM (MutualId, Set QName) -checkMutual i ds = inMutualBlock $ \ blockId -> do +checkMutual i ds = inMutualBlock $ \ blockId -> defaultOpenLevelsToZero $ do - verboseS "tc.decl.mutual" 20 $ do - reportSDoc "tc.decl.mutual" 20 $ vcat $ - ("Checking mutual block" <+> text (show blockId) <> ":") : + reportSDoc "tc.decl.mutual" 20 $ vcat $ + (("Checking mutual block" <+> text (show blockId)) <> ":") : map (nest 2 . prettyA) ds insertMutualBlockInfo blockId i - localTC (\e -> e { envTerminationCheck = () <$ Info.mutualTermCheck i }) $ + localTC ( set eTerminationCheck (() <$ Info.mutualTerminationCheck i) + . set eCoverageCheck (Info.mutualCoverageCheck i)) $ mapM_ checkDecl ds (blockId, ) . mutualNames <$> lookupMutualBlock blockId @@ -755,7 +778,6 @@ -- Issue #2321, only go to AbstractMode for abstract definitions | otherwise -> inConcreteMode PublicAccess -> inConcreteMode - OnlyQualified -> __IMPOSSIBLE__ in abstr $ checkAxiom' gtel funSig i info mp x e checkTypeSignature' _ _ = __IMPOSSIBLE__ -- type signatures are always axioms @@ -784,11 +806,12 @@ where bad = typeError $ ModuleArityMismatch m tel args + check :: Telescope -> [NamedArg A.Expr] -> TCM Telescope check tel [] = return tel check EmptyTel (_:_) = bad - check (ExtendTel dom@Dom{domInfo = info} btel) args0@(Arg info' (Named rname _) : args) = - let name = fmap rangedThing rname - my = fmap rangedThing $ domName dom + check (ExtendTel dom@Dom{domInfo = info} btel) args0@(Arg info' arg : args) = + let name = bareNameOf arg + my = bareNameOf dom tel = absBody btel in case (argInfoHiding info, argInfoHiding info', name) of (Instance{}, NotHidden, _) -> check tel args0 @@ -860,11 +883,11 @@ reportSDoc "tc.mod.apply" 15 $ vcat [ "applying section" <+> prettyTCM m2 , nest 2 $ "args =" <+> sep (map prettyA args) - , nest 2 $ "ptel =" <+> escapeContext (size ptel) (prettyTCM ptel) + , nest 2 $ "ptel =" <+> escapeContext __IMPOSSIBLE__ (size ptel) (prettyTCM ptel) , nest 2 $ "tel =" <+> prettyTCM tel , nest 2 $ "tel' =" <+> prettyTCM tel' , nest 2 $ "tel''=" <+> prettyTCM tel'' - , nest 2 $ "eta =" <+> escapeContext (size ptel) (addContext tel'' $ prettyTCM etaTel) + , nest 2 $ "eta =" <+> escapeContext __IMPOSSIBLE__ (size ptel) (addContext tel'' $ prettyTCM etaTel) ] -- Now, type check arguments. ts <- (noConstraints $ checkArguments_ DontExpandLast (getRange i) args tel') >>= \case @@ -911,7 +934,7 @@ -- Found last parameter: switch it to @Instance@. instFinal (ExtendTel dom (Abs n EmptyTel)) = ExtendTel do' (Abs n EmptyTel) - where do' = makeInstance dom { domName = Just $ unranged "r" } + where do' = makeInstance dom { domName = Just $ WithOrigin Inserted $ unranged "r" } -- Otherwise, keep searchinf for last parameter: instFinal (ExtendTel arg (Abs n tel)) = ExtendTel arg (Abs n (instFinal tel)) diff --git a/src/full/Agda/TypeChecking/Rules/Def.hs b/src/full/Agda/TypeChecking/Rules/Def.hs --- a/src/full/Agda/TypeChecking/Rules/Def.hs +++ b/src/full/Agda/TypeChecking/Rules/Def.hs @@ -1,31 +1,25 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE NondecreasingIndentation #-} module Agda.TypeChecking.Rules.Def where -#if MIN_VERSION_base(4,11,0) -import Prelude hiding ( (<>), mapM, null ) -#else import Prelude hiding ( mapM, null ) -#endif -import Control.Arrow ((***),first,second) +import Control.Arrow (first,second) import Control.Monad.State hiding (forM, mapM) -import Control.Monad.Reader hiding (forM, mapM) import Data.Function +import Data.IntSet (IntSet) +import qualified Data.IntSet as IntSet import qualified Data.List as List import Data.Maybe -import Data.Traversable (Traversable, traverse, forM, mapM) -import qualified Data.Map as Map -import qualified Data.Set as Set +import Data.Traversable (forM, mapM) import Data.Semigroup (Semigroup((<>))) +import Data.Tuple ( swap ) import Agda.Interaction.Options import Agda.Syntax.Common import qualified Agda.Syntax.Concrete as C -import Agda.Syntax.Concrete (exprFieldA) import Agda.Syntax.Position import Agda.Syntax.Abstract.Pattern as A import qualified Agda.Syntax.Abstract as A @@ -34,7 +28,6 @@ import Agda.Syntax.Internal.Pattern as I import qualified Agda.Syntax.Info as Info import Agda.Syntax.Fixity -import Agda.Syntax.Translation.InternalToAbstract import Agda.Syntax.Info import Agda.TypeChecking.Monad @@ -46,35 +39,30 @@ import Agda.TypeChecking.Conversion import Agda.TypeChecking.Coverage.SplitTree import Agda.TypeChecking.Inlining -import Agda.TypeChecking.MetaVars import Agda.TypeChecking.Reduce import Agda.TypeChecking.Patterns.Abstract (expandPatternSynonyms) -import Agda.TypeChecking.Pretty hiding ((<>)) -import qualified Agda.TypeChecking.Pretty as Pr +import Agda.TypeChecking.Pretty import Agda.TypeChecking.Substitute -import Agda.TypeChecking.Free import Agda.TypeChecking.CheckInternal import Agda.TypeChecking.With import Agda.TypeChecking.Telescope import Agda.TypeChecking.Injectivity import Agda.TypeChecking.Irrelevance import Agda.TypeChecking.SizedTypes.Solve -import Agda.TypeChecking.RecordPatterns -import Agda.TypeChecking.Records +import Agda.TypeChecking.Rewriting.Confluence import Agda.TypeChecking.CompiledClause (CompiledClauses'(..), hasProjectionPatterns) import Agda.TypeChecking.CompiledClause.Compile import Agda.TypeChecking.Primitive hiding (Nat) import Agda.TypeChecking.Rules.Term import Agda.TypeChecking.Rules.LHS ( checkLeftHandSide, LHSResult(..), bindAsPatterns ) -import Agda.TypeChecking.Rules.LHS.Problem ( AsBinding(..) ) import {-# SOURCE #-} Agda.TypeChecking.Rules.Decl ( checkDecls ) -import Agda.Utils.Except ( MonadError(catchError, throwError) ) +import Agda.Utils.Except ( MonadError(catchError) ) import Agda.Utils.Functor import Agda.Utils.Lens import Agda.Utils.List -import Agda.Utils.Maybe ( whenNothing ) +import Agda.Utils.Maybe import Agda.Utils.Monad import Agda.Utils.Null import Agda.Utils.Permutation @@ -82,18 +70,21 @@ import qualified Agda.Utils.Pretty as P import Agda.Utils.Size -#include "undefined.h" import Agda.Utils.Impossible --------------------------------------------------------------------------- -- * Definitions by pattern matching --------------------------------------------------------------------------- -checkFunDef :: Delayed -> Info.DefInfo -> QName -> [A.Clause] -> TCM () +checkFunDef :: Delayed -> A.DefInfo -> QName -> [A.Clause] -> TCM () checkFunDef delayed i name cs = do + -- Reset blocking tag (in case a previous attempt was blocked) + modifySignature $ updateDefinition name $ updateDefBlocked $ const $ + NotBlocked MissingClauses () -- Get the type and relevance of the function - t <- typeOfConst name - info <- flip setRelevance defaultArgInfo <$> relOfConst name + def <- instantiateDef =<< getConstInfo name + let t = defType def + let info = getArgInfo def case isAlias cs t of Just (e, mc, x) -> traceCall (CheckFunDefCall (getRange i) name cs) $ do @@ -105,11 +96,12 @@ _ -> checkFunDef' t info delayed Nothing Nothing i name cs -- If it's a macro check that it ends in Term → TC ⊤ - ismacro <- isMacro . theDef <$> getConstInfo name + let ismacro = isMacro . theDef $ def when (ismacro || Info.defMacro i == MacroDef) $ checkMacroType t `catchIlltypedPatternBlockedOnMeta` \ (err, x) -> do reportSDoc "tc.def" 20 $ vcat $ [ "checking function definition got stuck on meta: " <+> text (show x) ] + modifySignature $ updateDefinition name $ updateDefBlocked $ const $ Blocked x () addConstraint $ CheckFunDef delayed i name cs checkMacroType :: Type -> TCM () @@ -140,8 +132,14 @@ trivialClause _ = Nothing -- | Check a trivial definition of the form @f = e@ -checkAlias :: Type -> ArgInfo -> Delayed -> Info.DefInfo -> QName -> A.Expr -> Maybe C.Expr -> TCM () -checkAlias t ai delayed i name e mc = atClause name 0 (A.RHS e mc) $ do +checkAlias :: Type -> ArgInfo -> Delayed -> A.DefInfo -> QName -> A.Expr -> Maybe C.Expr -> TCM () +checkAlias t ai delayed i name e mc = + let clause = A.Clause { clauseLHS = A.SpineLHS (LHSInfo (getRange i) NoEllipsis) name [] + , clauseStrippedPats = [] + , clauseRHS = A.RHS e mc + , clauseWhereDecls = A.noWhereDecls + , clauseCatchall = False } in + atClause name 0 t Nothing clause $ do reportSDoc "tc.def.alias" 10 $ "checkAlias" <+> vcat [ text (prettyShow name) <+> colon <+> prettyTCM t , text (prettyShow name) <+> equals <+> prettyTCM e @@ -178,7 +176,9 @@ , clauseBody = Just $ bodyMod v , clauseType = Just $ Arg ai t , clauseCatchall = False + , clauseRecursive = Nothing -- we don't know yet , clauseUnreachable = Just False + , clauseEllipsis = NoEllipsis } ] , funCompiled = Just $ Done [] $ bodyMod v , funSplitTree = Just $ SplittingDone 0 @@ -188,20 +188,23 @@ -- Andreas, 2017-01-01, issue #2372: -- Add the definition to the instance table, if needed, to update its type. - when (Info.defInstance i == InstanceDef) $ do - addTypedInstance name t + case Info.defInstance i of + InstanceDef _r -> setCurrentRange name $ addTypedInstance name t + -- Put highlighting on the name only; + -- @(getRange (r, name))@ does not give good results. + NotInstanceDef -> pure () reportSDoc "tc.def.alias" 20 $ "checkAlias: leaving" -- | Type check a definition by pattern matching. checkFunDef' :: Type -- ^ the type we expect the function to have - -> ArgInfo -- ^ is it irrelevant (for instance) + -> ArgInfo -- ^ is it irrelevant (for instance) -> Delayed -- ^ are the clauses delayed (not unfolded willy-nilly) -> Maybe ExtLamInfo -- ^ does the definition come from an extended lambda -- (if so, we need to know some stuff about lambda-lifted args) -> Maybe QName -- ^ is it a with function (if so, what's the name of the parent function) - -> Info.DefInfo -- ^ range info + -> A.DefInfo -- ^ range info -> QName -- ^ the name of the function -> [A.Clause] -- ^ the clauses to check -> TCM () @@ -210,12 +213,12 @@ -- | Type check a definition by pattern matching. checkFunDefS :: Type -- ^ the type we expect the function to have - -> ArgInfo -- ^ is it irrelevant (for instance) + -> ArgInfo -- ^ is it irrelevant (for instance) -> Delayed -- ^ are the clauses delayed (not unfolded willy-nilly) -> Maybe ExtLamInfo -- ^ does the definition come from an extended lambda -- (if so, we need to know some stuff about lambda-lifted args) -> Maybe QName -- ^ is it a with function (if so, what's the name of the parent function) - -> Info.DefInfo -- ^ range info + -> A.DefInfo -- ^ range info -> QName -- ^ the name of the function -> Maybe Substitution -- ^ substitution (from with abstraction) that needs to be applied to module parameters -> [A.Clause] -- ^ the clauses to check @@ -247,7 +250,7 @@ -- Check the clauses cs <- traceCall NoHighlighting $ do -- To avoid flicker. forM (zip cs [0..]) $ \ (c, clauseNo) -> do - atClause name clauseNo (A.clauseRHS c) $ do + atClause name clauseNo t withSub c $ do (c,b) <- applyModalityToContextFunBody ai $ do checkClause t withSub c -- Andreas, 2013-11-23 do not solve size constraints here yet @@ -295,12 +298,16 @@ , nest 2 $ sep $ map (text . show . QNamed name) cs ] + -- Needed to calculate the proper fullType below. + -- Also: issue #4173, allow splitting on erased arguments in erased definitions + -- in the coverage checker. + applyCohesionToContext ai $ applyQuantityToContext ai $ do -- Systems have their own coverage and "coherence" check, we -- also add an absurd clause for the cases not needed. - (cs,sys) <- if not isSystem then return (cs, Nothing) else do + (cs,sys) <- if not isSystem then return (cs, empty) else do fullType <- flip abstract t <$> getContextTelescope - sys <- inTopContext $ checkSystemCoverage name isOneIxs fullType cs + sys <- inTopContext $ checkSystemCoverage name (IntSet.toList isOneIxs) fullType cs tel <- getContextTelescope let c = Clause { clauseFullRange = noRange @@ -310,9 +317,11 @@ , clauseBody = Nothing , clauseType = Just (defaultArg t) , clauseCatchall = False + , clauseRecursive = Just False , clauseUnreachable = Just False + , clauseEllipsis = NoEllipsis } - return (cs ++ [c], Just sys) + return (cs ++ [c], pure sys) -- Annotate the clauses with which arguments are actually used. cs <- instantiateFull {- =<< mapM rebindClause -} cs @@ -325,7 +334,7 @@ -- Check if the function is injective. -- Andreas, 2015-07-01 we do it here in order to resolve metas -- in mutual definitions, e.g. the U/El definition in succeed/Issue439.agda - -- We do it again for the mutual block after polarity analysis, see Rules.Decl. + -- We do it again for the mutual block after termination checking, see Rules.Decl. reportSLn "tc.inj.def" 20 $ "checkFunDef': checking injectivity..." inv <- Bench.billTo [Bench.Injectivity] $ checkInjectivity name cs @@ -340,7 +349,7 @@ , nest 2 $ sep $ map (text . show) cs ] - -- add clauses for the coverage checker (needs to reduce) + -- add clauses for the coverage (& confluence) checker (needs to reduce) inTopContext $ addClauses name cs reportSDoc "tc.cc.type" 60 $ " type : " <+> (text . prettyShow) t @@ -351,9 +360,16 @@ reportSLn "tc.cc.type" 80 $ show fullType -- Coverage check and compile the clauses - (mst, cc) <- Bench.billTo [Bench.Coverage] $ - inTopContext $ compileClauses (if isSystem then Nothing else (Just (name, fullType))) + (mst, _recordExpressionBecameCopatternLHS, cc) <- Bench.billTo [Bench.Coverage] $ + unsafeInTopContext $ compileClauses (if isSystem then Nothing else (Just (name, fullType))) cs + -- Andreas, 2019-10-21 (see also issue #4142): + -- We ignore whether the clause compilation turned some + -- record expressions into copatterns + -- (_recordExpressionsBecameCopatternLHS), + -- since the defCopatternLHS flag is anyway set by traversing + -- the compiled clauses looking for a copattern match + -- (hasProjectionPatterns). -- Clause compilation runs the coverage checker, which might add -- some extra clauses. @@ -369,6 +385,13 @@ covering <- funCovering . theDef <$> getConstInfo name + -- Jesper, 2019-05-30: if the constructors used in the + -- lhs of a clause have rewrite rules, we need to check + -- confluence here + whenM (optConfluenceCheck <$> pragmaOptions) $ inTopContext $ + forM_ (zip cs [0..]) $ \(c , clauseNo) -> + checkConfluenceOfClause name clauseNo c + -- Add the definition inTopContext $ addConstant name =<< do -- If there was a pragma for this definition, we can set the @@ -384,10 +407,11 @@ , funAbstr = Info.defAbstract i , funExtLam = (\ e -> e { extLamSys = sys }) <$> extlam , funWith = with - , funCopatternLHS = hasProjectionPatterns cc , funCovering = covering } - useTerPragma $ defaultDefn ai name fullType defn + useTerPragma $ + updateDefCopatternLHS (const $ hasProjectionPatterns cc) $ + defaultDefn ai name fullType defn reportSDoc "tc.def.fun" 10 $ do sep [ "added " <+> prettyTCM name <+> ":" @@ -398,19 +422,18 @@ -- which comes from a possible termination pragma. useTerPragma :: Definition -> TCM Definition useTerPragma def@Defn{ defName = name, theDef = fun@Function{}} = do - tc <- asksTC envTerminationCheck + tc <- viewTC eTerminationCheck let terminates = case tc of NonTerminating -> Just False Terminating -> Just True _ -> Nothing - reportSLn "tc.fundef" 30 $ unlines $ + reportS "tc.fundef" 30 $ [ "funTerminates of " ++ prettyShow name ++ " set to " ++ show terminates , " tc = " ++ show tc ] return $ def { theDef = fun { funTerminates = terminates }} useTerPragma def = return def - -- | Insert some with-patterns into the with-clauses LHS of the given RHS. -- (Used for @rewrite@.) insertPatterns :: [A.Pattern] -> A.RHS -> A.RHS @@ -433,21 +456,20 @@ data WithFunctionProblem = NoWithFunction | WithFunction - { wfParentName :: QName -- ^ Parent function name. - , wfName :: QName -- ^ With function name. - , wfParentType :: Type -- ^ Type of the parent function. - , wfParentTel :: Telescope -- ^ Context of the parent patterns. - , wfBeforeTel :: Telescope -- ^ Types of arguments to the with function before the with expressions (needed vars). - , wfAfterTel :: Telescope -- ^ Types of arguments to the with function after the with expressions (unneeded vars). - , wfExprs :: [Term] -- ^ With and rewrite expressions. - , wfExprTypes :: [EqualityView] -- ^ Types of the with and rewrite expressions. - , wfRHSType :: Type -- ^ Type of the right hand side. - , wfParentPats :: [NamedArg DeBruijnPattern] -- ^ Parent patterns. - , wfParentParams :: Nat -- ^ Number of module parameters in parent patterns - , wfPermSplit :: Permutation -- ^ Permutation resulting from splitting the telescope into needed and unneeded vars. - , wfPermParent :: Permutation -- ^ Permutation reordering the variables in the parent pattern. - , wfPermFinal :: Permutation -- ^ Final permutation (including permutation for the parent clause). - , wfClauses :: [A.Clause] -- ^ The given clauses for the with function + { wfParentName :: QName -- ^ Parent function name. + , wfName :: QName -- ^ With function name. + , wfParentType :: Type -- ^ Type of the parent function. + , wfParentTel :: Telescope -- ^ Context of the parent patterns. + , wfBeforeTel :: Telescope -- ^ Types of arguments to the with function before the with expressions (needed vars). + , wfAfterTel :: Telescope -- ^ Types of arguments to the with function after the with expressions (unneeded vars). + , wfExprs :: [WithHiding (Term, EqualityView)] -- ^ With and rewrite expressions and their types. + , wfRHSType :: Type -- ^ Type of the right hand side. + , wfParentPats :: [NamedArg DeBruijnPattern] -- ^ Parent patterns. + , wfParentParams :: Nat -- ^ Number of module parameters in parent patterns + , wfPermSplit :: Permutation -- ^ Permutation resulting from splitting the telescope into needed and unneeded vars. + , wfPermParent :: Permutation -- ^ Permutation reordering the variables in the parent pattern. + , wfPermFinal :: Permutation -- ^ Final permutation (including permutation for the parent clause). + , wfClauses :: [A.Clause] -- ^ The given clauses for the with function } checkSystemCoverage @@ -559,37 +581,43 @@ -- * Info that is needed after all clauses have been processed. + data ClausesPostChecks = CPC - { cpcPartialSplits :: [Int] + { cpcPartialSplits :: IntSet -- ^ Which argument indexes have a partial split. } instance Semigroup ClausesPostChecks where - (<>) (CPC xs) (CPC xs') = CPC (List.nub $ mappend xs xs') + CPC xs <> CPC xs' = CPC (IntSet.union xs xs') instance Monoid ClausesPostChecks where - mempty = CPC [] + mempty = CPC empty mappend = (<>) --- | Type check a function clause. - -checkClause - :: Type -- ^ Type of function defined by this clause. - -> Maybe Substitution -- ^ Module parameter substitution arising from with-abstraction. - -> A.SpineClause -- ^ Clause. - -> TCM (Clause,ClausesPostChecks) -- ^ Type-checked clause - -checkClause t withSub c@(A.Clause (A.SpineLHS i x aps) strippedPats rhs0 wh catchall) = do +-- | The LHS part of checkClause. +checkClauseLHS :: Type -> Maybe Substitution -> A.SpineClause -> (LHSResult -> TCM a) -> TCM a +checkClauseLHS t withSub c@(A.Clause lhs@(A.SpineLHS i x aps) strippedPats rhs0 wh catchall) ret = do reportSDoc "tc.lhs.top" 30 $ "Checking clause" $$ prettyA c unlessNull (trailingWithPatterns aps) $ \ withPats -> do typeError $ UnexpectedWithPatterns $ map namedArg withPats traceCall (CheckClause t c) $ do aps <- expandPatternSynonyms aps - cxtNames <- reverse . map (fst . unDom) <$> getContext when (not $ null strippedPats) $ reportSDoc "tc.lhs.top" 50 $ "strippedPats:" <+> vcat [ prettyA p <+> "=" <+> prettyTCM v <+> ":" <+> prettyTCM a | A.ProblemEq p v a <- strippedPats ] closed_t <- flip abstract t <$> getContextTelescope - checkLeftHandSide (CheckPatternShadowing c) (Just x) aps t withSub strippedPats $ \ lhsResult@(LHSResult npars delta ps absurdPat trhs patSubst asb psplit) -> do + checkLeftHandSide (CheckLHS lhs) (Just x) aps t withSub strippedPats ret + +-- | Type check a function clause. + +checkClause + :: Type -- ^ Type of function defined by this clause. + -> Maybe Substitution -- ^ Module parameter substitution arising from with-abstraction. + -> A.SpineClause -- ^ Clause. + -> TCM (Clause,ClausesPostChecks) -- ^ Type-checked clause + +checkClause t withSub c@(A.Clause lhs@(A.SpineLHS i x aps) strippedPats rhs0 wh catchall) = do + cxtNames <- reverse . map (fst . unDom) <$> getContext + checkClauseLHS t withSub c $ \ lhsResult@(LHSResult npars delta ps absurdPat trhs patSubst asb psplit) -> do -- Note that we might now be in irrelevant context, -- in case checkLeftHandSide walked over an irrelevant projection pattern. @@ -624,7 +652,7 @@ -- the context with the parent (but withSub will take you from parent -- to child). - inTopContext $ Bench.billTo [Bench.Typing, Bench.With] $ checkWithFunction cxtNames with + unsafeInTopContext $ Bench.billTo [Bench.Typing, Bench.With] $ checkWithFunction cxtNames with whenM (optDoubleCheck <$> pragmaOptions) $ case body of Just v -> do @@ -632,20 +660,20 @@ [ "double checking rhs" , nest 2 (prettyTCM v <+> " : " <+> prettyTCM (unArg trhs)) ] - noConstraints $ dontAssignMetas $ checkInternal v $ unArg trhs + noConstraints $ dontAssignMetas $ checkInternal v CmpLeq $ unArg trhs Nothing -> return () reportSDoc "tc.lhs.top" 10 $ vcat [ "Clause before translation:" , nest 2 $ vcat - [ "delta =" <+> do escapeContext (size delta) $ prettyTCM delta + [ "delta =" <+> do escapeContext __IMPOSSIBLE__ (size delta) $ prettyTCM delta , "ps =" <+> do P.fsep <$> prettyTCMPatterns ps , "body =" <+> maybe "_|_" prettyTCM body , "type =" <+> prettyTCM t ] ] - reportSDoc "tc.lhs.top" 60 $ escapeContext (size delta) $ vcat + reportSDoc "tc.lhs.top" 60 $ escapeContext __IMPOSSIBLE__ (size delta) $ vcat [ "Clause before translation (raw):" , nest 2 $ vcat [ "ps =" <+> text (show ps) @@ -667,7 +695,7 @@ ConP _ _ ps -> iApplyVars ps -- compute body modification for irrelevant definitions, see issue 610 - rel <- asksTC envRelevance + rel <- asksTC getRelevance let bodyMod body = case rel of Irrelevant -> dontCare <$> body _ -> body @@ -684,7 +712,9 @@ , clauseBody = bodyMod body , clauseType = Just trhs , clauseCatchall = catchall' + , clauseRecursive = Nothing -- we don't know yet , clauseUnreachable = Nothing -- we don't know yet + , clauseEllipsis = lhsEllipsis i } -- | Type check the @with@ and @rewrite@ lhss and/or the rhs. @@ -698,166 +728,226 @@ -> A.RHS -- ^ Rhs to check. -> TCM (Maybe Term, WithFunctionProblem) -- Note: the as-bindings are already bound (in checkClause) -checkRHS i x aps t lhsResult@(LHSResult _ delta ps absurdPat trhs _ _asb _) rhs0 = handleRHS rhs0 - where - handleRHS rhs = - case rhs of +checkRHS i x aps t lhsResult@(LHSResult _ delta ps absurdPat trhs _ _asb _) rhs0 = + handleRHS rhs0 where - -- Case: ordinary RHS - A.RHS e _ -> Bench.billTo [Bench.Typing, Bench.CheckRHS] $ do - -- If there is an absurd pattern, we do not need a RHS. If we have - -- one we complain, ignore it and return the same @(Nothing, NoWithFunction)@ - -- as the case dealing with @A.AbsurdRHS@. - mv <- if absurdPat - then Nothing <$ setCurrentRange rhs (warning $ AbsurdPatternRequiresNoRHS ps) - else Just <$> checkExpr e (unArg trhs) - return (mv, NoWithFunction) + handleRHS :: A.RHS -> TCM (Maybe Term, WithFunctionProblem) + handleRHS rhs = case rhs of + A.RHS e _ -> ordinaryRHS e + A.AbsurdRHS -> noRHS + A.RewriteRHS eqs ps rhs wh -> rewriteEqnsRHS eqs ps rhs wh + A.WithRHS aux es cs -> withRHS aux es cs - -- Case: no RHS - A.AbsurdRHS -> do - unless absurdPat $ typeError $ NoRHSRequiresAbsurdPattern aps - return (Nothing, NoWithFunction) + -- Ordinary case: f xs = e + ordinaryRHS :: A.Expr -> TCM (Maybe Term, WithFunctionProblem) + ordinaryRHS e = Bench.billTo [Bench.Typing, Bench.CheckRHS] $ do + -- If there is an absurd pattern, we do not need a RHS. If we have + -- one we complain, ignore it and return the same @(Nothing, NoWithFunction)@ + -- as the case dealing with @A.AbsurdRHS@. + mv <- if absurdPat + then Nothing <$ setCurrentRange e (warning $ AbsurdPatternRequiresNoRHS ps) + else Just <$> checkExpr e (unArg trhs) + return (mv, NoWithFunction) + -- Absurd case: no right hand side + noRHS :: TCM (Maybe Term, WithFunctionProblem) + noRHS = do + unless absurdPat $ typeError $ NoRHSRequiresAbsurdPattern aps + return (Nothing, NoWithFunction) + + + -- With case: @f xs with a | b | c | ...; ... | ps1 = rhs1; ... | ps2 = rhs2; ...@ + -- This is mostly a wrapper around @checkWithRHS@ + withRHS :: QName -- ^ name of the with-function + -> [WithHiding A.Expr] -- ^ @[a, b, c, ...]@ + -> [A.Clause] -- ^ @[(ps1 = rhs1), (ps2 = rhs), ...]@ + -> TCM (Maybe Term, WithFunctionProblem) + withRHS aux es cs = do + + reportSDoc "tc.with.top" 15 $ vcat + [ "TC.Rules.Def.checkclause reached A.WithRHS" + , sep $ prettyA aux : map (parens . prettyA) es + ] + reportSDoc "tc.with.top" 20 $ do + nfv <- getCurrentModuleFreeVars + m <- currentModule + sep [ "with function module:" <+> + prettyList (map prettyTCM $ mnameToList m) + , text $ "free variables: " ++ show nfv + ] + + -- Infer the types of the with expressions + vtys <- mapM (traverse (fmap OtherType <.> inferExprForWith)) es + + -- Andreas, 2016-01-23, Issue #1796 + -- Run the size constraint solver to improve with-abstraction + -- in case the with-expression contains size metas. + solveSizeConstraints DefaultToInfty + + checkWithRHS x aux t lhsResult vtys cs + + -- Rewrite case: f xs (rewrite / invert) a | b | c | ... + rewriteEqnsRHS :: [A.RewriteEqn] -> [A.ProblemEq] -> A.RHS -> A.WhereDeclarations -> TCM (Maybe Term, WithFunctionProblem) + rewriteEqnsRHS [] strippedPats rhs wh = checkWhere wh $ handleRHS rhs -- Case: @rewrite@ -- Andreas, 2014-01-17, Issue 1402: -- If the rewrites are discarded since lhs=rhs, then -- we can actually have where clauses. - A.RewriteRHS [] strippedPats rhs wh -> checkWhere wh $ handleRHS rhs - A.RewriteRHS ((qname,eq):qes) strippedPats rhs wh -> do + rewriteEqnsRHS (r:rs) strippedPats rhs wh = case r of + Rewrite ((qname, eq) : qes) -> + rewriteEqnRHS qname eq (case qes of { [] -> rs; _ -> Rewrite qes : rs }) + Invert _ [] -> __IMPOSSIBLE__ + Invert qname pes -> invertEqnRHS qname pes rs + -- Invariant: these lists are non-empty + Rewrite [] -> __IMPOSSIBLE__ - -- Action for skipping this rewrite. - -- We do not want to create unsolved metas in case of - -- a futile rewrite with a reflexive equation. - -- Thus, we restore the state in this case, - -- unless the rewrite expression contains questionmarks. - st <- getTC - let recurse = do - st' <- getTC - -- Comparing the whole stInteractionPoints maps is a bit - -- wasteful, but we assume - -- 1. rewriting with a reflexive equality to happen rarely, - -- 2. especially with ?-holes in the rewrite expression - -- 3. and a large overall number of ?s. - let sameIP = (==) `on` (^.stInteractionPoints) - when (sameIP st st') $ putTC st - handleRHS $ A.RewriteRHS qes strippedPats rhs wh + where - -- Get value and type of rewrite-expression. + -- @invert@ clauses + invertEqnRHS :: QName -> [(A.Pattern,A.Expr)] -> [A.RewriteEqn] -> TCM (Maybe Term, WithFunctionProblem) + invertEqnRHS qname pes rs = do - (proof, eqt) <- inferExpr eq + let (pats, es) = unzip pes + -- Infer the types of the with expressions + vtys <- mapM (WithHiding NotHidden <.> fmap OtherType <.> inferExprForWith) es - -- Andreas, 2016-04-14, see also Issue #1796 - -- Run the size constraint solver to improve with-abstraction - -- in case the with-expression contains size metas. - solveSizeConstraints DefaultToInfty + -- Andreas, 2016-04-14, see also Issue #1796 + -- Run the size constraint solver to improve with-abstraction + -- in case the with-expression contains size metas. + solveSizeConstraints DefaultToInfty - -- Check that the type is actually an equality (lhs ≡ rhs) - -- and extract lhs, rhs, and their type. + let rhs' = insertPatterns pats rhs + (rhs'', outerWhere) -- the where clauses should go on the inner-most with + | null rs = (rhs', wh) + | otherwise = (A.RewriteRHS rs strippedPats rhs' wh, A.noWhereDecls) + -- Andreas, 2014-03-05 kill range of copied patterns + -- since they really do not have a source location. + cl = A.Clause (A.LHS i $ insertPatternsLHSCore pats $ A.LHSHead x $ killRange aps) + strippedPats rhs'' outerWhere False - t' <- reduce =<< instantiateFull eqt - (eqt,rewriteType,rewriteFrom,rewriteTo) <- equalityView t' >>= \case - eqt@(EqualityType _s _eq _params (Arg _ dom) a b) -> do - s <- inferSort dom - return (eqt, El s dom, unArg a, unArg b) - -- Note: the sort _s of the equality need not be the sort of the type @dom@! - OtherType{} -> typeError . GenericDocError =<< do - "Cannot rewrite by equation of type" <+> prettyTCM t' + reportSDoc "tc.invert" 60 $ vcat + [ text "invert" + , " rhs' = " <> (text . show) rhs' + ] + checkWithRHS x qname t lhsResult vtys [cl] - -- Get the name of builtin REFL. + -- @rewrite@ clauses + rewriteEqnRHS :: QName -> A.Expr + -> [A.RewriteEqn] -> TCM (Maybe Term, WithFunctionProblem) + rewriteEqnRHS qname eq rs = do - Con reflCon _ [] <- primRefl - reflInfo <- fmap (setOrigin Inserted) <$> getReflArgInfo reflCon + -- Action for skipping this rewrite. + -- We do not want to create unsolved metas in case of + -- a futile rewrite with a reflexive equation. + -- Thus, we restore the state in this case, + -- unless the rewrite expression contains questionmarks. + st <- getTC + let recurse = do + st' <- getTC + -- Comparing the whole stInteractionPoints maps is a bit + -- wasteful, but we assume + -- 1. rewriting with a reflexive equality to happen rarely, + -- 2. especially with ?-holes in the rewrite expression + -- 3. and a large overall number of ?s. + let sameIP = (==) `on` (^.stInteractionPoints) + when (sameIP st st') $ putTC st + handleRHS $ A.RewriteRHS rs strippedPats rhs wh - -- Andreas, 2017-01-11: - -- The test for refl is obsolete after fixes of #520 and #1740. - -- -- Andreas, 2014-05-17 Issue 1110: - -- -- Rewriting with @refl@ has no effect, but gives an - -- -- incomprehensible error message about the generated - -- -- with clause. Thus, we rather do simply nothing if - -- -- rewriting with @refl@ is attempted. - -- let isReflProof = do - -- v <- reduce proof - -- case v of - -- Con c _ [] | c == reflCon -> return True - -- _ -> return False - -- ifM isReflProof recurse $ {- else -} do + -- Get value and type of rewrite-expression. - -- Process 'rewrite' clause like a suitable 'with' clause. + (proof, eqt) <- inferExpr eq - -- The REFL constructor might have an argument - let reflPat = A.ConP (ConPatInfo ConOCon patNoRange ConPatEager) (unambiguous $ conName reflCon) $ - maybeToList $ fmap (\ ai -> Arg ai $ unnamed $ A.WildP patNoRange) reflInfo + -- Andreas, 2016-04-14, see also Issue #1796 + -- Run the size constraint solver to improve with-abstraction + -- in case the with-expression contains size metas. + solveSizeConstraints DefaultToInfty - -- Andreas, 2015-12-25 Issue #1740: - -- After the fix of #520, rewriting with a reflexive equation - -- has to be desugared as matching against refl. - let isReflexive = tryConversion $ dontAssignMetas $ - equalTerm rewriteType rewriteFrom rewriteTo + -- Check that the type is actually an equality (lhs ≡ rhs) + -- and extract lhs, rhs, and their type. - (pats, withExpr, withType) <- do - ifM isReflexive - {-then-} (return ([ reflPat ], proof, OtherType t')) - {-else-} (return ([ A.WildP patNoRange, reflPat ], proof, eqt)) + t' <- reduce =<< instantiateFull eqt + (eqt,rewriteType,rewriteFrom,rewriteTo) <- equalityView t' >>= \case + eqt@(EqualityType _s _eq _params (Arg _ dom) a b) -> do + s <- inferSort dom + return (eqt, El s dom, unArg a, unArg b) + -- Note: the sort _s of the equality need not be the sort of the type @dom@! + OtherType{} -> typeError . GenericDocError =<< do + "Cannot rewrite by equation of type" <+> prettyTCM t' - let rhs' = insertPatterns pats rhs - (rhs'', outerWhere) -- the where clauses should go on the inner-most with - | null qes = (rhs', wh) - | otherwise = (A.RewriteRHS qes strippedPats rhs' wh, A.noWhereDecls) - -- Andreas, 2014-03-05 kill range of copied patterns - -- since they really do not have a source location. - cl = A.Clause (A.LHS i $ insertPatternsLHSCore pats $ A.LHSHead x $ killRange aps) - strippedPats rhs'' outerWhere False - reportSDoc "tc.rewrite" 60 $ vcat - [ "rewrite" - , " rhs' = " Pr.<> (text . show) rhs' - ] - checkWithRHS x qname t lhsResult [withExpr] [withType] [cl] + -- Get the name of builtin REFL. - -- Case: @with@ - A.WithRHS aux es cs -> do - reportSDoc "tc.with.top" 15 $ vcat - [ "TC.Rules.Def.checkclause reached A.WithRHS" - , sep $ prettyA aux : map (parens . prettyA) es - ] - reportSDoc "tc.with.top" 20 $ do - nfv <- getCurrentModuleFreeVars - m <- currentModule - sep [ "with function module:" <+> - prettyList (map prettyTCM $ mnameToList m) - , text $ "free variables: " ++ show nfv - ] + Con reflCon _ [] <- primRefl + reflInfo <- fmap (setOrigin Inserted) <$> getReflArgInfo reflCon - -- Infer the types of the with expressions - (vs0, as) <- unzip <$> mapM inferExprForWith es + -- Andreas, 2017-01-11: + -- The test for refl is obsolete after fixes of #520 and #1740. + -- -- Andreas, 2014-05-17 Issue 1110: + -- -- Rewriting with @refl@ has no effect, but gives an + -- -- incomprehensible error message about the generated + -- -- with clause. Thus, we rather do simply nothing if + -- -- rewriting with @refl@ is attempted. + -- let isReflProof = do + -- v <- reduce proof + -- case v of + -- Con c _ [] | c == reflCon -> return True + -- _ -> return False + -- ifM isReflProof recurse $ {- else -} do - -- Andreas, 2016-01-23, Issue #1796 - -- Run the size constraint solver to improve with-abstraction - -- in case the with-expression contains size metas. - solveSizeConstraints DefaultToInfty + -- Process 'rewrite' clause like a suitable 'with' clause. - checkWithRHS x aux t lhsResult vs0 (map OtherType as) cs + -- The REFL constructor might have an argument + let reflPat = A.ConP (ConPatInfo ConOCon patNoRange ConPatEager) (unambiguous $ conName reflCon) $ + maybeToList $ fmap (\ ai -> Arg ai $ unnamed $ A.WildP patNoRange) reflInfo + -- Andreas, 2015-12-25 Issue #1740: + -- After the fix of #520, rewriting with a reflexive equation + -- has to be desugared as matching against refl. + let isReflexive = tryConversion $ dontAssignMetas $ + equalTerm rewriteType rewriteFrom rewriteTo + + (pats, withExpr, withType) <- do + ifM isReflexive + {-then-} (return ([ reflPat ] , proof, OtherType t')) + {-else-} (return ([ A.WildP patNoRange, reflPat ], proof, eqt)) + + let rhs' = insertPatterns pats rhs + (rhs'', outerWhere) -- the where clauses should go on the inner-most with + | null rs = (rhs', wh) + | otherwise = (A.RewriteRHS rs strippedPats rhs' wh, A.noWhereDecls) + -- Andreas, 2014-03-05 kill range of copied patterns + -- since they really do not have a source location. + cl = A.Clause (A.LHS i $ insertPatternsLHSCore pats $ A.LHSHead x $ killRange aps) + strippedPats rhs'' outerWhere False + + reportSDoc "tc.rewrite" 60 $ vcat + [ text "rewrite" + , " rhs' = " <> (text . show) rhs' + ] + checkWithRHS x qname t lhsResult [WithHiding NotHidden (withExpr, withType)] [cl] + checkWithRHS - :: QName -- ^ Name of function. - -> QName -- ^ Name of the with-function. - -> Type -- ^ Type of function. - -> LHSResult -- ^ Result of type-checking patterns - -> [Term] -- ^ With-expressions. - -> [EqualityView] -- ^ Types of with-expressions. - -> [A.Clause] -- ^ With-clauses to check. + :: QName -- ^ Name of function. + -> QName -- ^ Name of the with-function. + -> Type -- ^ Type of function. + -> LHSResult -- ^ Result of type-checking patterns + -> [WithHiding (Term, EqualityView)] -- ^ Expressions and types of with-expressions. + -> [A.Clause] -- ^ With-clauses to check. -> TCM (Maybe Term, WithFunctionProblem) -- Note: as-bindings already bound (in checkClause) -checkWithRHS x aux t (LHSResult npars delta ps _absurdPat trhs _ _asb _) vs0 as cs = Bench.billTo [Bench.Typing, Bench.With] $ do - let withArgs = withArguments vs0 as +checkWithRHS x aux t (LHSResult npars delta ps _absurdPat trhs _ _asb _) vtys0 cs = + Bench.billTo [Bench.Typing, Bench.With] $ do + let withArgs = withArguments vtys0 perm = fromMaybe __IMPOSSIBLE__ $ dbPatPerm ps - (vs, as) <- normalise (vs0, as) + vtys0 <- normalise vtys0 -- Andreas, 2012-09-17: for printing delta, -- we should remove it from the context first - reportSDoc "tc.with.top" 25 $ escapeContext (size delta) $ vcat + reportSDoc "tc.with.top" 25 $ escapeContext __IMPOSSIBLE__ (size delta) $ vcat [ "delta =" <+> prettyTCM delta ] - reportSDoc "tc.with.top" 25 $ vcat + reportSDoc "tc.with.top" 25 $ vcat $ + -- declared locally because we do not want to use the unzip'd thing! + let (vs, as) = unzipWith whThing vtys0 in [ "vs =" <+> prettyTCM vs , "as =" <+> prettyTCM as , "perm =" <+> text (show perm) @@ -865,15 +955,14 @@ -- Split the telescope into the part needed to type the with arguments -- and all the other stuff - (delta1, delta2, perm', t', as, vs) <- return $ - splitTelForWith delta (unArg trhs) as vs + let (delta1, delta2, perm', t', vtys) = splitTelForWith delta (unArg trhs) vtys0 let finalPerm = composeP perm' perm reportSLn "tc.with.top" 75 $ "delta = " ++ show delta -- Andreas, 2012-09-17: for printing delta, -- we should remove it from the context first - reportSDoc "tc.with.top" 25 $ escapeContext (size delta) $ vcat + reportSDoc "tc.with.top" 25 $ escapeContext __IMPOSSIBLE__ (size delta) $ vcat [ "delta1 =" <+> prettyTCM delta1 , "delta2 =" <+> addContext delta1 (prettyTCM delta2) ] @@ -893,43 +982,42 @@ -- Then permute the rest and grab those needed to for the with arguments (us1, us2) = splitAt (size delta1) $ permute perm' us1' -- Now stuff the with arguments in between and finish with the remaining variables - v = Def aux $ map Apply $ us0 ++ us1 ++ map defaultArg withArgs ++ us2 + mkWithArg = \ (WithHiding h e) -> setHiding h $ defaultArg e + v = Def aux $ map Apply $ us0 ++ us1 ++ map mkWithArg withArgs ++ us2 -- Andreas, 2013-02-26 add with-name to signature for printing purposes addConstant aux =<< do useTerPragma $ defaultDefn defaultArgInfo aux __DUMMY_TYPE__ emptyFunction -- Andreas, 2013-02-26 separate msgs to see which goes wrong - reportSDoc "tc.with.top" 20 $ - " with arguments" <+> do escapeContext (size delta) $ addContext delta1 $ prettyList (map prettyTCM vs) - reportSDoc "tc.with.top" 20 $ - " types" <+> do escapeContext (size delta) $ addContext delta1 $ prettyList (map prettyTCM as) - reportSDoc "tc.with.top" 20 $ - "with function call" <+> prettyTCM v - reportSDoc "tc.with.top" 20 $ - " context" <+> (prettyTCM =<< getContextTelescope) - reportSDoc "tc.with.top" 20 $ - " delta" <+> do escapeContext (size delta) $ prettyTCM delta - reportSDoc "tc.with.top" 20 $ - " delta1" <+> do escapeContext (size delta) $ prettyTCM delta1 - reportSDoc "tc.with.top" 20 $ - " delta2" <+> do escapeContext (size delta) $ addContext delta1 $ prettyTCM delta2 - reportSDoc "tc.with.top" 20 $ - " body" <+> prettyTCM v + reportSDoc "tc.with.top" 20 $ vcat $ + let (vs, as) = unzipWith whThing vtys in + [ " with arguments" <+> do escapeContext __IMPOSSIBLE__ (size delta) $ addContext delta1 $ prettyList (map prettyTCM vs) + , " types" <+> do escapeContext __IMPOSSIBLE__ (size delta) $ addContext delta1 $ prettyList (map prettyTCM as) + , "with function call" <+> prettyTCM v + , " context" <+> (prettyTCM =<< getContextTelescope) + , " delta" <+> do escapeContext __IMPOSSIBLE__ (size delta) $ prettyTCM delta + , " delta1" <+> do escapeContext __IMPOSSIBLE__ (size delta) $ prettyTCM delta1 + , " delta2" <+> do escapeContext __IMPOSSIBLE__ (size delta) $ addContext delta1 $ prettyTCM delta2 + , " body" <+> prettyTCM v + ] - return (Just v, WithFunction x aux t delta delta1 delta2 vs as t' ps npars perm' perm finalPerm cs) + return (Just v, WithFunction x aux t delta delta1 delta2 vtys t' ps npars perm' perm finalPerm cs) -- | Invoked in empty context. checkWithFunction :: [Name] -> WithFunctionProblem -> TCM () checkWithFunction _ NoWithFunction = return () -checkWithFunction cxtNames (WithFunction f aux t delta delta1 delta2 vs as b qs npars perm' perm finalPerm cs) = do +checkWithFunction cxtNames (WithFunction f aux t delta delta1 delta2 vtys b qs npars perm' perm finalPerm cs) = do let -- Δ₁ ws Δ₂ ⊢ withSub : Δ′ (where Δ′ is the context of the parent lhs) withSub :: Substitution - withSub = liftS (size delta2) (wkS (countWithArgs as) idS) `composeS` renaming __IMPOSSIBLE__ (reverseP perm') + withSub = let as = map (snd . whThing) vtys in + liftS (size delta2) (wkS (countWithArgs as) idS) + `composeS` renaming __IMPOSSIBLE__ (reverseP perm') reportSDoc "tc.with.top" 10 $ vcat [ "checkWithFunction" - , nest 2 $ vcat + , nest 2 $ vcat $ + let (vs, as) = unzipWith whThing vtys in [ "delta1 =" <+> prettyTCM delta1 , "delta2 =" <+> addContext delta1 (prettyTCM delta2) , "t =" <+> prettyTCM t @@ -951,7 +1039,7 @@ -- but module application is sloppy. -- We normalise to get rid of Def's coming -- from module applications. - (withFunType, n) <- withFunctionType delta1 vs as delta2 b + (withFunType, n) <- withFunctionType delta1 vtys delta2 b reportSDoc "tc.with.type" 10 $ sep [ "with-function type:", nest 2 $ prettyTCM withFunType ] reportSDoc "tc.with.type" 50 $ sep [ "with-function type:", nest 2 $ pretty withFunType ] @@ -963,7 +1051,7 @@ checkType withFunType -- With display forms are closed - df <- safeInTopContext $ makeOpen =<< withDisplayForm f aux delta1 delta2 n qs perm' perm + df <- inTopContext $ makeOpen =<< withDisplayForm f aux delta1 delta2 n qs perm' perm reportSLn "tc.with.top" 20 "created with display form" @@ -1063,5 +1151,8 @@ withCurrentModule m cont -- | Set the current clause number. -atClause :: QName -> Int -> A.RHS -> TCM a -> TCM a -atClause name i rhs = localTC $ \ e -> e { envClause = IPClause name i rhs } + +atClause :: QName -> Int -> Type -> Maybe Substitution -> A.SpineClause -> TCM a -> TCM a +atClause name i t sub cl ret = do + clo <- buildClosure () + localTC (\ e -> e { envClause = IPClause name i t sub cl clo [] }) ret diff --git a/src/full/Agda/TypeChecking/Rules/Def.hs-boot b/src/full/Agda/TypeChecking/Rules/Def.hs-boot --- a/src/full/Agda/TypeChecking/Rules/Def.hs-boot +++ b/src/full/Agda/TypeChecking/Rules/Def.hs-boot @@ -2,7 +2,6 @@ import Agda.Syntax.Abstract as A import Agda.Syntax.Common -import Agda.Syntax.Info import Agda.TypeChecking.Monad import qualified Agda.Syntax.Internal as I diff --git a/src/full/Agda/TypeChecking/Rules/Display.hs b/src/full/Agda/TypeChecking/Rules/Display.hs --- a/src/full/Agda/TypeChecking/Rules/Display.hs +++ b/src/full/Agda/TypeChecking/Rules/Display.hs @@ -1,8 +1,9 @@ module Agda.TypeChecking.Rules.Display (checkDisplayPragma) where +import Data.List.NonEmpty (NonEmpty(..)) +import qualified Data.List.NonEmpty as NonEmpty import Data.Maybe -import qualified Data.List as List import qualified Agda.Syntax.Abstract as A import Agda.Syntax.Abstract.Views @@ -14,7 +15,7 @@ import Agda.TypeChecking.Telescope import Agda.TypeChecking.Pretty -import Agda.Utils.NonemptyList +import Agda.Utils.Impossible checkDisplayPragma :: QName -> [NamedArg A.Pattern] -> A.Expr -> TCM () checkDisplayPragma f ps e = do @@ -26,26 +27,26 @@ reportSLn "tc.display.pragma" 20 $ "Adding display form for " ++ show f ++ "\n " ++ show df addDisplayForm f df --- Compute a left-hand side for a display form. Inserts implicits, but no type --- checking so does the wrong thing if implicitness is computed. Binds variables. -displayLHS :: Telescope -> [NamedArg A.Pattern] -> (Int -> [Term] -> TCM a) -> TCM a -displayLHS tel ps ret = patternsToTerms tel ps $ \n vs -> ret n (map unArg vs) +--UNUSED Liang-Ting 2019-07-16 +---- Compute a left-hand side for a display form. Inserts implicits, but no type +---- checking so does the wrong thing if implicitness is computed. Binds variables. +--displayLHS :: Telescope -> [NamedArg A.Pattern] -> (Int -> [Term] -> TCM a) -> TCM a +--displayLHS tel ps ret = patternsToTerms tel ps $ \n vs -> ret n (map unArg vs) patternsToTerms :: Telescope -> [NamedArg A.Pattern] -> (Int -> Args -> TCM a) -> TCM a patternsToTerms _ [] ret = ret 0 [] patternsToTerms EmptyTel (p : ps) ret = patternToTerm (namedArg p) $ \n v -> patternsToTerms EmptyTel ps $ \m vs -> ret (n + m) (inheritHiding p v : vs) -patternsToTerms (ExtendTel a tel) (p : ps) ret = do - let isMatch = sameHiding p a && - (visible p || isNothing (nameOf (unArg p)) || - Just (absName tel) == (rangedThing <$> nameOf (unArg p))) - case isMatch of - True -> +patternsToTerms (ExtendTel a tel) (p : ps) ret + -- Andreas, 2019-07-22, while #3353: we should use domName, not absName !! + -- WAS: -- | sameHiding p a, visible p || maybe True (absName tel ==) (bareNameOf p) = -- no ArgName or same as p + | fromMaybe __IMPOSSIBLE__ $ fittingNamedArg p a = patternToTerm (namedArg p) $ \n v -> patternsToTerms (unAbs tel) ps $ \m vs -> ret (n + m) (inheritHiding p v : vs) - False -> - bindWild $ patternsToTerms (unAbs tel) (p : ps) $ \n vs -> ret (1 + n) (inheritHiding a (Var 0 []) : vs) + | otherwise = + bindWild $ patternsToTerms (unAbs tel) (p : ps) $ \n vs -> + ret (1 + n) (inheritHiding a (Var 0 []) : vs) inheritHiding :: LensHiding a => a -> b -> Arg b inheritHiding a b = setHiding (getHiding a) (defaultArg b) @@ -67,7 +68,7 @@ patternToTerm :: A.Pattern -> (Nat -> Term -> TCM a) -> TCM a patternToTerm p ret = case p of - A.VarP (A.BindName x) -> bindVar x $ ret 1 (Var 0 []) + A.VarP A.BindName{unBind = x} -> bindVar x $ ret 1 (Var 0 []) A.ConP _ cs ps | Just c <- getUnambiguous cs -> pappToTerm c (Con (ConHead c Inductive []) ConOCon . map Apply) ps ret | otherwise -> ambigErr "constructor" cs @@ -86,7 +87,7 @@ ambigErr thing (AmbQ xs) = genericDocError =<< do text ("Ambiguous " ++ thing ++ ":") - fsep (punctuate comma (map pshow $ toList xs)) + fsep (punctuate comma (map pshow $ NonEmpty.toList xs)) bindWild :: TCM a -> TCM a bindWild ret = do diff --git a/src/full/Agda/TypeChecking/Rules/LHS.hs b/src/full/Agda/TypeChecking/Rules/LHS.hs --- a/src/full/Agda/TypeChecking/Rules/LHS.hs +++ b/src/full/Agda/TypeChecking/Rules/LHS.hs @@ -1,5 +1,3 @@ -{-# LANGUAGE CPP #-} -{-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE NondecreasingIndentation #-} module Agda.TypeChecking.Rules.LHS @@ -10,26 +8,25 @@ , checkSortOfSplitVar ) where -#if MIN_VERSION_base(4,11,0) -import Prelude hiding ( (<>), mapM, null, sequence ) -#else import Prelude hiding ( mapM, null, sequence ) -#endif import Data.Maybe import Control.Arrow (left) import Control.Monad import Control.Monad.Reader -import Control.Monad.State import Control.Monad.Writer hiding ((<>)) import Control.Monad.Trans.Maybe import Data.Either (partitionEithers) import Data.IntMap (IntMap) import qualified Data.IntMap as IntMap -import Data.List (delete, sortBy, stripPrefix, (\\), findIndex) +import Data.IntSet (IntSet) +import qualified Data.IntSet as IntSet +import Data.List (findIndex) import qualified Data.List as List +import Data.List.NonEmpty (NonEmpty(..)) +import qualified Data.List.NonEmpty as NonEmpty import Data.Monoid ( Monoid, mempty, mappend ) import Data.Semigroup ( Semigroup ) import qualified Data.Semigroup as Semigroup @@ -45,14 +42,13 @@ import Agda.Syntax.Abstract (IsProjP(..)) import qualified Agda.Syntax.Abstract as A import Agda.Syntax.Abstract.Views (asView, deepUnscope) -import Agda.Syntax.Concrete (FieldAssignment'(..),NameInScope(..),LensInScope(..)) +import Agda.Syntax.Concrete (FieldAssignment'(..),LensInScope(..)) import Agda.Syntax.Common as Common import Agda.Syntax.Info as A import Agda.Syntax.Literal import Agda.Syntax.Position import Agda.TypeChecking.Monad -import Agda.TypeChecking.Monad.Builtin (litType, constructorForm) import qualified Agda.TypeChecking.Monad.Benchmark as Bench import Agda.TypeChecking.Conversion @@ -61,7 +57,11 @@ import Agda.TypeChecking.Datatypes hiding (isDataOrRecordType) import Agda.TypeChecking.Errors (dropTopLevelModule) import Agda.TypeChecking.Irrelevance -import {-# SOURCE #-} Agda.TypeChecking.Empty +-- Prevent "Ambiguous occurrence ‘DontKnow’" when loading with ghci. +-- (DontKnow is one of the constructors of ErrorNonEmpty *and* UnifactionResult'). +-- We can't explicitly hide just the constructor here because it isn't in the +-- hs-boot file. +import {-# SOURCE #-} Agda.TypeChecking.Empty (ensureEmptyType) import Agda.TypeChecking.Forcing import Agda.TypeChecking.Patterns.Abstract import Agda.TypeChecking.Pretty @@ -86,21 +86,20 @@ import Agda.Utils.List import Agda.Utils.Maybe import Agda.Utils.Monad -import Agda.Utils.NonemptyList import Agda.Utils.Null import Agda.Utils.Pretty (prettyShow) import Agda.Utils.Singleton import Agda.Utils.Size +import Agda.Utils.Tuple -#include "undefined.h" import Agda.Utils.Impossible - --- | Compute the set of flexible patterns in a list of patterns. The result is --- the deBruijn indices of the flexible patterns. -flexiblePatterns :: [NamedArg A.Pattern] -> TCM FlexibleVars -flexiblePatterns nps = do - forMaybeM (zip (downFrom $ length nps) nps) $ \ (i, Arg ai p) -> do - runMaybeT $ (\ f -> FlexibleVar (getHiding ai) (getOrigin ai) f (Just i) i) <$> maybeFlexiblePattern p +--UNUSED Liang-Ting Chen 2019-07-16 +---- | Compute the set of flexible patterns in a list of patterns. The result is +---- the deBruijn indices of the flexible patterns. +--flexiblePatterns :: [NamedArg A.Pattern] -> TCM FlexibleVars +--flexiblePatterns nps = do +-- forMaybeM (zip (downFrom $ length nps) nps) $ \ (i, Arg ai p) -> do +-- runMaybeT $ (\ f -> FlexibleVar (getHiding ai) (getOrigin ai) f (Just i) i) <$> maybeFlexiblePattern p -- | A pattern is flexible if it is dotted or implicit, or a record pattern -- with only flexible subpatterns. @@ -137,8 +136,8 @@ case p of I.DotP{} -> return DotFlex I.ConP _ i ps - | Just PatOSystem <- conPRecord i -> return ImplicitFlex -- expanded from ImplicitP - | Just _ <- conPRecord i -> maybeFlexiblePattern ps + | conPRecord i , PatOSystem <- patOrigin (conPInfo i) -> return ImplicitFlex -- expanded from ImplicitP + | conPRecord i -> maybeFlexiblePattern ps | otherwise -> mzero I.VarP{} -> mzero I.LitP{} -> mzero @@ -156,6 +155,18 @@ instance IsFlexiblePattern a => IsFlexiblePattern (Common.Named name a) where maybeFlexiblePattern = maybeFlexiblePattern . namedThing +-- | Update the given LHS state: +-- 1. simplify problem equations +-- 2. rename telescope variables +-- 3. introduce trailing patterns +updateLHSState :: LHSState a -> TCM (LHSState a) +updateLHSState st = do + let tel = st ^. lhsTel + problem = st ^. lhsProblem + eqs' <- addContext tel $ updateProblemEqs $ problem ^. problemEqs + tel' <- useNamesFromProblemEqs eqs' tel + updateProblemRest $ set lhsTel tel' $ set (lhsProblem . problemEqs) eqs' st + -- | Update the user patterns in the given problem, simplifying equations -- between constructors where possible. updateProblemEqs @@ -183,6 +194,9 @@ update :: ProblemEq -> TCM [ProblemEq] update eq@(ProblemEq A.WildP{} _ _) = return [] update eq@(ProblemEq p@A.ProjP{} _ _) = typeError $ IllformedProjectionPattern p + update eq@(ProblemEq p@(A.AsP info x p') v a) = + (ProblemEq (A.VarP x) v a :) <$> update (ProblemEq p' v a) + update eq@(ProblemEq p v a) = reduce v >>= constructorForm >>= \case Con c ci es -> do let vs = fromMaybe __IMPOSSIBLE__ $ allApplyElims es @@ -194,8 +208,7 @@ p <- expandLitPattern p case p of - A.AsP info x p' -> - (ProblemEq (A.VarP x) v a :) <$> update (ProblemEq p' v a) + A.AsP{} -> __IMPOSSIBLE__ A.ConP cpi ambC ps -> do (c',_) <- disambiguateConstructor ambC d pars @@ -233,7 +246,7 @@ updates $ zipWith3 ProblemEq (map namedArg ps) (map unArg vs) bs A.RecP pi fs -> do - axs <- recFields . theDef <$> getConstInfo d + axs <- map argFromDom . recFields . theDef <$> getConstInfo d -- Andreas, 2018-09-06, issue #3122. -- Associate the concrete record field names used in the record pattern @@ -306,13 +319,9 @@ -- -- Precondition: The problem has to be solved. -noShadowingOfConstructors - :: Call -- ^ Trace, e.g., @CheckPatternShadowing clause@ - -> [ProblemEq] -> TCM () -noShadowingOfConstructors mkCall eqs = - traceCall mkCall $ mapM_ noShadowing eqs - where - noShadowing (ProblemEq p _ (Dom{domInfo = info, unDom = El _ a})) = case snd $ asView p of +noShadowingOfConstructors :: ProblemEq -> TCM () +noShadowingOfConstructors (ProblemEq p _ (Dom{domInfo = info, unDom = El _ a})) = + case snd $ asView p of A.WildP {} -> return () A.AbsurdP {} -> return () A.DotP {} -> return () @@ -329,7 +338,7 @@ -- Due to parameter refinement, there can be (invisible) variable patterns from module -- parameters that shadow constructors. -- Thus, only complain about user written variable that shadow constructors. - A.VarP (A.BindName x) -> when (getOrigin info == UserWritten) $ do + A.VarP A.BindName{unBind = x} -> when (getOrigin info == UserWritten) $ do reportSDoc "tc.lhs.shadow" 30 $ vcat [ text $ "checking whether pattern variable " ++ prettyShow x ++ " shadows a constructor" , nest 2 $ "type of variable =" <+> prettyTCM a @@ -374,7 +383,7 @@ Level {} -> __IMPOSSIBLE__ Con {} -> __IMPOSSIBLE__ DontCare{} -> __IMPOSSIBLE__ - Dummy s -> __IMPOSSIBLE_VERBOSE__ s + Dummy s _ -> __IMPOSSIBLE_VERBOSE__ s -- | Check that a dot pattern matches it's instantiation. checkDotPattern :: DotPattern -> TCM () @@ -394,74 +403,11 @@ , nest 2 $ pretty u , nest 2 $ pretty v ] - -- Should be ok to do noConstraints here - noConstraints $ equalTerm a u v + equalTerm a u v checkAbsurdPattern :: AbsurdPattern -> TCM () checkAbsurdPattern (Absurd r a) = ensureEmptyType r a -data LeftoverPatterns = LeftoverPatterns - { patternVariables :: IntMap [A.Name] - , asPatterns :: [AsBinding] - , dotPatterns :: [DotPattern] - , absurdPatterns :: [AbsurdPattern] - , otherPatterns :: [A.Pattern] - } - -instance Semigroup LeftoverPatterns where - x <> y = LeftoverPatterns - { patternVariables = IntMap.unionWith (++) (patternVariables x) (patternVariables y) - , asPatterns = asPatterns x ++ asPatterns y - , dotPatterns = dotPatterns x ++ dotPatterns y - , absurdPatterns = absurdPatterns x ++ absurdPatterns y - , otherPatterns = otherPatterns x ++ otherPatterns y - } - -instance Monoid LeftoverPatterns where - mempty = LeftoverPatterns empty [] [] [] [] - mappend = (Semigroup.<>) - --- | Classify remaining patterns after splitting is complete into pattern --- variables, as patterns, dot patterns, and absurd patterns. --- Precondition: there are no more constructor patterns. -getLeftoverPatterns :: [ProblemEq] -> TCM LeftoverPatterns -getLeftoverPatterns eqs = do - reportSDoc "tc.lhs.top" 30 $ "classifying leftover patterns" - mconcat <$> mapM getLeftoverPattern eqs - where - patternVariable x i = LeftoverPatterns (singleton (i,[x])) [] [] [] [] - asPattern x v a = LeftoverPatterns empty [AsB x v (unDom a)] [] [] [] - dotPattern e v a = LeftoverPatterns empty [] [Dot e v a] [] [] - absurdPattern info a = LeftoverPatterns empty [] [] [Absurd info a] [] - otherPattern p = LeftoverPatterns empty [] [] [] [p] - - getLeftoverPattern :: ProblemEq -> TCM LeftoverPatterns - getLeftoverPattern (ProblemEq p v a) = case p of - (A.VarP (A.BindName x)) -> isEtaVar v (unDom a) >>= \case - Just i -> return $ patternVariable x i - Nothing -> return $ asPattern x v a - (A.WildP _) -> return mempty - (A.AsP info (A.BindName x) p) -> (asPattern x v a `mappend`) <$> do - getLeftoverPattern $ ProblemEq p v a - (A.DotP info e) -> return $ dotPattern e v a - (A.AbsurdP info) -> return $ absurdPattern (getRange info) (unDom a) - _ -> return $ otherPattern p - --- | Build a renaming for the internal patterns using variable names from --- the user patterns. If there are multiple user names for the same internal --- variable, the unused ones are returned as as-bindings. -getUserVariableNames :: Telescope -> IntMap [A.Name] - -> ([Maybe A.Name], [AsBinding]) -getUserVariableNames tel names = runWriter $ - zipWithM makeVar (flattenTel tel) (downFrom $ size tel) - - where - makeVar :: Dom Type -> Int -> Writer [AsBinding] (Maybe A.Name) - makeVar a i | Just (x:xs) <- IntMap.lookup i names = do - tell $ map (\y -> AsB y (var i) (unDom a)) xs - return $ Just x - makeVar a i = return Nothing - -- | After splitting is complete, we transfer the origins -- We also transfer the locations of absurd patterns, since these haven't -- been introduced yet in the internal pattern. @@ -488,49 +434,52 @@ transfers (p : ps) [] = __IMPOSSIBLE__ transfers (p : ps) (q : qs) | matchingArgs p q = do - q' <- setOrigin (getOrigin p) <$> - (traverse $ traverse $ transfer $ namedArg p) q + q' <- mapNameOf (maybe id (const . Just) $ getNameOf p) -- take NamedName from p if present + . setOrigin (getOrigin p) + <$> (traverse $ traverse $ transfer $ namedArg p) q (q' :) <$> transfers ps qs | otherwise = (setOrigin Inserted q :) <$> transfers (p : ps) qs transfer :: A.Pattern -> DeBruijnPattern -> TCM DeBruijnPattern - transfer p q = case (snd (asView p) , q) of + transfer p q = case (asView p , q) of - (A.ConP pi _ ps , ConP c (ConPatternInfo mo ft mb l) qs) -> do - let cpi = ConPatternInfo (mo $> PatOCon) ft mb l + ((asB , A.ConP pi _ ps) , ConP c (ConPatternInfo i r ft mb l) qs) -> do + let cpi = ConPatternInfo (PatternInfo PatOCon asB) r ft mb l ConP c cpi <$> transfers ps qs - (A.RecP pi fs , ConP c (ConPatternInfo mo ft mb l) qs) -> do + ((asB , A.RecP pi fs) , ConP c (ConPatternInfo i r ft mb l) qs) -> do let Def d _ = unEl $ unArg $ fromMaybe __IMPOSSIBLE__ mb axs = map (nameConcrete . qnameName . unArg) (conFields c) `withArgsFrom` qs - cpi = ConPatternInfo (mo $> PatORec) ft mb l + cpi = ConPatternInfo (PatternInfo PatORec asB) r ft mb l ps <- insertMissingFields d (const $ A.WildP patNoRange) fs axs ConP c cpi <$> transfers ps qs - (p , ConP c (ConPatternInfo mo ft mb l) qs) -> do - let cpi = ConPatternInfo (mo $> patOrigin p) ft mb l + ((asB , p) , ConP c (ConPatternInfo i r ft mb l) qs) -> do + let cpi = ConPatternInfo (PatternInfo (patOrig p) asB) r ft mb l return $ ConP c cpi qs - (p , VarP _ x) -> return $ VarP (patOrigin p) x + ((asB , p) , VarP _ x) -> return $ VarP (PatternInfo (patOrig p) asB) x - (p , DotP _ u) -> return $ DotP (patOrigin p) u + ((asB , p) , DotP _ u) -> return $ DotP (PatternInfo (patOrig p) asB) u + ((asB , p) , LitP _ l) -> return $ LitP (PatternInfo (patOrig p) asB) l + _ -> return q - patOrigin :: A.Pattern -> PatOrigin - patOrigin (A.VarP x) = PatOVar (A.unBind x) - patOrigin A.DotP{} = PatODot - patOrigin A.ConP{} = PatOCon - patOrigin A.RecP{} = PatORec - patOrigin A.WildP{} = PatOWild - patOrigin A.AbsurdP{} = PatOAbsurd - patOrigin A.LitP{} = PatOLit - patOrigin A.EqualP{} = PatOCon --TODO: origin for EqualP - patOrigin A.AsP{} = __IMPOSSIBLE__ - patOrigin A.ProjP{} = __IMPOSSIBLE__ - patOrigin A.DefP{} = __IMPOSSIBLE__ - patOrigin A.PatternSynP{} = __IMPOSSIBLE__ - patOrigin A.WithP{} = __IMPOSSIBLE__ + patOrig :: A.Pattern -> PatOrigin + patOrig (A.VarP x) = PatOVar (A.unBind x) + patOrig A.DotP{} = PatODot + patOrig A.ConP{} = PatOCon + patOrig A.RecP{} = PatORec + patOrig A.WildP{} = PatOWild + patOrig A.AbsurdP{} = PatOAbsurd + patOrig A.LitP{} = PatOLit + patOrig A.EqualP{} = PatOCon --TODO: origin for EqualP + patOrig A.AsP{} = __IMPOSSIBLE__ + patOrig A.ProjP{} = __IMPOSSIBLE__ + patOrig A.DefP{} = __IMPOSSIBLE__ + patOrig A.PatternSynP{} = __IMPOSSIBLE__ + patOrig A.WithP{} = __IMPOSSIBLE__ matchingArgs :: NamedArg A.Pattern -> NamedArg DeBruijnPattern -> Bool matchingArgs p q @@ -540,9 +489,9 @@ -- 2. or they are both visible, | visible p && visible q = True -- 3. or they have the same hiding and the argument is not named, - | sameHiding p q && isNothing (nameOf (unArg p)) = True + | sameHiding p q && isNothing (getNameOf p) = True -- 4. or they have the same hiding and the same name. - | sameHiding p q && nameOf (unArg p) == nameOf (unArg q) = True + | sameHiding p q && namedSame p q = True -- Otherwise this argument was inserted by the typechecker. | otherwise = False @@ -566,10 +515,9 @@ ] case p of A.VarP x -> do - verboseS "tc.lhs.linear" 60 $ do + reportSLn "tc.lhs.linear" 60 $ let y = A.unBind x - reportSLn "tc.lhs.linear" 60 $ - "pattern variable " ++ show (A.nameConcrete y) ++ " with id " ++ show (A.nameId y) + in "pattern variable " ++ show (A.nameConcrete y) ++ " with id " ++ show (A.nameId y) case Map.lookup x vars of Just v -> do noConstraints $ equalTerm (unDom a) u v @@ -625,7 +573,7 @@ -- | Since with-abstraction can change the type of a variable, we have to -- recheck the stripped with patterns when checking a with function. recheckStrippedWithPattern :: ProblemEq -> TCM () -recheckStrippedWithPattern (ProblemEq p v a) = checkInternal v (unDom a) +recheckStrippedWithPattern (ProblemEq p v a) = checkInternal v CmpLeq (unDom a) `catchError` \_ -> typeError . GenericDocError =<< vcat [ "Ill-typed pattern after with abstraction: " <+> prettyA p , "(perhaps you can replace it by `_`?)" @@ -655,7 +603,7 @@ -- ^ As-bindings from the left-hand side. Return instead of bound since we -- want them in where's and right-hand sides, but not in with-clauses -- (Issue 2303). - , lhsPartialSplit :: [Int] + , lhsPartialSplit :: IntSet -- ^ have we done a partial split? } @@ -677,7 +625,7 @@ checkLeftHandSide :: forall a. Call - -- ^ Trace, e.g. @CheckPatternShadowing clause@ + -- ^ Trace, e.g. 'CheckLHS' or 'CheckPattern'. -> Maybe QName -- ^ The name of the definition we are checking. -> [NamedArg A.Pattern] @@ -692,14 +640,16 @@ -> (LHSResult -> TCM a) -- ^ Continuation. -> TCM a -checkLeftHandSide c f ps a withSub' strippedPats = Bench.billToCPS [Bench.Typing, Bench.CheckLHS] $ \ ret -> do +checkLeftHandSide call f ps a withSub' strippedPats = + Bench.billToCPS [Bench.Typing, Bench.CheckLHS] $ + traceCallCPS call $ \ ret -> do -- To allow module parameters to be refined by matching, we're adding the -- context arguments as wildcard patterns and extending the type with the -- context telescope. cxt <- map (setOrigin Inserted) . reverse <$> getContext let tel = telFromList' prettyShow cxt - cps = [ unnamed . A.VarP . A.BindName . fst <$> argFromDom d + cps = [ unnamed . A.VarP . A.mkBindName . fst <$> argFromDom d | d <- cxt ] eqs0 = zipWith3 ProblemEq (map namedArg cps) (map var $ downFrom $ size tel) (flattenTel tel) @@ -708,19 +658,14 @@ reportSDoc "tc.lhs.top" 20 $ vcat [ "lhs: final checks with remaining equations" - , nest 2 $ if null eqs then "(none)" else vcat $ map prettyTCM eqs + , nest 2 $ if null eqs then "(none)" else addContext delta $ vcat $ map prettyTCM eqs , "qs0 =" <+> addContext delta (prettyTCMPatternList qs0) ] unless (null rps) __IMPOSSIBLE__ - -- Update modalities of delta to match the modalities of the variables - -- after the forcing translation. We can't perform the forcing translation - -- yet, since that would mess with with-clause stripping. - delta <- forceTranslateTelescope delta qs0 - addContext delta $ do - noShadowingOfConstructors c eqs + mapM_ noShadowingOfConstructors eqs noPatternMatchingOnCodata qs0 -- Compute substitution from the out patterns @qs0@ @@ -769,9 +714,12 @@ eqs <- addContext delta $ checkPatternLinearity eqs - LeftoverPatterns patVars asb0 dots absurds otherPats + leftovers@(LeftoverPatterns patVars asb0 dots absurds otherPats) <- addContext delta $ getLeftoverPatterns eqs + reportSDoc "tc.lhs.leftover" 30 $ vcat + [ "leftover patterns: " , nest 2 (addContext delta $ prettyTCM leftovers) ] + unless (null otherPats) __IMPOSSIBLE__ -- Get the user-written names for the pattern variables @@ -786,7 +734,7 @@ let hasAbsurd = not . null $ absurds - let lhsResult = LHSResult (length cxt) delta qs hasAbsurd b patSub asb (catMaybes psplit) + let lhsResult = LHSResult (length cxt) delta qs hasAbsurd b patSub asb (IntSet.fromList $ catMaybes psplit) -- Debug output reportSDoc "tc.lhs.top" 10 $ @@ -839,11 +787,10 @@ let st = over (lhsProblem . problemEqs) (++ withEqs) st0 -- doing the splits: - (result, block) <- inTopContext $ runWriterT $ (`runReaderT` (size cxt)) $ checkLHS f st + (result, block) <- unsafeInTopContext $ runWriterT $ (`runReaderT` (size cxt)) $ checkLHS f st return result --- | Determine in which order the splits should be tried by --- reordering/inserting/dropping the problem equations. +-- | Determine which splits should be tried. splitStrategy :: [ProblemEq] -> [ProblemEq] splitStrategy = filter shouldSplit where @@ -868,14 +815,14 @@ -- | The loop (tail-recursive): split at a variable in the problem until problem is solved checkLHS - :: forall tcm a. (MonadTCM tcm, MonadReduce tcm, MonadWriter Blocked_ tcm, HasConstInfo tcm, MonadError TCErr tcm, MonadDebug tcm, MonadReader Nat tcm) + :: forall tcm a. (MonadTCM tcm, MonadReduce tcm, MonadAddContext tcm, MonadWriter Blocked_ tcm, HasConstInfo tcm, MonadError TCErr tcm, MonadDebug tcm, MonadReader Nat tcm) => Maybe QName -- ^ The name of the definition we are checking. -> LHSState a -- ^ The current state. -> tcm a -checkLHS mf = updateRelevance checkLHS_ where +checkLHS mf = updateModality checkLHS_ where -- If the target type is irrelevant or in Prop, -- we need to check the lhs in irr. cxt. (see Issue 939). - updateRelevance cont st@(LHSState tel ip problem target psplit) = do + updateModality cont st@(LHSState tel ip problem target psplit) = do let m = getModality target applyModalityToContext m $ do cont $ over (lhsTel . listTel) (map $ inverseApplyModality m) st @@ -887,6 +834,10 @@ if isSolvedProblem problem then liftTCM $ (problem ^. problemCont) st else do + + reportSDoc "tc.lhs.top" 30 $ vcat + [ "LHS state: " , nest 2 (prettyTCM st) ] + unlessM (optPatternMatching <$> getsTC getPragmaOptions) $ unless (problemAllVariables problem) $ typeError $ GenericError $ "Pattern matching is disabled" @@ -984,7 +935,7 @@ ip' = ip ++ [projP] -- drop the projection pattern (already splitted) problem' = over problemRestPats tail problem - liftTCM $ updateProblemRest (LHSState tel ip' problem' target' psplit) + liftTCM $ updateLHSState (LHSState tel ip' problem' target' psplit) -- | Split a Partial. @@ -1044,7 +995,8 @@ -> ExceptT TCErr tcm (LHSState a) splitPartial delta1 dom adelta2 ts = do - unless (domFinite dom) $ softTypeError $ GenericError $ "Not a finite domain: " ++ show dom + unless (domFinite dom) $ liftTCM $ softTypeError . GenericDocError =<< + hsep [ "Not a finite domain:" , prettyTCM $ unDom dom ] tInterval <- liftTCM $ elInf primInterval @@ -1128,11 +1080,11 @@ = ConP c (noConPatternInfo { conPType = Just (Arg defaultArgInfo tInterval) , conPFallThrough = True }) [] - mkConP (Var i []) = VarP PatOSystem (DBPatVar "x" i) + mkConP (Var i []) = VarP defaultPatternInfo (DBPatVar "x" i) mkConP _ = __IMPOSSIBLE__ rho0 = fmap mkConP sigma - rho = liftS (size delta2) $ consS (DotP PatOSystem itisone) rho0 + rho = liftS (size delta2) $ consS (DotP defaultPatternInfo itisone) rho0 delta' = abstract gamma delta2 eqs' = applyPatSubst rho $ problem ^. problemEqs @@ -1140,10 +1092,9 @@ target' = applyPatSubst rho target -- Compute the new state - eqs' <- liftTCM $ addContext delta' $ updateProblemEqs eqs' let problem' = set problemEqs eqs' problem reportSDoc "tc.lhs.split.partial" 60 $ text (show problem') - liftTCM $ updateProblemRest (LHSState delta' ip' problem' target' (psplit ++ [Just o_n])) + liftTCM $ updateLHSState (LHSState delta' ip' problem' target' (psplit ++ [Just o_n])) splitLit :: Telescope -- ^ The types of arguments before the one we split on @@ -1154,7 +1105,7 @@ splitLit delta1 dom@Dom{domInfo = info, unDom = a} adelta2 lit = do let delta2 = absApp adelta2 (Lit lit) delta' = abstract delta1 delta2 - rho = singletonS (size delta2) (LitP lit) + rho = singletonS (size delta2) (litP lit) -- Andreas, 2015-06-13 Literals are closed, so no need to raise them! -- rho = liftS (size delta2) $ singletonS 0 (Lit lit) -- rho = [ var i | i <- [0..size delta2 - 1] ] @@ -1173,15 +1124,16 @@ -- -- Thus, no checking of (usableQuantity info) here. + unlessM (splittableCohesion info) $ + addContext delta1 $ softTypeError $ SplitOnUnusableCohesion dom -- check that a is indeed the type of lit (otherwise fail softly) -- if not, fail softly since it could be instantiated by a later split. suspendErrors $ equalType a =<< litType lit -- Compute the new state - eqs' <- liftTCM $ addContext delta' $ updateProblemEqs eqs' let problem' = set problemEqs eqs' problem - liftTCM $ updateProblemRest (LHSState delta' ip' problem' target' psplit) + liftTCM $ updateLHSState (LHSState delta' ip' problem' target' psplit) splitCon :: Telescope -- ^ The types of arguments before the one we split on @@ -1198,6 +1150,7 @@ [ "checking lhs" , nest 2 $ "tel =" <+> prettyTCM tel , nest 2 $ "rel =" <+> (text $ show $ getRelevance info) + , nest 2 $ "mod =" <+> (text $ show $ getModality info) ] reportSDoc "tc.lhs.split" 15 $ vcat @@ -1220,6 +1173,9 @@ -- -- Thus, no checking of (usableQuantity info) here. + unlessM (splittableCohesion info) $ + addContext delta1 $ softTypeError $ SplitOnUnusableCohesion dom + -- We should be at a data/record type (dr, d, pars, ixs) <- addContext delta1 $ isDataOrRecordType a @@ -1230,10 +1186,10 @@ Just ambC -> disambiguateConstructor ambC d pars Nothing -> getRecordConstructor d pars a - -- Don't split on lazy constructor + -- Don't split on lazy (non-eta) constructor case focusPat of - A.ConP cpi _ _ | patLazy cpi == ConPatLazy -> softTypeError $ - ForcedConstructorNotInstantiated focusPat + A.ConP cpi _ _ | conPatLazy cpi == ConPatLazy -> + unlessM (isEtaRecord d) $ softTypeError $ ForcedConstructorNotInstantiated focusPat _ -> return () -- The type of the constructor will end in an application of the datatype @@ -1252,7 +1208,7 @@ ps <- insertImplicitPatterns ExpandLast ps gamma return $ useNamesFromPattern ps gamma A.RecP _ fs -> do - axs <- recordFieldNames . theDef <$> getConstInfo d + axs <- map argFromDom . recordFieldNames . theDef <$> getConstInfo d ps <- insertMissingFields d (const $ A.WildP patNoRange) fs axs ps <- insertImplicitPatterns ExpandLast ps gamma return $ useNamesFromPattern ps gamma @@ -1278,13 +1234,19 @@ , "cixs =" <+> addContext gamma (brackets (fsep $ punctuate comma $ map prettyTCM cixs)) ] ] + -- We ignore forcing for make-case + cforced <- ifM (viewTC eMakeCase) (return []) $ + {-else-} defForced <$> getConstInfo (conName c) let delta1Gamma = delta1 `abstract` gamma da' = raise (size gamma) da ixs' = raise (size gamma) ixs + -- Variables in Δ₁ are not forced, since the unifier takes care to not introduce forced + -- variables. + forced = replicate (size delta1) NotForced ++ cforced -- All variables are flexible. - let flex = allFlexVars $ delta1Gamma + let flex = allFlexVars forced $ delta1Gamma -- Unify constructor target and given type (in Δ₁Γ) -- Given: Δ₁ ⊢ D pars : Φ → Setᵢ @@ -1312,6 +1274,14 @@ -- from Δ' = Δ₁';Δ₂ρ₃ -- Δ' ⊢ ρ : Δ₁(x : D vs ws)Δ₂ + -- Andrea 2019-07-17 propagate the Cohesion to the equation telescope + -- TODO: should we propagate the modality in general? + -- See also Coverage checking. + da' <- do + let updCoh = composeCohesion (getCohesion info) + TelV tel dt <- telView da' + return $ abstract (mapCohesion updCoh <$> tel) a + liftTCM (unifyIndices delta1Gamma flex da' cixs ixs') >>= \case -- Mismatch. Report and abort. @@ -1345,10 +1315,11 @@ -- Also remember if we are a record pattern. isRec <- isRecord d - let cpi = ConPatternInfo { conPRecord = isRec $> PatOCon + let cpi = ConPatternInfo { conPInfo = PatternInfo PatOCon [] + , conPRecord = isJust isRec , conPFallThrough = False , conPType = Just $ Arg info a' - , conPLazy = False } + , conPLazy = False } -- Don't mark eta-record matches as lazy (#4254) -- compute final context and substitution let crho = ConP c cpi $ applySubst rho0 $ (telePatterns gamma boundary) @@ -1379,13 +1350,11 @@ -- Update the problem equations let eqs' = applyPatSubst rho $ problem ^. problemEqs - eqs' <- liftTCM $ addContext delta' $ updateProblemEqs eqs' - - let problem' = set problemEqs eqs' problem + problem' = set problemEqs eqs' problem -- if rest type reduces, -- extend the split problem by previously not considered patterns - st' <- liftTCM $ updateProblemRest $ LHSState delta' ip' problem' target' psplit + st' <- liftTCM $ updateLHSState $ LHSState delta' ip' problem' target' psplit reportSDoc "tc.lhs.top" 12 $ sep [ "new problem from rest" @@ -1432,7 +1401,7 @@ -- | A more direct implementation of the specification -- @softTypeError err == suspendErrors (typeError err)@ -softTypeError :: (MonadTCM m, MonadError TCErr m) => TypeError -> m a +softTypeError :: (ReadTCState m, MonadError TCErr m, MonadTCEnv m) => TypeError -> m a softTypeError err = throwError =<< typeError_ err -- | A convenient alias for @liftTCM . typeError@. Throws the error directly @@ -1445,7 +1414,7 @@ -- definition, parameters, and indices. Fails softly if the type could become -- a data/record type by instantiating a variable/metavariable, or fail hard -- otherwise. -isDataOrRecordType :: (MonadTCM m, MonadDebug m) +isDataOrRecordType :: (MonadTCM m, MonadDebug m, ReadTCState m) => Type -> ExceptT TCErr m (DataOrRecord, QName, Args, Args) isDataOrRecordType a = liftTCM (reduceB a) >>= \case @@ -1499,7 +1468,7 @@ Con{} -> __IMPOSSIBLE__ Level{} -> __IMPOSSIBLE__ DontCare{} -> __IMPOSSIBLE__ - Dummy s -> __IMPOSSIBLE_VERBOSE__ s + Dummy s _ -> __IMPOSSIBLE_VERBOSE__ s -- Type is blocked on a meta or something else: fail softly _ -> softTypeError =<< notData @@ -1539,47 +1508,42 @@ reportSDoc "tc.lhs.split" 20 $ sep [ text $ "we are of record type r = " ++ prettyShow r , text "applied to parameters vs = " <+> prettyTCM vs - , text $ "and have fields fs = " ++ prettyShow fs + , text $ "and have fields fs = " ++ prettyShow (map argFromDom fs) ] -- Try the projection candidates. - -- Note that tryProj wraps TCM in an ExceptT, collecting errors - -- instead of throwing them to the user immediately. -- First, we try to find a disambiguation that doesn't produce -- any new constraints. - disambiguations <- mapM (runExceptT . tryProj False fs r vs) ds - case partitionEithers $ toList disambiguations of - (_ , (d,a):_) -> do - -- From here, we have the correctly disambiguated projection. - -- For highlighting, we remember which name we disambiguated to. - -- This is safe here (fingers crossed) as we won't decide on a - -- different projection even if we backtrack and come here again. - liftTCM $ storeDisambiguatedName d - return (d,a) - (_ , [] ) -> do + tryDisambiguate False fs r vs $ \ _ -> -- If this fails, we try again with constraints, but we require -- the solution to be unique. - disambiguations <- mapM (runExceptT . tryProj True fs r vs) ds - case partitionEithers $ toList disambiguations of + tryDisambiguate True fs r vs $ \case ([] , [] ) -> __IMPOSSIBLE__ (err:_, [] ) -> throwError err - (errs , [(d,a)]) -> do - liftTCM $ storeDisambiguatedName d - return (d,a) - (errs , disambs@((d,a):_)) -> typeError . GenericDocError =<< vcat + (_ , disambs@((d,a):_)) -> typeError . GenericDocError =<< vcat [ "Ambiguous projection " <> prettyTCM d <> "." , "It could refer to any of" - , nest 2 $ vcat $ map showDisamb disambs + , nest 2 $ vcat $ map (prettyDisamb . fst) disambs ] _ -> __IMPOSSIBLE__ where - showDisamb (d,_) = - let r = head $ filter (noRange /=) $ map nameBindingSite $ reverse $ mnameToList $ qnameModule d - in (pretty =<< dropTopLevelModule d) <+> "(introduced at " <> prettyTCM r <> ")" + tryDisambiguate constraintsOk fs r vs failure = do + -- Note that tryProj wraps TCM in an ExceptT, collecting errors + -- instead of throwing them to the user immediately. + disambiguations <- mapM (runExceptT . tryProj constraintsOk fs r vs) ds + case partitionEithers $ NonEmpty.toList disambiguations of + (_ , (d,a) : disambs) | constraintsOk <= null disambs -> do + -- From here, we have the correctly disambiguated projection. + -- For highlighting, we remember which name we disambiguated to. + -- This is safe here (fingers crossed) as we won't decide on a + -- different projection even if we backtrack and come here again. + liftTCM $ storeDisambiguatedName d + return (d,a) + other -> failure other - notRecord = wrongProj $ headNe ds + notRecord = wrongProj $ NonEmpty.head ds - wrongProj :: (MonadTCM m, MonadError TCErr m) => QName -> m a + wrongProj :: (MonadTCM m, MonadError TCErr m, ReadTCState m) => QName -> m a wrongProj d = softTypeError =<< do liftTCM $ GenericDocError <$> sep [ "Cannot eliminate type " @@ -1591,14 +1555,14 @@ prettyTCM d ] - wrongHiding :: (MonadTCM m, MonadError TCErr m) => QName -> m a + wrongHiding :: (MonadTCM m, MonadError TCErr m, ReadTCState m) => QName -> m a wrongHiding d = softTypeError =<< do liftTCM $ GenericDocError <$> sep [ "Wrong hiding used for projection " , prettyTCM d ] tryProj :: Bool -- ^ Are we allowed to create new constraints? - -> [Arg QName] -- ^ Fields of record type under consideration. + -> [Dom QName] -- ^ Fields of record type under consideration. -> QName -- ^ Name of record type we are eliminating. -> Args -- ^ Parameters of record type we are eliminating. -> QName -- ^ Candidate projection. @@ -1627,12 +1591,13 @@ -- If the projection pattern name @d@ is not a field name, -- we have to try the next projection name. -- If this was not an ambiguous projection, that's an error. - argd <- maybe (wrongProj d) return $ List.find ((d ==) . unArg) fs + argd <- maybe (wrongProj d) return $ List.find ((d ==) . unDom) fs - let ai = setRelevance (getRelevance argd) $ projArgInfo proj + let ai = setModality (getModality argd) $ projArgInfo proj - reportSDoc "tc.lhs.split" 20 $ sep + reportSDoc "tc.lhs.split" 20 $ vcat [ text $ "original proj relevance = " ++ show (getRelevance argd) + , text $ "original proj quantity = " ++ show (getQuantity argd) ] -- Andreas, 2016-12-31, issue #2374: -- We can also disambiguate by hiding info. @@ -1666,32 +1631,54 @@ def@Record{} -> return $ [conName $ recConHead def] _ -> __IMPOSSIBLE__ - disambiguations <- mapM (runExceptT . tryCon False cons d pars) cs -- TODO: be more lazy - case partitionEithers $ toList disambiguations of - (_ , (c0,c,a):_) -> do - -- If constructor pattern was ambiguous, - -- remember our choice for highlighting info. - when (isAmbiguous ambC) $ liftTCM $ storeDisambiguatedName c0 - return (c,a) - (_ , [] ) -> do - disambiguations <- mapM (runExceptT . tryCon True cons d pars) cs - case partitionEithers $ toList disambiguations of + -- First, try do disambiguate with noConstraints, + -- if that fails, try again allowing constraint generation. + tryDisambiguate False cons d $ \ _ -> + tryDisambiguate True cons d $ \case ([] , [] ) -> __IMPOSSIBLE__ (err:_, [] ) -> throwError err - (errs , [(c0,c,a)]) -> do - when (isAmbiguous ambC) $ liftTCM $ storeDisambiguatedName c0 - return (c,a) - - (errs , disambs@((c0,c,a):_)) -> typeError . GenericDocError =<< vcat + (_ , disambs@((_c0,c,_a):_)) -> typeError . GenericDocError =<< vcat [ "Ambiguous constructor " <> prettyTCM (qnameName $ conName c) <> "." , "It could refer to any of" - , nest 2 $ vcat $ map showDisamb disambs + , nest 2 $ vcat $ map (prettyDisamb . fst3) disambs ] where - showDisamb (c0,_,_) = - let r = head $ filter (noRange /=) $ map nameBindingSite $ reverse $ mnameToList $ qnameModule c0 - in (pretty =<< dropTopLevelModule c0) <+> "(introduced at " <> prettyTCM r <> ")" + tryDisambiguate constraintsOk cons d failure = do + disambiguations <- mapM (runExceptT . tryCon constraintsOk cons d pars) cs + -- TODO: can we be more lazy, like using the ListT monad? + case partitionEithers $ NonEmpty.toList disambiguations of + -- Andreas, 2019-10-14: The code from which I factored out 'tryDisambiguate' + -- did allow several disambiguations in case @constraintsOk == False@. + -- There was no comment explaining why, but "fixing" it and insisting on a + -- single disambiguation triggers this error in the std-lib + -- (version 4fca6541edbf5951cff5048b61235fe87d376d84): + -- + -- Data/List/Relation/Unary/All/Properties.agda:462,15-17 + -- Ambiguous constructor []₁. + -- It could refer to any of + -- _._.Pointwise.[] (introduced at Data/List/Relation/Binary/Pointwise.agda:40,6-15) + -- [] (introduced at Data/List/Relation/Binary/Pointwise.agda:40,6-15) + -- when checking that the pattern [] has type x ≋ y + -- + -- There are problems with this error message (reported as issue #4130): + -- + -- * the constructor [] is printed as []₁ + -- * the two (identical) locations point to the definition of data type Pointwise + -- - not to the constructor [] + -- - not offering a clue which imports generated the ambiguity + -- + -- (These should be fixed at some point.) + -- It is not entirely clear to me that the ambiguity is safe to ignore, + -- but let's go with it for the sake of preserving the current behavior of Agda. + -- Thus, only when 'constraintsOk' we require 'null disambs': + -- (Note that in Haskell, boolean implication is '<=' rather than '=>'.) + (_, (c0,c,a) : disambs) | constraintsOk <= null disambs -> do + -- If constructor pattern was ambiguous, + -- remember our choice for highlighting info. + when (isAmbiguous ambC) $ liftTCM $ storeDisambiguatedName c0 + return (c,a) + other -> failure other abstractConstructor c = softTypeError $ AbstractConstructorNotInScope c @@ -1710,7 +1697,7 @@ Left (SigUnknown err) -> __IMPOSSIBLE__ Left SigAbstract -> abstractConstructor c Right def -> do - let con = conSrcCon $ theDef def + let con = conSrcCon (theDef def) `withRangeOf` c unless (conName con `elem` cons) $ wrongDatatype c d -- Andreas, 2013-03-22 fixing issue 279 @@ -1733,7 +1720,11 @@ return (c, con, cType) - +prettyDisamb :: QName -> TCM Doc +prettyDisamb x = do + let d = pretty =<< dropTopLevelModule x + let mr = lastMaybe $ filter (noRange /=) $ map nameBindingSite $ mnameToList $ qnameModule x + caseMaybe mr d $ \ r -> d <+> ("(introduced at " <> prettyTCM r <> ")") -- | @checkConstructorParameters c d pars@ checks that the data/record type @@ -1768,8 +1759,9 @@ compareArgs [] [] t (Def d []) vs (take (length vs) pars) _ -> __IMPOSSIBLE__ -checkSortOfSplitVar :: (MonadTCM tcm, MonadReduce tcm, MonadError TCErr tcm, LensSort a) - => DataOrRecord -> a -> Maybe (Arg Type) -> tcm () +checkSortOfSplitVar :: (MonadTCM m, MonadReduce m, MonadError TCErr m, ReadTCState m, MonadDebug m, + LensSort a, PrettyTCM a, LensSort ty, PrettyTCM ty) + => DataOrRecord -> a -> Maybe ty -> m () checkSortOfSplitVar dr a mtarget = do infOk <- optOmegaInOmega <$> pragmaOptions liftTCM (reduce $ getSort a) >>= \case diff --git a/src/full/Agda/TypeChecking/Rules/LHS/Implicit.hs b/src/full/Agda/TypeChecking/Rules/LHS/Implicit.hs --- a/src/full/Agda/TypeChecking/Rules/LHS/Implicit.hs +++ b/src/full/Agda/TypeChecking/Rules/LHS/Implicit.hs @@ -1,36 +1,26 @@ -{-# LANGUAGE CPP #-} module Agda.TypeChecking.Rules.LHS.Implicit where import Prelude hiding (null) -import Control.Applicative hiding (empty) -import Control.Monad (forM) - import Agda.Syntax.Common import Agda.Syntax.Position import Agda.Syntax.Info import Agda.Syntax.Internal as I -import Agda.Syntax.Abstract (IsProjP(..)) import qualified Agda.Syntax.Abstract as A -import Agda.Syntax.Translation.InternalToAbstract (reify) import Agda.TypeChecking.Monad import Agda.TypeChecking.Implicit import Agda.TypeChecking.Substitute import Agda.TypeChecking.Pretty -import Agda.TypeChecking.Records import Agda.TypeChecking.Reduce import Agda.TypeChecking.Telescope -import Agda.TypeChecking.Rules.LHS.Problem - import Agda.Utils.Function import Agda.Utils.Functor import Agda.Utils.Maybe import Agda.Utils.Monad -#include "undefined.h" import Agda.Utils.Impossible implicitP :: ArgInfo -> NamedArg A.Pattern @@ -105,4 +95,4 @@ NoSuchName x -> typeError WrongHidingInLHS ImpInsert n -> return $ map implicitArg n - implicitArg h = implicitP $ setHiding h $ defaultArgInfo + implicitArg d = implicitP $ getArgInfo d diff --git a/src/full/Agda/TypeChecking/Rules/LHS/Problem.hs b/src/full/Agda/TypeChecking/Rules/LHS/Problem.hs --- a/src/full/Agda/TypeChecking/Rules/LHS/Problem.hs +++ b/src/full/Agda/TypeChecking/Rules/LHS/Problem.hs @@ -1,4 +1,3 @@ --- {-# LANGUAGE CPP #-} module Agda.TypeChecking.Rules.LHS.Problem ( FlexibleVars , FlexibleVarKind(..) , FlexibleVar(..) , allFlexVars @@ -7,36 +6,42 @@ , problemRestPats, problemCont, problemInPats , AsBinding(..) , DotPattern(..) , AbsurdPattern(..) , LHSState(..) , lhsTel , lhsOutPat , lhsProblem , lhsTarget + , LeftoverPatterns(..), getLeftoverPatterns, getUserVariableNames ) where import Prelude hiding (null) -import Control.Applicative hiding (empty) +import Control.Arrow ( (***) ) +import Control.Monad.Writer hiding ((<>)) + import Data.Foldable ( Foldable ) -import Data.Maybe ( fromMaybe ) +import Data.IntMap (IntMap) +import qualified Data.IntMap as IntMap +import Data.List ( partition ) import Data.Monoid ( Monoid, mempty, mappend, mconcat ) import Data.Semigroup ( Semigroup, (<>) ) -import Data.Traversable +import Data.Set (Set) +import qualified Data.Set as Set import Agda.Syntax.Common -import Agda.Syntax.Info -import Agda.Syntax.Literal import Agda.Syntax.Position import Agda.Syntax.Internal -import Agda.Syntax.Internal.Pattern import Agda.Syntax.Abstract (ProblemEq(..)) import qualified Agda.Syntax.Abstract as A -import Agda.TypeChecking.Monad (TCM) +import Agda.TypeChecking.Monad (TCM, IsForced(..), addContext, lookupSection, currentModule) +import Agda.TypeChecking.Monad.Debug import Agda.TypeChecking.Substitute +import Agda.TypeChecking.Telescope +import Agda.TypeChecking.Records import Agda.TypeChecking.Reduce import qualified Agda.TypeChecking.Pretty as P -import Agda.TypeChecking.Pretty hiding ((<>)) +import Agda.TypeChecking.Pretty import Agda.Utils.Lens import Agda.Utils.List import Agda.Utils.Null -import Agda.Utils.Permutation +import Agda.Utils.Singleton import Agda.Utils.Size import qualified Agda.Utils.Pretty as PP @@ -57,20 +62,21 @@ -- | Flexible variables are equipped with information where they come from, -- in order to make a choice which one to assign when two flexibles are unified. data FlexibleVar a = FlexibleVar - { flexHiding :: Hiding - , flexOrigin :: Origin - , flexKind :: FlexibleVarKind - , flexPos :: Maybe Int - , flexVar :: a + { flexArgInfo :: ArgInfo + , flexForced :: IsForced + , flexKind :: FlexibleVarKind + , flexPos :: Maybe Int + , flexVar :: a } deriving (Eq, Show, Functor, Foldable, Traversable) -instance LensHiding (FlexibleVar a) where - getHiding = flexHiding - mapHiding f x = x { flexHiding = f (flexHiding x) } +instance LensArgInfo (FlexibleVar a) where + getArgInfo = flexArgInfo + setArgInfo ai fl = fl { flexArgInfo = ai } + mapArgInfo f fl = fl { flexArgInfo = f (flexArgInfo fl) } -instance LensOrigin (FlexibleVar a) where - getOrigin = flexOrigin - mapOrigin f x = x { flexOrigin = f (flexOrigin x) } +instance LensHiding (FlexibleVar a) +instance LensOrigin (FlexibleVar a) +instance LensModality (FlexibleVar a) -- UNUSED -- defaultFlexibleVar :: a -> FlexibleVar a @@ -80,10 +86,12 @@ -- flexibleVarFromHiding :: Hiding -> a -> FlexibleVar a -- flexibleVarFromHiding h a = FlexibleVar h ImplicitFlex Nothing a -allFlexVars :: Telescope -> FlexibleVars -allFlexVars tel = zipWith makeFlex (downFrom $ size tel) $ telToList tel +allFlexVars :: [IsForced] -> Telescope -> FlexibleVars +allFlexVars forced tel = zipWith3 makeFlex (downFrom n) (telToList tel) fs where - makeFlex i d = FlexibleVar (getHiding d) (getOrigin d) ImplicitFlex (Just i) i + n = size tel + fs = forced ++ repeat NotForced + makeFlex i d f = FlexibleVar (getArgInfo d) f ImplicitFlex (Just i) i data FlexChoice = ChooseLeft | ChooseRight | ChooseEither | ExpandBoth deriving (Eq, Show) @@ -126,6 +134,16 @@ chooseFlex (Just x) Nothing = ChooseRight chooseFlex (Just x) (Just y) = chooseFlex x y +instance ChooseFlex ArgInfo where + chooseFlex ai1 ai2 = firstChoice [ chooseFlex (getOrigin ai1) (getOrigin ai2) + , chooseFlex (getHiding ai1) (getHiding ai2) ] + +instance ChooseFlex IsForced where + chooseFlex NotForced NotForced = ChooseEither + chooseFlex NotForced Forced = ChooseRight + chooseFlex Forced NotForced = ChooseLeft + chooseFlex Forced Forced = ChooseEither + instance ChooseFlex Hiding where chooseFlex Hidden Hidden = ChooseEither chooseFlex Hidden _ = ChooseLeft @@ -151,19 +169,20 @@ GT -> ChooseRight instance (ChooseFlex a) => ChooseFlex (FlexibleVar a) where - chooseFlex (FlexibleVar h1 o1 f1 p1 i1) (FlexibleVar h2 o2 f2 p2 i2) = - firstChoice [ chooseFlex f1 f2, chooseFlex o1 o2, chooseFlex h1 h2 + chooseFlex (FlexibleVar ai1 fc1 f1 p1 i1) (FlexibleVar ai2 fc2 f2 p2 i2) = + firstChoice [ chooseFlex f1 f2, chooseFlex fc1 fc2, chooseFlex ai1 ai2 , chooseFlex p1 p2, chooseFlex i1 i2] - where - firstChoice :: [FlexChoice] -> FlexChoice - firstChoice [] = ChooseEither - firstChoice (ChooseEither : xs) = firstChoice xs - firstChoice (x : _ ) = x +firstChoice :: [FlexChoice] -> FlexChoice +firstChoice [] = ChooseEither +firstChoice (ChooseEither : xs) = firstChoice xs +firstChoice (x : _ ) = x + -- | The user patterns we still have to split on. data Problem a = Problem { _problemEqs :: [ProblemEq] - -- ^ User patterns. + -- ^ User patterns which are typed + -- (including the ones generated from implicit arguments). , _problemRestPats :: [NamedArg A.Pattern] -- ^ List of user patterns which could not yet be typed. -- Example: @@ -181,6 +200,7 @@ -- As we instantiate @b@ to @false@, the 'targetType' reduces to -- @Nat -> Nat@ and we can move pattern @zero@ over to @problemEqs@. , _problemCont :: LHSState a -> TCM a + -- ^ The code that checks the RHS. } deriving Show @@ -216,7 +236,8 @@ -- Can be 'Irrelevant' to indicate that we came by -- an irrelevant projection and, hence, the rhs must -- be type-checked in irrelevant mode. - , _lhsPartialSplit :: ![Maybe Int] -- ^ have we splitted with a PartialFocus? + , _lhsPartialSplit :: ![Maybe Int] + -- ^ have we splitted with a PartialFocus? } lhsTel :: Lens' Telescope (LHSState a) @@ -231,9 +252,98 @@ lhsTarget :: Lens' (Arg Type) (LHSState a) lhsTarget f p = f (_lhsTarget p) <&> \x -> p {_lhsTarget = x} -lhsPartialSplit :: Lens' [Maybe Int] (LHSState a) -lhsPartialSplit f p = f (_lhsPartialSplit p) <&> \x -> p {_lhsPartialSplit = x} +-- UNUSED Liang-Ting Chen 2019-07-16 +--lhsPartialSplit :: Lens' [Maybe Int] (LHSState a) +--lhsPartialSplit f p = f (_lhsPartialSplit p) <&> \x -> p {_lhsPartialSplit = x} +data PatVarPosition = PVLocal | PVParam + deriving (Show, Eq) + +data LeftoverPatterns = LeftoverPatterns + { patternVariables :: IntMap [(A.Name,PatVarPosition)] + , asPatterns :: [AsBinding] + , dotPatterns :: [DotPattern] + , absurdPatterns :: [AbsurdPattern] + , otherPatterns :: [A.Pattern] + } + +instance Semigroup LeftoverPatterns where + x <> y = LeftoverPatterns + { patternVariables = IntMap.unionWith (++) (patternVariables x) (patternVariables y) + , asPatterns = asPatterns x ++ asPatterns y + , dotPatterns = dotPatterns x ++ dotPatterns y + , absurdPatterns = absurdPatterns x ++ absurdPatterns y + , otherPatterns = otherPatterns x ++ otherPatterns y + } + +instance Monoid LeftoverPatterns where + mempty = LeftoverPatterns empty [] [] [] [] + mappend = (<>) + +instance PrettyTCM LeftoverPatterns where + prettyTCM (LeftoverPatterns varp asb dotp absurdp otherp) = vcat + [ "pattern variables: " <+> text (show varp) + , "as bindings: " <+> prettyList_ (map prettyTCM asb) + , "dot patterns: " <+> prettyList_ (map prettyTCM dotp) + , "absurd patterns: " <+> prettyList_ (map prettyTCM absurdp) + , "other patterns: " <+> prettyList_ (map prettyA otherp) + ] + +-- | Classify remaining patterns after splitting is complete into pattern +-- variables, as patterns, dot patterns, and absurd patterns. +-- Precondition: there are no more constructor patterns. +getLeftoverPatterns :: [ProblemEq] -> TCM LeftoverPatterns +getLeftoverPatterns eqs = do + reportSDoc "tc.lhs.top" 30 $ "classifying leftover patterns" + params <- Set.fromList . teleNames <$> (lookupSection =<< currentModule) + let isParamName = (`Set.member` params) . nameToArgName + mconcat <$> mapM (getLeftoverPattern isParamName) eqs + where + patternVariable x i = LeftoverPatterns (singleton (i,[(x,PVLocal)])) [] [] [] [] + moduleParameter x i = LeftoverPatterns (singleton (i,[(x,PVParam)])) [] [] [] [] + asPattern x v a = LeftoverPatterns empty [AsB x v (unDom a)] [] [] [] + dotPattern e v a = LeftoverPatterns empty [] [Dot e v a] [] [] + absurdPattern info a = LeftoverPatterns empty [] [] [Absurd info a] [] + otherPattern p = LeftoverPatterns empty [] [] [] [p] + + getLeftoverPattern :: (A.Name -> Bool) -> ProblemEq -> TCM LeftoverPatterns + getLeftoverPattern isParamName (ProblemEq p v a) = case p of + (A.VarP A.BindName{unBind = x}) -> isEtaVar v (unDom a) >>= \case + Just i | isParamName x -> return $ moduleParameter x i + | otherwise -> return $ patternVariable x i + Nothing -> return $ asPattern x v a + (A.WildP _) -> return mempty + (A.AsP info A.BindName{unBind = x} p) -> (asPattern x v a `mappend`) <$> do + getLeftoverPattern isParamName $ ProblemEq p v a + (A.DotP info e) -> return $ dotPattern e v a + (A.AbsurdP info) -> return $ absurdPattern (getRange info) (unDom a) + _ -> return $ otherPattern p + +-- | Build a renaming for the internal patterns using variable names from +-- the user patterns. If there are multiple user names for the same internal +-- variable, the unused ones are returned as as-bindings. +-- Names that are not also module parameters are preferred over +-- those that are. +getUserVariableNames + :: Telescope -- ^ The telescope of pattern variables + -> IntMap [(A.Name,PatVarPosition)] -- ^ The list of user names for each pattern variable + -> ([Maybe A.Name], [AsBinding]) +getUserVariableNames tel names = runWriter $ + zipWithM makeVar (flattenTel tel) (downFrom $ size tel) + + where + makeVar :: Dom Type -> Int -> Writer [AsBinding] (Maybe A.Name) + makeVar a i = case partitionIsParam (IntMap.findWithDefault [] i names) of + ([] , []) -> return Nothing + ((x:xs) , []) -> tellAsBindings xs *> return (Just x) + (xs , y:ys) -> tellAsBindings (xs ++ ys) *> return (Just y) + where + tellAsBindings = tell . map (\y -> AsB y (var i) (unDom a)) + + partitionIsParam :: [(A.Name,PatVarPosition)] -> ([A.Name],[A.Name]) + partitionIsParam = (map fst *** map fst) . (partition $ (== PVParam) . snd) + + instance Subst Term (Problem a) where applySubst rho (Problem eqs rps cont) = Problem (applySubst rho eqs) rps cont @@ -255,7 +365,7 @@ instance PrettyTCM AsBinding where prettyTCM (AsB x v a) = - sep [ prettyTCM x P.<> "@" P.<> parens (prettyTCM v) + sep [ prettyTCM x <> "@" <> parens (prettyTCM v) , nest 2 $ ":" <+> prettyTCM a ] @@ -276,3 +386,12 @@ instance InstantiateFull AsBinding where instantiateFull' (AsB x v a) = AsB x <$> instantiateFull' v <*> instantiateFull' a + +instance PrettyTCM (LHSState a) where + prettyTCM (LHSState tel outPat (Problem eqs rps _) target _) = vcat + [ "tel = " <+> prettyTCM tel + , "outPat = " <+> addContext tel (prettyTCMPatternList outPat) + , "problemEqs = " <+> addContext tel (prettyList_ $ map prettyTCM eqs) + , "problemRestPats = " <+> prettyList_ (return $ prettyA rps) + , "target = " <+> addContext tel (prettyTCM target) + ] diff --git a/src/full/Agda/TypeChecking/Rules/LHS/ProblemRest.hs b/src/full/Agda/TypeChecking/Rules/LHS/ProblemRest.hs --- a/src/full/Agda/TypeChecking/Rules/LHS/ProblemRest.hs +++ b/src/full/Agda/TypeChecking/Rules/LHS/ProblemRest.hs @@ -1,18 +1,13 @@ -{-# LANGUAGE BangPatterns #-} -{-# LANGUAGE CPP #-} module Agda.TypeChecking.Rules.LHS.ProblemRest where -import Control.Arrow (first, second) import Control.Monad -import Data.Functor ((<$)) import Data.Maybe import Agda.Syntax.Common import Agda.Syntax.Internal import Agda.Syntax.Internal.Pattern -import Agda.Syntax.Abstract.Pattern import qualified Agda.Syntax.Abstract as A import Agda.TypeChecking.Monad @@ -24,11 +19,8 @@ import Agda.TypeChecking.Rules.LHS.Implicit import Agda.Utils.Functor -import Agda.Utils.List import Agda.Utils.Size -import Agda.Utils.Permutation -#include "undefined.h" import Agda.Utils.Impossible -- | Rename the variables in a telescope using the names from a given pattern. @@ -47,7 +39,7 @@ -- Andreas, 2017-10-12, issue #2803, also preserve user-written hidden names. -- However, not if the argument is named, because then the name in the telescope -- is significant for implicit insertion. - A.VarP (A.BindName x) + A.VarP A.BindName{unBind = x} | not (isNoName x) , visible dom || (getOrigin ai == UserWritten && nm == Nothing) -> dom{ unDom = (nameToArgName x, a) } @@ -57,6 +49,12 @@ _ | visible dom && isNoName y -> dom{ unDom = (stringToArgName "x", a) } | otherwise -> dom +useNamesFromProblemEqs :: [ProblemEq] -> Telescope -> TCM Telescope +useNamesFromProblemEqs eqs tel = addContext tel $ do + names <- fst . getUserVariableNames tel . patternVariables <$> getLeftoverPatterns eqs + let argNames = map (fmap nameToArgName) names + return $ renameTel argNames tel + useOriginFrom :: (LensOrigin a, LensOrigin b) => [a] -> [b] -> [a] useOriginFrom = zipWith $ \x y -> setOrigin (getOrigin y) x @@ -82,7 +80,9 @@ -- @ -- lhsTel = [A : Set, m : Maybe A] -- lhsOutPat = ["A", "m"] --- lhsProblem = Problem ["_", "just a"] [] [] [] +-- lhsProblem = Problem ["A" = _, "just a" = "a"] +-- ["_", "just a"] +-- ["just b"] [] -- lhsTarget = "Case m Bool (Maybe A -> Bool)" -- @ initLHSState @@ -133,7 +133,13 @@ ] reportSDoc "tc.lhs.problem" 60 $ addContext tel0 $ vcat [ nest 2 $ vcat - [ "qs1 =" <+> fsep (map pretty qs1) + [ "ps =" <+> (text . show) ps + , "a =" <+> (text . show) a + , "tel1 =" <+> (text . show) tel1 + , "ps1 =" <+> (text . show) ps1 + , "ps2 =" <+> (text . show) ps2 + , "b =" <+> (text . show) b + , "qs1 =" <+> fsep (map pretty qs1) ] ] return $ LHSState diff --git a/src/full/Agda/TypeChecking/Rules/LHS/Unify.hs b/src/full/Agda/TypeChecking/Rules/LHS/Unify.hs --- a/src/full/Agda/TypeChecking/Rules/LHS/Unify.hs +++ b/src/full/Agda/TypeChecking/Rules/LHS/Unify.hs @@ -1,6 +1,3 @@ -{-# LANGUAGE CPP #-} -{-# LANGUAGE DeriveDataTypeable #-} -{-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE NondecreasingIndentation #-} {-# LANGUAGE UndecidableInstances #-} @@ -15,62 +12,81 @@ -- splitting (see @Agda.Interaction.MakeCase@). -- -- A unification problem (of type @UnifyState@) consists of: +-- -- 1. A telescope @varTel@ of free variables, some or all of which are -- flexible (as indicated by @flexVars@). +-- -- 2. A telescope @eqTel@ containing the types of the equations. +-- -- 3. Left- and right-hand sides for each equation: -- @varTel ⊢ eqLHS : eqTel@ and @varTel ⊢ eqRHS : eqTel@. -- -- The unification algorithm can end in three different ways: -- (type @UnificationResult@): +-- -- - A *positive success* @Unifies (tel, sigma, ps)@ with @tel ⊢ sigma : varTel@, -- @tel ⊢ eqLHS [ varTel ↦ sigma ] ≡ eqRHS [ varTel ↦ sigma ] : eqTel@, -- and @tel ⊢ ps : eqTel@. In this case, @sigma;ps@ is an *equivalence* -- between the telescopes @tel@ and @varTel(eqLHS ≡ eqRHS)@. +-- -- - A *negative success* @NoUnify err@ means that a conflicting equation -- was found (e.g an equation between two distinct constructors or a cycle). +-- -- - A *failure* @DontKnow err@ means that the unifier got stuck. -- -- The unification algorithm itself consists of two parts: +-- -- 1. A *unification strategy* takes a unification problem and produces a -- list of suggested unification rules (of type @UnifyStep@). Strategies -- can be constructed by composing simpler strategies (see for example the -- definition of @completeStrategyAt@). +-- -- 2. The *unification engine* @unifyStep@ takes a unification rule and tries -- to apply it to the given state, writing the result to the UnifyOutput -- on a success. -- -- The unification steps (of type @UnifyStep@) are the following: +-- -- - *Deletion* removes a reflexive equation @u =?= v : a@ if the left- and -- right-hand side @u@ and @v@ are (definitionally) equal. This rule results -- in a failure if --without-K is enabled (see \"Pattern Matching Without K\" -- by Jesper Cockx, Dominique Devriese, and Frank Piessens (ICFP 2014). +-- -- - *Solution* solves an equation if one side is (eta-equivalent to) a -- flexible variable. In case both sides are flexible variables, the -- unification strategy makes a choice according to the @chooseFlex@ -- function in @Agda.TypeChecking.Rules.LHS.Problem@. +-- -- - *Injectivity* decomposes an equation of the form -- @c us =?= c vs : D pars is@ where @c : Δc → D pars js@ is a constructor -- of the inductive datatype @D@ into a sequence of equations -- @us =?= vs : delta@. In case @D@ is an indexed datatype, -- *higher-dimensional unification* is applied (see below). +-- -- - *Conflict* detects absurd equations of the form -- @c₁ us =?= c₂ vs : D pars is@ where @c₁@ and @c₂@ are two distinct -- constructors of the datatype @D@. +-- -- - *Cycle* detects absurd equations of the form @x =?= v : D pars is@ where -- @x@ is a variable of the datatype @D@ that occurs strongly rigid in @v@. +-- -- - *EtaExpandVar* eta-expands a single flexible variable @x : R@ where @R@ -- is a (eta-expandable) record type, replacing it by one variable for each -- field of @R@. +-- -- - *EtaExpandEquation* eta-expands an equation @u =?= v : R@ where @R@ is a -- (eta-expandable) record type, replacing it by one equation for each field -- of @R@. The left- and right-hand sides of these equations are the -- projections of @u@ and @v@. +-- -- - *LitConflict* detects absurd equations of the form @l₁ =?= l₂ : A@ where -- @l₁@ and @l₂@ are distinct literal terms. +-- -- - *StripSizeSuc* simplifies an equation of the form -- @sizeSuc x =?= sizeSuc y : Size@ to @x =?= y : Size@. +-- -- - *SkipIrrelevantEquation@ removes an equation between irrelevant terms. +-- -- - *TypeConInjectivity* decomposes an equation of the form -- @D us =?= D vs : Set i@ where @D@ is a datatype. This rule is only used -- if --injective-type-constructors is enabled. @@ -107,30 +123,25 @@ import Prelude hiding (null) -import Control.Arrow ((***)) -import Control.Applicative hiding (empty) import Control.Monad import Control.Monad.State -import Control.Monad.Trans.Maybe -import Control.Monad.Reader import Control.Monad.Writer (WriterT(..), MonadWriter(..), Monoid(..)) -import Data.Map (Map) -import qualified Data.Map as Map import Data.Semigroup hiding (Arg) import qualified Data.List as List +import qualified Data.IntSet as IntSet +import Data.IntSet (IntSet) +import qualified Data.IntMap as IntMap +import Data.IntMap (IntMap) import Data.Foldable (Foldable) import Data.Traversable (Traversable,traverse) -import qualified Data.Traversable as Trav import Agda.Interaction.Options (optInjectiveTypeConstructors) import Agda.Syntax.Common import Agda.Syntax.Internal -import Agda.Syntax.Internal.Pattern import Agda.Syntax.Literal -import Agda.Syntax.Position import Agda.TypeChecking.Monad import qualified Agda.TypeChecking.Monad.Benchmark as Bench @@ -138,27 +149,20 @@ import Agda.TypeChecking.Conversion -- equalTerm import Agda.TypeChecking.Constraints import Agda.TypeChecking.Datatypes -import Agda.TypeChecking.DropArgs import Agda.TypeChecking.Irrelevance import Agda.TypeChecking.Level (reallyUnLevelView) import Agda.TypeChecking.Reduce import qualified Agda.TypeChecking.Patterns.Match as Match -import Agda.TypeChecking.Pretty hiding ((<>)) -import Agda.TypeChecking.SizedTypes (compareSizes) +import Agda.TypeChecking.Pretty import Agda.TypeChecking.Substitute import Agda.TypeChecking.Telescope import Agda.TypeChecking.Free +import Agda.TypeChecking.Free.Precompute import Agda.TypeChecking.Free.Reduce import Agda.TypeChecking.Records -import Agda.TypeChecking.MetaVars (assignV, newArgsMetaCtx) -import Agda.TypeChecking.EtaContract -import Agda.Interaction.Options (optInjectiveTypeConstructors) import Agda.TypeChecking.Rules.LHS.Problem --- import Agda.TypeChecking.SyntacticEquality -import Agda.Utils.Except ( MonadError(catchError, throwError) ) -import Agda.Utils.Either import Agda.Utils.Function import Agda.Utils.Functor import Agda.Utils.Lens @@ -167,11 +171,11 @@ import Agda.Utils.Maybe import Agda.Utils.Monad import Agda.Utils.Null +import Agda.Utils.PartialOrd import Agda.Utils.Permutation import Agda.Utils.Singleton import Agda.Utils.Size -#include "undefined.h" import Agda.Utils.Impossible -- | Result of 'unifyIndices'. @@ -189,22 +193,23 @@ -- | Unify indices. -- --- In @unifyIndices gamma flex us vs@, +-- In @unifyIndices gamma flex a us vs@, -- --- @us@ and @vs@ are the argument lists to unify, +-- * @us@ and @vs@ are the argument lists to unify, eliminating type @a@. -- --- @gamma@ is the telescope of free variables in @us@ and @vs@. +-- * @gamma@ is the telescope of free variables in @us@ and @vs@. -- --- @flex@ is the set of flexible (instantiable) variabes in @us@ and @vs@. +-- * @flex@ is the set of flexible (instantiable) variabes in @us@ and @vs@. -- -- The result is the most general unifier of @us@ and @vs@. -unifyIndices :: MonadTCM tcm - => Telescope - -> FlexibleVars - -> Type - -> Args - -> Args - -> tcm UnificationResult +unifyIndices + :: MonadTCM tcm + => Telescope -- ^ @gamma@ + -> FlexibleVars -- ^ @flex@ + -> Type -- ^ @a@ + -> Args -- ^ @us@ + -> Args -- ^ @vs@ + -> tcm UnificationResult unifyIndices tel flex a [] [] = return $ Unifies (tel, idS, []) unifyIndices tel flex a us vs = liftTCM $ Bench.billTo [Bench.Typing, Bench.CheckLHS, Bench.UnifyIndices] $ do reportSDoc "tc.lhs.unify" 10 $ @@ -227,9 +232,9 @@ ---------------------------------------------------- data Equality = Equal - { eqType :: Dom Type - , eqLeft :: Term - , eqRight :: Term + { _eqType :: Dom Type + , _eqLeft :: Term + , _eqRight :: Term } instance Reduce Equality where @@ -249,61 +254,77 @@ ---------------------------------------------------- data UnifyState = UState - { varTel :: Telescope + { varTel :: Telescope -- ^ Don't reduce! , flexVars :: FlexibleVars - , eqTel :: Telescope - , eqLHS :: [Arg Term] - , eqRHS :: [Arg Term] + , eqTel :: Telescope -- ^ Can be reduced eagerly. + , eqLHS :: [Arg Term] -- ^ Ends up in dot patterns (should not be reduced eagerly). + , eqRHS :: [Arg Term] -- ^ Ends up in dot patterns (should not be reduced eagerly). } deriving (Show) +-- Issues #3578 and #4125: avoid unnecessary reduction in unifier. lensVarTel :: Lens' Telescope UnifyState lensVarTel f s = f (varTel s) <&> \ tel -> s { varTel = tel } - -lensFlexVars :: Lens' FlexibleVars UnifyState -lensFlexVars f s = f (flexVars s) <&> \ flex -> s { flexVars = flex } +--UNUSED Liang-Ting Chen 2019-07-16 +--lensFlexVars :: Lens' FlexibleVars UnifyState +--lensFlexVars f s = f (flexVars s) <&> \ flex -> s { flexVars = flex } lensEqTel :: Lens' Telescope UnifyState lensEqTel f s = f (eqTel s) <&> \ x -> s { eqTel = x } -lensEqLHS :: Lens' Args UnifyState -lensEqLHS f s = f (eqLHS s) <&> \ x -> s { eqLHS = x } +--UNUSED Liang-Ting Chen 2019-07-16 +--lensEqLHS :: Lens' Args UnifyState +--lensEqLHS f s = f (eqLHS s) <&> \ x -> s { eqLHS = x } -lensEqRHS :: Lens' Args UnifyState -lensEqRHS f s = f (eqRHS s) <&> \ x -> s { eqRHS = x } +--UNUSED Liang-Ting Chen 2019-07-16 +--lensEqRHS :: Lens' Args UnifyState +--lensEqRHS f s = f (eqRHS s) <&> \ x -> s { eqRHS = x } +-- UNUSED Andreas, 2019-10-14 +-- instance Reduce UnifyState where +-- reduce' (UState var flex eq lhs rhs) = +-- UState <$> reduce' var +-- <*> pure flex +-- <*> reduce' eq +-- <*> reduce' lhs +-- <*> reduce' rhs + +-- Andreas, 2019-10-14, issues #3578 and #4125: +-- | Don't ever reduce the whole 'varTel', as it will destroy +-- readability of the context in interactive editing! +-- To make sure this insight is not lost, the following +-- dummy instance should prevent a proper 'Reduce' instance for 'UnifyState'. instance Reduce UnifyState where - reduce' (UState var flex eq lhs rhs) = - UState <$> reduce' var - <*> pure flex - <*> reduce' eq - <*> reduce' lhs - <*> reduce' rhs + reduce' = __IMPOSSIBLE__ -reduceEqTel :: UnifyState -> TCM UnifyState -reduceEqTel = lensEqTel reduce +--UNUSED Liang-Ting Chen 2019-07-16 +--reduceEqTel :: UnifyState -> TCM UnifyState +--reduceEqTel = lensEqTel reduce -instance Normalise UnifyState where - normalise' (UState var flex eq lhs rhs) = - UState <$> normalise' var - <*> pure flex - <*> normalise' eq - <*> normalise' lhs - <*> normalise' rhs +-- UNUSED Andreas, 2019-10-14 +-- instance Normalise UnifyState where +-- normalise' (UState var flex eq lhs rhs) = +-- UState <$> normalise' var +-- <*> pure flex +-- <*> normalise' eq +-- <*> normalise' lhs +-- <*> normalise' rhs instance PrettyTCM UnifyState where prettyTCM state = "UnifyState" $$ nest 2 (vcat $ [ "variable tel: " <+> prettyTCM gamma - , "flexible vars: " <+> prettyTCM (map flexVar $ flexVars state) + , "flexible vars: " <+> pshow (map flexVarF $ flexVars state) , "equation tel: " <+> addContext gamma (prettyTCM delta) , "equations: " <+> addContext gamma (prettyList_ (zipWith prettyEquality (eqLHS state) (eqRHS state))) ]) where + flexVarF fi = (flexVar fi, flexForced fi) gamma = varTel state delta = eqTel state prettyEquality x y = prettyTCM x <+> "=?=" <+> prettyTCM y initUnifyState :: Telescope -> FlexibleVars -> Type -> Args -> Args -> TCM UnifyState initUnifyState tel flex a lhs rhs = do + (tel, a, lhs, rhs) <- instantiateFull (tel, a, lhs, rhs) let n = size lhs unless (n == size rhs) __IMPOSSIBLE__ TelV eqTel _ <- telView a @@ -344,28 +365,29 @@ (unArg $ indexWithDefault __IMPOSSIBLE__ lhs k) (unArg $ indexWithDefault __IMPOSSIBLE__ rhs k) -getEqInfo :: Int -> UnifyState -> ArgInfo -getEqInfo k UState { eqTel = eqs } = - domInfo $ indexWithDefault __IMPOSSIBLE__ (telToList eqs) k - --- | Add a list of equations to the front of the equation telescope -addEqs :: Telescope -> [Arg Term] -> [Arg Term] -> UnifyState -> UnifyState -addEqs tel us vs s = - s { eqTel = tel `abstract` eqTel s - , eqLHS = us ++ eqLHS s - , eqRHS = vs ++ eqRHS s - } - where k = size tel - -addEq :: Type -> Arg Term -> Arg Term -> UnifyState -> UnifyState -addEq a u v = addEqs (ExtendTel (defaultDom a) (Abs underscore EmptyTel)) [u] [v] +--UNUSED Liang-Ting Chen 2019-07-16 +--getEqInfo :: Int -> UnifyState -> ArgInfo +--getEqInfo k UState { eqTel = eqs } = +-- domInfo $ indexWithDefault __IMPOSSIBLE__ (telToList eqs) k +-- +---- | Add a list of equations to the front of the equation telescope +--addEqs :: Telescope -> [Arg Term] -> [Arg Term] -> UnifyState -> UnifyState +--addEqs tel us vs s = +-- s { eqTel = tel `abstract` eqTel s +-- , eqLHS = us ++ eqLHS s +-- , eqRHS = vs ++ eqRHS s +-- } +-- where k = size tel +-- +--addEq :: Type -> Arg Term -> Arg Term -> UnifyState -> UnifyState +--addEq a u v = addEqs (ExtendTel (defaultDom a) (Abs underscore EmptyTel)) [u] [v] -- | Instantiate the k'th variable with the given value. -- Returns Nothing if there is a cycle. -solveVar :: Int -- ^ Index @k@ - -> Term -- ^ Solution @u@ +solveVar :: Int -- ^ Index @k@ + -> DeBruijnPattern -- ^ Solution @u@ -> UnifyState -> Maybe (UnifyState, PatternSubstitution) solveVar k u s = case instantiateTelescope (varTel s) k u of Nothing -> Nothing @@ -379,8 +401,8 @@ where permuteFlex :: Permutation -> FlexibleVars -> FlexibleVars permuteFlex perm = - mapMaybe $ \(FlexibleVar h o k p x) -> - FlexibleVar h o k p <$> List.findIndex (x==) (permPicks perm) + mapMaybe $ \(FlexibleVar ai fc k p x) -> + FlexibleVar ai fc k p <$> List.findIndex (x==) (permPicks perm) applyUnder :: Int -> Telescope -> Term -> Telescope applyUnder k tel u @@ -411,19 +433,20 @@ n = eqCount s sigma = liftS (n-k-1) $ consS (dotP u') idS --- | Simplify the k'th equation with the given value (which can depend on other --- equation variables). Returns Nothing if there is a cycle. -simplifyEq :: Int -> Term -> UnifyState -> Maybe (UnifyState, PatternSubstitution) -simplifyEq k u s = case instantiateTelescope (eqTel s) k u of - Nothing -> Nothing - Just (tel' , sigma , rho) -> Just $ (,sigma) $ UState - { varTel = varTel s - , flexVars = flexVars s - , eqTel = tel' - , eqLHS = permute rho $ eqLHS s - , eqRHS = permute rho $ eqRHS s - } - +--UNUSED Liang-Ting Chen 2019-07-16 +---- | Simplify the k'th equation with the given value (which can depend on other +---- equation variables). Returns Nothing if there is a cycle. +--simplifyEq :: Int -> Term -> UnifyState -> Maybe (UnifyState, PatternSubstitution) +--simplifyEq k u s = case instantiateTelescope (eqTel s) k u of +-- Nothing -> Nothing +-- Just (tel' , sigma , rho) -> Just $ (,sigma) $ UState +-- { varTel = varTel s +-- , flexVars = flexVars s +-- , eqTel = tel' +-- , eqLHS = permute rho $ eqLHS s +-- , eqRHS = permute rho $ eqRHS s +-- } +-- ---------------------------------------------------- -- Unification strategies ---------------------------------------------------- @@ -507,7 +530,7 @@ Solution k a i u -> "Solution" $$ nest 2 (vcat $ [ "position: " <+> text (show k) , "type: " <+> prettyTCM a - , "variable: " <+> text (show i) + , "variable: " <+> text (show (flexVar i, flexPos i, flexForced i, flexKind i)) , "term: " <+> prettyTCM u ]) Injectivity k a d pars ixs c -> "Injectivity" $$ nest 2 (vcat $ @@ -567,10 +590,11 @@ type UnifyStrategy = UnifyState -> ListT TCM UnifyStep -leftToRightStrategy :: UnifyStrategy -leftToRightStrategy s = - msum (for [0..n-1] $ \k -> completeStrategyAt k s) - where n = size $ eqTel s +--UNUSED Liang-Ting Chen 2019-07-16 +--leftToRightStrategy :: UnifyStrategy +--leftToRightStrategy s = +-- msum (for [0..n-1] $ \k -> completeStrategyAt k s) +-- where n = size $ eqTel s rightToLeftStrategy :: UnifyStrategy rightToLeftStrategy s = @@ -647,15 +671,14 @@ Def d es | Type{} <- getSort a -> do npars <- catMaybesMP $ liftTCM $ getNumberOfParameters d let (pars,ixs) = splitAt npars $ fromMaybe __IMPOSSIBLE__ $ allApplyElims es - hpars <- fromMaybeMP $ isHom k pars - liftTCM $ reportSDoc "tc.lhs.unify" 40 $ addContext (varTel s) $ + liftTCM $ reportSDoc "tc.lhs.unify" 40 $ addContext (varTel s `abstract` eqTel s) $ "Found equation at datatype " <+> prettyTCM d - <+> " with (homogeneous) parameters " <+> prettyTCM hpars + <+> " with parameters " <+> prettyTCM (raise (size (eqTel s) - k) pars) case (u, v) of - (Con c _ _ , Con c' _ _ ) | c == c' -> return $ Injectivity k a d hpars ixs c - (Con c _ _ , Con c' _ _ ) -> return $ Conflict k a d hpars u v - (Var i [] , v ) -> ifOccursStronglyRigid i v $ return $ Cycle k a d hpars i v - (u , Var j [] ) -> ifOccursStronglyRigid j u $ return $ Cycle k a d hpars j u + (Con c _ _ , Con c' _ _ ) | c == c' -> return $ Injectivity k a d pars ixs c + (Con c _ _ , Con c' _ _ ) -> return $ Conflict k a d pars u v + (Var i [] , v ) -> ifOccursStronglyRigid i v $ return $ Cycle k a d pars i v + (u , Var j [] ) -> ifOccursStronglyRigid j u $ return $ Cycle k a d pars j u _ -> mzero _ -> mzero where @@ -663,8 +686,8 @@ -- Call forceNotFree to reduce u as far as possible -- around any occurrences of i (_ , u) <- liftTCM $ forceNotFree (singleton i) u - case occurrence i u of - StronglyRigid -> ret + case flexRigOccurrenceIn i u of + Just StronglyRigid -> ret _ -> mzero checkEqualityStrategy :: Int -> UnifyStrategy @@ -696,16 +719,18 @@ fi <- fromMaybeMP $ findFlexible i (flexVars s) liftTCM $ reportSDoc "tc.lhs.unify" 50 $ "Found flexible variable " <+> text (show i) - -- Issue 2888: Do this if there are projections or if it's a singleton + -- Issue 2888: Do this if there are only projections or if it's a singleton -- record or if it's unified against a record constructor term. Basically -- we need to avoid EtaExpandEquation if EtaExpandVar is possible, or the -- forcing translation is unhappy. b <- reduce $ unDom $ getVarTypeUnraised (varCount s - 1 - i) s (d, pars) <- catMaybesMP $ liftTCM $ isEtaRecordType b ps <- fromMaybeMP $ allProjElims es - sing <- liftTCM $ (Right True ==) <$> isSingletonRecord d pars - con <- liftTCM $ isRecCon v -- is the other term a record constructor? - guard $ not (null ps) || sing || con + guard =<< orM + [ pure $ not $ null ps + , liftTCM $ isRecCon v -- is the other term a record constructor? + , liftTCM $ (Right True ==) <$> isSingletonRecord d pars + ] liftTCM $ reportSDoc "tc.lhs.unify" 50 $ "with projections " <+> prettyTCM (map snd ps) liftTCM $ reportSDoc "tc.lhs.unify" 50 $ @@ -721,10 +746,11 @@ -- Andreas, 2019-02-23, re #3578, is the following reduce redundant? Equal Dom{unDom = a} u v <- reduce $ getEqualityUnraised k s (d, pars) <- catMaybesMP $ liftTCM $ addContext tel $ isEtaRecordType a - sing <- liftTCM $ (Right True ==) <$> isSingletonRecord d pars - projLeft <- liftTCM $ shouldProject u - projRight <- liftTCM $ shouldProject v - guard $ sing || projLeft || projRight + guard =<< orM + [ liftTCM $ (Right True ==) <$> isSingletonRecord d pars + , liftTCM $ shouldProject u + , liftTCM $ shouldProject v + ] return $ EtaExpandEquation k d pars where shouldProject :: Term -> TCM Bool @@ -740,7 +766,7 @@ Level _ -> __IMPOSSIBLE__ MetaV _ _ -> return False DontCare _ -> return False - Dummy s -> __IMPOSSIBLE_VERBOSE__ s + Dummy s _ -> __IMPOSSIBLE_VERBOSE__ s tel = varTel s `abstract` telFromList (take k $ telToList $ eqTel s) @@ -809,8 +835,8 @@ ---------------------------------------------------- data UnifyLogEntry - = UnificationDone UnifyState - | UnificationStep UnifyState UnifyStep + = UnificationStep UnifyState UnifyStep +-- | UnificationDone UnifyState -- unused? type UnifyLog = [UnifyLogEntry] @@ -849,10 +875,8 @@ unifyStep s Deletion{ deleteAt = k , deleteType = a , deleteLeft = u , deleteRight = v } = do -- Check definitional equality of u and v - isReflexive <- liftTCM $ addContext (varTel s) $ do + isReflexive <- liftTCM $ addContext (varTel s) $ tryCatch $ do dontAssignMetas $ noConstraints $ equalTerm a u v - return Nothing - `catchError` \err -> return $ Just err withoutK <- liftTCM withoutKOption case isReflexive of Just err -> return $ DontKnow [] @@ -862,83 +886,22 @@ tellUnifyProof sigma Unifies <$> liftTCM (lensEqTel reduce s') -unifyStep s Solution{ solutionAt = k - , solutionType = dom@Dom{ unDom = a } - , solutionVar = fi@FlexibleVar{ flexVar = i } - , solutionTerm = u } = do - let m = varCount s - - -- Check that the type of the variable is equal to the type of the equation - -- (not just a subtype), otherwise we cannot instantiate (see Issue 2407). - let dom'@Dom{ unDom = a' } = getVarType (m-1-i) s - equalTypes <- liftTCM $ addContext (varTel s) $ do - reportSDoc "tc.lhs.unify" 45 $ "Equation type: " <+> prettyTCM a - reportSDoc "tc.lhs.unify" 45 $ "Variable type: " <+> prettyTCM a' - dontAssignMetas $ noConstraints $ equalType a a' - return Nothing - `catchError` \err -> return $ Just err - - -- The conditions on the relevances are as follows (see #2640): - -- - If the type of the equation is relevant, then the solution must be - -- usable in a relevant position. - -- - If the type of the equation is (shape-)irrelevant, then the solution - -- must be usable in a μ-relevant position where μ is the relevance - -- of the variable being solved. - -- - -- Jesper, Andreas, 2018-10-17: the quantity of the equation is morally - -- always @Quantity0@, since the indices of the data type are runtime erased. - -- This, we need not change the quantity of the solution. - let eqrel = getRelevance dom - varmod = getModality dom' - mod = applyUnless (NonStrict `moreRelevant` eqrel) (setRelevance eqrel) - $ varmod - reportSDoc "tc.lhs.unify" 65 $ text $ "Equation modality: " ++ show (getModality dom) - reportSDoc "tc.lhs.unify" 65 $ text $ "Variable modality: " ++ show varmod - reportSDoc "tc.lhs.unify" 65 $ text $ "Solution must be usable in a " ++ show mod ++ " position." - -- Andreas, 2018-10-18 - -- Currently, the modality check that would correspond to the - -- relevance check has problems with meta-variables created in the type signature, - -- and thus, in quantity 0, that get into terms using the unifier, - -- and there are checked to be non-erased, i.e., have quantity ω. - -- Thus, at the moment wo only check relevances, being aware - -- that uses of the 0-quantity might create segfaults in the compiled program - -- situations analogous to #2640 (issue with projecting forced constructor fields). - -- - -- usable <- liftTCM $ addContext (varTel s) $ usableMod mod u -- TODO - usable <- liftTCM $ addContext (varTel s) $ usableRel (getRelevance mod) u - reportSDoc "tc.lhs.unify" 45 $ "Modality ok: " <+> prettyTCM usable - unless usable $ reportSLn "tc.lhs.unify" 65 $ "Rejected solution: " ++ show u - - case equalTypes of - Just err -> return $ DontKnow [] - Nothing | usable -> caseMaybeM (trySolveVar (m-1-i) u s) - -- Case: Nothing - (return $ DontKnow [UnifyRecursiveEq (varTel s) a i u]) - -- Case: Just - $ \ (s', sub) -> do - tellUnifySubst sub - let (s'', sigma) = solveEq k (applyPatSubst sub u) s' - tellUnifyProof sigma - return $ Unifies s'' - -- Andreas, 2019-02-23, issue #3578: do not eagerly reduce - -- Unifies <$> liftTCM (reduce s'') - Nothing -> return $ DontKnow [] - where - trySolveVar i u s = case solveVar i u s of - Just x -> return $ Just x - Nothing -> do - u <- liftTCM $ normalise u - s <- liftTCM $ lensVarTel normalise s - return $ solveVar i u s +unifyStep s step@Solution{} = solutionStep RetryNormalised s step unifyStep s (Injectivity k a d pars ixs c) = do ifM (liftTCM $ consOfHIT $ conName c) (return $ DontKnow []) $ do withoutK <- liftTCM withoutKOption let n = eqCount s + -- Split equation telescope into parts before and after current equation + let (eqListTel1, _ : eqListTel2) = splitAt k $ telToList $ eqTel s + (eqTel1, eqTel2) = (telFromList eqListTel1, telFromList eqListTel2) + -- Get constructor telescope and target indices - ctype <- (`piApply` pars) . defType <$> liftTCM (getConInfo c) - addContext (varTel s) $ reportSDoc "tc.lhs.unify" 40 $ + cdef <- liftTCM (getConInfo c) + let ctype = defType cdef `piApply` pars + forced = defForced cdef + addContext (varTel s `abstract` eqTel1) $ reportSDoc "tc.lhs.unify" 40 $ "Constructor type: " <+> prettyTCM ctype TelV ctel ctarget <- liftTCM $ telView ctype let cixs = case unEl ctarget of @@ -949,26 +912,23 @@ -- Get index telescope of the datatype dtype <- (`piApply` pars) . defType <$> liftTCM (getConstInfo d) - addContext (varTel s) $ reportSDoc "tc.lhs.unify" 40 $ + addContext (varTel s `abstract` eqTel1) $ reportSDoc "tc.lhs.unify" 40 $ "Datatype type: " <+> prettyTCM dtype - -- Split equation telescope into parts before and after current equation - let (eqListTel1, _ : eqListTel2) = splitAt k $ telToList $ eqTel s - (eqTel1, eqTel2) = (telFromList eqListTel1, telFromList eqListTel2) - -- This is where the magic of higher-dimensional unification happens -- We need to generalize the indices `ixs` to the target indices of the -- constructor `cixs`. This is done by calling the unification algorithm -- recursively (this doesn't get stuck in a loop because a type should -- never be indexed over itself). Note the similarity with the -- computeNeighbourhood function in Agda.TypeChecking.Coverage. - let hduTel = eqTel1 `abstract` raise (size eqTel1) ctel + let hduTel = eqTel1 `abstract` ctel + notforced = replicate (size hduTel) NotForced res <- liftTCM $ addContext (varTel s) $ unifyIndices hduTel - (allFlexVars hduTel) - (raise (size hduTel) dtype) + (allFlexVars notforced hduTel) + (raise (size ctel) dtype) (raise (size ctel) ixs) - (raiseFrom (size ctel) (size eqTel1) cixs) + cixs case res of -- Higher-dimensional unification can never end in a conflict, -- because `cong c1 ...` and `cong c2 ...` don't even have the @@ -980,7 +940,7 @@ -- simplify the equation as in the non-indexed case. DontKnow _ | not withoutK -> do -- using the same variable names as in the case where hdu succeeds. - let eqTel1' = eqTel1 `abstract` raise (size eqTel1) ctel + let eqTel1' = eqTel1 `abstract` ctel rho1 = raiseS (size ctel) ceq = ConP c noConPatternInfo $ teleNamedArgs ctel rho3 = consS ceq rho1 @@ -993,7 +953,7 @@ eqTel' <- liftTCM $ reduce eqTel' -- Compute new lhs and rhs by matching the old ones against rho - (lhs', rhs') <- liftTCM . reduce =<< do + (lhs', rhs') <- do let ps = applySubst rho $ teleNamedArgs $ eqTel s (lhsMatch, _) <- liftTCM $ runReduceM $ Match.matchPatterns ps $ eqLHS s (rhsMatch, _) <- liftTCM $ runReduceM $ Match.matchPatterns ps $ eqRHS s @@ -1028,7 +988,7 @@ eqTel' <- liftTCM $ reduce eqTel' -- Compute new lhs and rhs by matching the old ones against rho - (lhs', rhs') <- liftTCM . reduce =<< do + (lhs', rhs') <- do let ps = applySubst rho $ teleNamedArgs $ eqTel s (lhsMatch, _) <- liftTCM $ runReduceM $ Match.matchPatterns ps $ eqLHS s (rhsMatch, _) <- liftTCM $ runReduceM $ Match.matchPatterns ps $ eqRHS s @@ -1064,15 +1024,15 @@ c <- liftTCM $ getRecordConstructor d let nfields = size delta (varTel', rho) = expandTelescopeVar (varTel s) (m-1-i) delta c - projectFlexible = [ FlexibleVar (flexHiding fi) (flexOrigin fi) (projFlexKind j) (flexPos fi) (i+j) | j <- [0..nfields-1] ] + projectFlexible = [ FlexibleVar (getArgInfo fi) (flexForced fi) (projFlexKind j) (flexPos fi) (i+j) | j <- [0..nfields-1] ] tellUnifySubst $ rho - Unifies <$> liftTCM (reduce $ UState + return $ Unifies $ UState { varTel = varTel' , flexVars = projectFlexible ++ liftFlexibles nfields (flexVars s) , eqTel = applyPatSubst rho $ eqTel s , eqLHS = applyPatSubst rho $ eqLHS s , eqRHS = applyPatSubst rho $ eqRHS s - }) + } where i = flexVar fi m = varCount s @@ -1098,11 +1058,12 @@ rhs <- expandKth $ eqRHS s let (tel, sigma) = expandTelescopeVar (eqTel s) k delta c tellUnifyProof sigma - Unifies <$> liftTCM (lensEqTel reduce $ s + Unifies <$> do + liftTCM $ lensEqTel reduce $ s { eqTel = tel , eqLHS = lhs , eqRHS = rhs - }) + } where expandKth us = do let (us1,v:us2) = fromMaybe __IMPOSSIBLE__ $ splitExactlyAt k us @@ -1134,8 +1095,7 @@ unifyStep s (SkipIrrelevantEquation k) = do let lhs = eqLHS s - (s', sigma) = -- newline because of CPP - solveEq k (DontCare $ unArg $ indexWithDefault __IMPOSSIBLE__ lhs k) s + (s', sigma) = solveEq k (DontCare $ unArg $ indexWithDefault __IMPOSSIBLE__ lhs k) s tellUnifyProof sigma return $ Unifies s' @@ -1147,12 +1107,120 @@ deq = Def d $ map Apply $ teleArgs dtel -- TODO: tellUnifyProof ??? -- but d is not a constructor... - Unifies <$> liftTCM (lensEqTel reduce $ s + Unifies <$> do + liftTCM $ lensEqTel reduce $ s { eqTel = dtel `abstract` applyUnder k (eqTel s) (raise k deq) , eqLHS = us ++ dropAt k (eqLHS s) , eqRHS = vs ++ dropAt k (eqRHS s) - }) + } +data RetryNormalised = RetryNormalised | DontRetryNormalised + deriving (Eq, Show) + +solutionStep :: RetryNormalised -> UnifyState -> UnifyStep -> UnifyM (UnificationResult' UnifyState) +solutionStep retry s + step@Solution{ solutionAt = k + , solutionType = dom@Dom{ unDom = a } + , solutionVar = fi@FlexibleVar{ flexVar = i } + , solutionTerm = u } = do + let m = varCount s + + -- Now we have to be careful about forced variables in `u`. If they appear + -- in pattern positions we need to bind them there rather in their forced positions. We can safely + -- ignore non-pattern positions and forced pattern positions, because in that case there will be + -- other equations where the variable can be bound. + -- NOTE: If we're doing make-case we ignore forced variables. This is safe since we take the + -- result of unification and build user clauses that will be checked again with forcing turned on. + inMakeCase <- viewTC eMakeCase + let forcedVars | inMakeCase = IntMap.empty + | otherwise = IntMap.fromList [ (flexVar fi, getModality fi) | fi <- flexVars s, + flexForced fi == Forced ] + (p, bound) <- patternBindingForcedVars forcedVars u + + -- To maintain the invariant that each variable in varTel is bound exactly once in the pattern + -- subtitution we need to turn the bound variables in `p` into dot patterns in the rest of the + -- substitution. + let dotSub = foldr composeS idS [ inplaceS i (dotP (Var i [])) | i <- IntMap.keys bound ] + + -- We moved the binding site of some forced variables, so we need to update their modalities in + -- the telescope. The new modality is the combination of the modality of the variable we are + -- instantiating and the modality of the binding site in the pattern (return by + -- patternBindingForcedVars). + let updModality md vars tel + | IntMap.null vars = tel + | otherwise = telFromList $ zipWith upd (downFrom $ size tel) (telToList tel) + where + upd i a | Just md' <- IntMap.lookup i vars = setModality (md <> md') a + | otherwise = a + s <- return $ s { varTel = updModality (getModality fi) bound (varTel s) } + + reportSDoc "tc.lhs.unify.force" 45 $ vcat + [ "forcedVars =" <+> pretty (IntMap.keys forcedVars) + , "u =" <+> prettyTCM u + , "p =" <+> prettyTCM p + , "bound =" <+> pretty (IntMap.keys bound) + , "dotSub =" <+> pretty dotSub ] + + -- Check that the type of the variable is equal to the type of the equation + -- (not just a subtype), otherwise we cannot instantiate (see Issue 2407). + let dom'@Dom{ unDom = a' } = getVarType (m-1-i) s + equalTypes <- liftTCM $ addContext (varTel s) $ tryCatch $ do + reportSDoc "tc.lhs.unify" 45 $ "Equation type: " <+> prettyTCM a + reportSDoc "tc.lhs.unify" 45 $ "Variable type: " <+> prettyTCM a' + dontAssignMetas $ noConstraints $ equalType a a' + + -- The conditions on the relevances are as follows (see #2640): + -- - If the type of the equation is relevant, then the solution must be + -- usable in a relevant position. + -- - If the type of the equation is (shape-)irrelevant, then the solution + -- must be usable in a μ-relevant position where μ is the relevance + -- of the variable being solved. + -- + -- Jesper, Andreas, 2018-10-17: the quantity of the equation is morally + -- always @Quantity0@, since the indices of the data type are runtime erased. + -- Thus, we need not change the quantity of the solution. + let eqrel = getRelevance dom + eqmod = getModality dom + varmod = getModality dom' + mod = applyUnless (NonStrict `moreRelevant` eqrel) (setRelevance eqrel) + $ varmod + reportSDoc "tc.lhs.unify" 65 $ text $ "Equation modality: " ++ show (getModality dom) + reportSDoc "tc.lhs.unify" 65 $ text $ "Variable modality: " ++ show varmod + reportSDoc "tc.lhs.unify" 65 $ text $ "Solution must be usable in a " ++ show mod ++ " position." + -- Andreas, 2018-10-18 + -- Currently, the modality check has problems with meta-variables created in the type signature, + -- and thus, in quantity 0, that get into terms using the unifier, and there are checked to be + -- non-erased, i.e., have quantity ω. + -- Ulf, 2019-12-13. We still do it though. + usable <- liftTCM $ addContext (varTel s) $ usableMod mod u + reportSDoc "tc.lhs.unify" 45 $ "Modality ok: " <+> prettyTCM usable + unless usable $ reportSLn "tc.lhs.unify" 65 $ "Rejected solution: " ++ show u + + -- We need a Flat equality to solve a Flat variable. + -- This also ought to take care of the need for a usableCohesion check. + if not (getCohesion eqmod `moreCohesion` getCohesion varmod) then return $ DontKnow [] else do + + case equalTypes of + Just err -> return $ DontKnow [] + Nothing | usable -> + case solveVar (m - 1 - i) p s of + Nothing | retry == RetryNormalised -> do + u <- liftTCM $ normalise u + s <- liftTCM $ lensVarTel normalise s + solutionStep DontRetryNormalised s step{ solutionTerm = u } + Nothing -> + return $ DontKnow [UnifyRecursiveEq (varTel s) a i u] + Just (s', sub) -> do + let rho = sub `composeS` dotSub + tellUnifySubst rho + let (s'', sigma) = solveEq k (applyPatSubst rho u) s' + tellUnifyProof sigma + return $ Unifies s'' + -- Andreas, 2019-02-23, issue #3578: do not eagerly reduce + -- Unifies <$> liftTCM (reduce s'') + Nothing -> return $ DontKnow [UnifyUnusableModality (varTel s) a i u mod] +solutionStep _ _ _ = __IMPOSSIBLE__ + unify :: UnifyState -> UnifyStrategy -> UnifyM (UnificationResult' UnifyState) unify s strategy = if isUnifyStateSolved s then return $ Unifies s @@ -1188,3 +1256,51 @@ failure :: UnifyM (UnificationResult' a) failure = return $ DontKnow [] + +-- | Turn a term into a pattern binding as many of the given forced variables as possible (in +-- non-forced positions). +patternBindingForcedVars :: (HasConstInfo m, MonadReduce m) => IntMap Modality -> Term -> m (DeBruijnPattern, IntMap Modality) +patternBindingForcedVars forced v = do + let v' = precomputeFreeVars_ v + runWriterT (evalStateT (go defaultModality v') forced) + where + noForced v = IntSet.null . IntSet.intersection (precomputedFreeVars v) . IntMap.keysSet <$> get + + bind md i = do + Just md' <- gets $ IntMap.lookup i + if related md POLE md' -- The new binding site must be more relevant (more relevant = smaller). + then do -- The forcing analysis guarantees that there exists such a position. + tell $ IntMap.singleton i md + modify $ IntMap.delete i + return $ varP (deBruijnVar i) + else return $ dotP (Var i []) + + go md v = ifM (noForced v) (return $ dotP v) $ do + v' <- lift $ lift $ reduce v + case v' of + Var i [] -> bind md i -- we know i is forced + Con c ci es + | Just vs <- allApplyElims es -> do + fs <- defForced <$> getConstInfo (conName c) + let goArg Forced v = return $ fmap (unnamed . dotP) v + goArg NotForced v = fmap unnamed <$> traverse (go $ md <> getModality v) v + (ps, bound) <- listen $ zipWithM goArg (fs ++ repeat NotForced) vs + if IntMap.null bound + then return $ dotP v -- bound nothing + else do + let cpi = (toConPatternInfo ci) { conPRecord = True, + conPLazy = True } -- Not setting conPType. Is this a problem? + return $ ConP c cpi $ map (setOrigin Inserted) ps + | otherwise -> return $ dotP v -- Higher constructor (es has IApply) + + -- Non-pattern positions + Var _ (_:_) -> return $ dotP v + Lam{} -> return $ dotP v + Pi{} -> return $ dotP v + Def{} -> return $ dotP v + MetaV{} -> return $ dotP v + Sort{} -> return $ dotP v + Level{} -> return $ dotP v + DontCare{} -> return $ dotP v + Dummy{} -> return $ dotP v + Lit{} -> __IMPOSSIBLE__ diff --git a/src/full/Agda/TypeChecking/Rules/Record.hs b/src/full/Agda/TypeChecking/Rules/Record.hs --- a/src/full/Agda/TypeChecking/Rules/Record.hs +++ b/src/full/Agda/TypeChecking/Rules/Record.hs @@ -1,14 +1,11 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE NondecreasingIndentation #-} module Agda.TypeChecking.Rules.Record where import Prelude hiding (null) -import Control.Applicative hiding (empty) import Control.Monad import Data.Maybe -import qualified Data.Set as Set import Agda.Interaction.Options @@ -18,13 +15,11 @@ import Agda.Syntax.Internal.Pattern import Agda.Syntax.Position import qualified Agda.Syntax.Info as Info -import Agda.Syntax.Scope.Monad (freshAbstractQName) -import Agda.Syntax.Fixity import Agda.TypeChecking.Monad import Agda.TypeChecking.Monad.Builtin -import Agda.TypeChecking.Names import Agda.TypeChecking.Primitive +import Agda.TypeChecking.Rewriting.Confluence import Agda.TypeChecking.Substitute import Agda.TypeChecking.Telescope import Agda.TypeChecking.Reduce @@ -44,10 +39,10 @@ import Agda.Utils.Monad import Agda.Utils.Null import Agda.Utils.Permutation +import Agda.Utils.POMonoid import qualified Agda.Utils.Pretty as P import Agda.Utils.Size -#include "undefined.h" import Agda.Utils.Impossible --------------------------------------------------------------------------- @@ -68,7 +63,7 @@ -- [@fields@] List of field signatures. -- checkRecDef - :: Info.DefInfo -- ^ Position and other info. + :: A.DefInfo -- ^ Position and other info. -> QName -- ^ Record type identifier. -> UniverseCheck -- ^ Check universes? -> Maybe (Ranged Induction) -- ^ Optional: (co)inductive declaration. @@ -153,12 +148,15 @@ etaenabled <- etaEnabled - let getName :: A.Declaration -> [Arg QName] - getName (A.Field _ x arg) = [x <$ arg] + let getName :: A.Declaration -> [Dom QName] + getName (A.Field _ x arg) = [x <$ domFromArg arg] getName (A.ScopedDecl _ [f]) = getName f getName _ = [] - fs = concatMap getName fields + setTactic dom f = f { domTactic = domTactic dom } + + fs = zipWith setTactic (telToList ftel) $ concatMap getName fields + -- indCo is what the user wrote: inductive/coinductive/Nothing. -- We drop the Range. indCo = rangedThing <$> ind @@ -169,7 +167,7 @@ -- We should turn it off until it is proven to be safe. haveEta = maybe (Inferred NoEta) Specified eta -- haveEta = maybe (Inferred $ conInduction == Inductive && etaenabled) Specified eta - con = ConHead conName conInduction fs + con = ConHead conName conInduction $ map argFromDom fs -- A record is irrelevant if all of its fields are. -- In this case, the associated module parameter will be irrelevant. @@ -199,7 +197,7 @@ -- we make sure we get the original names! let npars = size tel telh = fmap hideAndRelParams tel - escapeContext npars $ do + escapeContext __IMPOSSIBLE__ npars $ do addConstant name $ defaultDefn defaultArgInfo name t $ Record @@ -229,14 +227,21 @@ , conData = name , conAbstr = Info.defAbstract conInfo , conInd = conInduction - , conComp = (emptyCompKit, Nothing) -- filled in later + , conComp = emptyCompKit -- filled in later + , conProj = Nothing -- filled in later , conForced = [] - , conErased = [] + , conErased = Nothing } -- Declare the constructor as eligible for instance search - when (Info.defInstance i == InstanceDef) $ do - addNamedInstance conName name + case Info.defInstance i of + InstanceDef r -> setCurrentRange r $ do + -- Andreas, 2020-01-28, issue #4360: + -- Use addTypedInstance instead of addNamedInstance + -- to detect unusable instances. + addTypedInstance conName contype + -- addNamedInstance conName name + NotInstanceDef -> pure () -- Check that the fields fit inside the sort _ <- fitsIn uc [] contype s @@ -285,7 +290,7 @@ -- section telescope changes the semantics, see e.g. -- test/Succeed/RecordInParModule. -- Ulf, 2016-03-02 but it's the right thing to do (#1759) - modifyContext (map hideOrKeepInstance) $ addRecordVar $ do + modifyContextInfo hideOrKeepInstance $ addRecordVar $ do -- Add the record section. @@ -293,18 +298,18 @@ [ "record section:" , nest 2 $ sep [ prettyTCM m <+> (inTopContext . prettyTCM =<< getContextTelescope) - , fsep $ punctuate comma $ map (return . P.pretty . getName) fields + , fsep $ punctuate comma $ map (return . P.pretty . map argFromDom . getName) fields ] ] reportSDoc "tc.rec.def" 15 $ nest 2 $ vcat - [ "field tel =" <+> escapeContext 1 (prettyTCM ftel) + [ "field tel =" <+> escapeContext __IMPOSSIBLE__ 1 (prettyTCM ftel) ] addSection m -- Andreas, 2016-02-09, Issue 1815 (see also issue 1759). -- For checking the record declarations, hide the record parameters -- and the parameters of the parent modules. - modifyContext (map hideOrKeepInstance) $ addRecordVar $ do + modifyContextInfo hideOrKeepInstance $ addRecordVar $ do -- Check the types of the fields and the other record declarations. withCurrentModule m $ do @@ -320,41 +325,49 @@ -- we define composition here so that the projections are already in the signature. - escapeContext npars $ do - addCompositionForRecord name con tel fs ftel rect + escapeContext __IMPOSSIBLE__ npars $ do + addCompositionForRecord name con tel (map argFromDom fs) ftel rect + -- Jesper, 2019-06-07: Check confluence of projection clauses + whenM (optConfluenceCheck <$> pragmaOptions) $ forM_ fs $ \f -> do + cls <- defClauses <$> getConstInfo (unDom f) + forM (zip cls [0..]) $ \(cl,i) -> + checkConfluenceOfClause (unDom f) i cl + return () addCompositionForRecord - :: QName -- datatype name - -> ConHead - -> Telescope -- Γ parameters - -> [Arg QName] -- projection names - -> Telescope -- Γ ⊢ Φ field types - -> Type -- Γ ⊢ T target type - -> TCM () + :: QName -- ^ Datatype name. + -> ConHead + -> Telescope -- ^ @Γ@ parameters. + -> [Arg QName] -- ^ Projection names. + -> Telescope -- ^ @Γ ⊢ Φ@ field types. + -> Type -- ^ @Γ ⊢ T@ target type. + -> TCM () addCompositionForRecord name con tel fs ftel rect = do - compWays <- do - cxt <- getContextTelescope - escapeContext (size cxt) $ - if null fs then Left . (,Just []) <$> defineCompData name con (abstract cxt tel) [] ftel rect [] - else Right <$> - ifM (return (any (== Irrelevant) $ map getRelevance fs) `and2M` do not . optIrrelevantProjections <$> pragmaOptions) - (return emptyCompKit) - (defineCompKitR name (abstract cxt tel) ftel fs rect) - case compWays of - Right kit -> do - modifySignature $ updateDefinition name $ updateTheDef $ \ d -> - case d of - r@Record{} -> r { recComp = kit } - _ -> __IMPOSSIBLE__ - Left y -> do - modifySignature $ updateDefinition (conName con) $ updateTheDef $ \ d -> - case d of - r@Constructor{} -> r { conComp = y } - _ -> __IMPOSSIBLE__ + cxt <- getContextTelescope + inTopContext $ do + -- Record has no fields: attach composition data to record constructor + if null fs then do + kit <- defineCompData name con (abstract cxt tel) [] ftel rect [] + modifySignature $ updateDefinition (conName con) $ updateTheDef $ \case + r@Constructor{} -> r { conComp = kit, conProj = Just [] } -- no projections + _ -> __IMPOSSIBLE__ + + -- Record has fields: attach composition data to record type + else do + -- If record has irrelevant fields but irrelevant projections are disabled, + -- we cannot generate composition data. + kit <- ifM (return (any isIrrelevant fs) + `and2M` do not . optIrrelevantProjections <$> pragmaOptions) + {-then-} (return emptyCompKit) + {-else-} (defineCompKitR name (abstract cxt tel) ftel fs rect) + modifySignature $ updateDefinition name $ updateTheDef $ \case + r@Record{} -> r { recComp = kit } + _ -> __IMPOSSIBLE__ + defineCompKitR :: QName -- ^ some name, e.g. record name -> Telescope -- ^ param types Δ @@ -450,7 +463,9 @@ , clauseLHSRange = noRange , clauseCatchall = False , clauseBody = Just $ rhs + , clauseRecursive = Just False -- definitely non-recursive! , clauseUnreachable = Just False + , clauseEllipsis = NoEllipsis } reportSDoc "trans.rec.face" 17 $ text $ show c return c @@ -464,7 +479,11 @@ , clauseLHSRange = noRange , clauseCatchall = False , clauseBody = Just body + , clauseRecursive = Nothing + -- Andreas 2020-02-06 TODO + -- Or: Just False; is it known to be non-recursive? , clauseUnreachable = Just False + , clauseEllipsis = NoEllipsis } reportSDoc "trans.rec" 17 $ text $ show c reportSDoc "trans.rec" 16 $ text "type =" <+> text (show (clauseType c)) @@ -473,7 +492,7 @@ return c addClauses theName $ c' : cs reportSDoc "trans.rec" 15 $ text $ "compiling clauses for " ++ show theName - (mst, cc) <- inTopContext (compileClauses Nothing cs) + (mst, _, cc) <- inTopContext (compileClauses Nothing cs) whenJust mst $ setSplitTree theName setCompiledClauses theName cc reportSDoc "trans.rec" 15 $ text $ "compiled" @@ -524,9 +543,23 @@ , "t =" <+> prettyTCM t , "ftel2 =" <+> addContext ftel1 (underAbstraction_ ftel2 prettyTCM) , "abstr =" <+> (text . show) (Info.defAbstract info) + , "quant =" <+> (text . show) (getQuantity ai) + , "coh =" <+> (text . show) (getCohesion ai) ] ] + -- Cohesion check: + -- For a field `@c π : A` we would create a projection `π : .., (@(c^-1) r : R as) -> A` + -- So we want to check that `@.., (c^-1 . c) x : A |- x : A` is allowed by the modalities. + -- + -- Alternatively we could create a projection `.. |- π r :c A` + -- but that would require support for a `t :c A` judgment. + if hasLeftAdjoint (getCohesion ai) + then unless (getCohesion ai == Continuous) + -- Andrea TODO: properly update the context/type of the projection when we add Sharp + __IMPOSSIBLE__ + else genericError $ "Cannot have record fields with modality " ++ show (getCohesion ai) + -- Andreas, 2010-09-09 The following comments are misleading, TODO: update -- in fact, tel includes the variable of record type as last one -- e.g. for cartesion product it is @@ -584,15 +617,17 @@ let bodyMod = case rel of Relevant -> id NonStrict -> id - Irrelevant -> DontCare + Irrelevant -> dontCare let -- Andreas, 2010-09-09: comment for existing code -- split the telescope into parameters (ptel) and the type or the record -- (rt) which should be R ptel telList = telToList tel - (_ptel,[rt]) = splitAt (size tel - 1) telList + (ptelList,[rt]) = splitAt (size tel - 1) telList + ptel = telFromList ptelList cpo = if hasNamedCon then PatOCon else PatORec - cpi = ConPatternInfo { conPRecord = Just cpo + cpi = ConPatternInfo { conPInfo = PatternInfo cpo [] + , conPRecord = True , conPFallThrough = False , conPType = Just $ argFromDom $ fmap snd rt , conPLazy = True } @@ -601,7 +636,7 @@ | Dom{domInfo = ai'} <- telToList ftel ] body = Just $ bodyMod $ var (size ftel2) - cltel = ftel + cltel = ptel `abstract` ftel clause = Clause { clauseLHSRange = getRange info , clauseFullRange = getRange info , clauseTel = killRange cltel @@ -609,7 +644,9 @@ , clauseBody = body , clauseType = Just $ Arg ai t , clauseCatchall = False + , clauseRecursive = Just False , clauseUnreachable = Just False + , clauseEllipsis = NoEllipsis } let projection = Projection @@ -641,14 +678,14 @@ -- projection functions are defined. Record pattern -- translation is defined in terms of projection -- functions. - (mst , cc) <- compileClauses Nothing [clause] + (mst, _, cc) <- compileClauses Nothing [clause] reportSDoc "tc.cc" 60 $ do sep [ "compiled clauses of " <+> prettyTCM projname , nest 2 $ text (show cc) ] - escapeContext (size tel) $ do + escapeContext __IMPOSSIBLE__ (size tel) $ do addConstant projname $ (defaultDefn ai projname (killRange finalt) emptyFunction @@ -658,13 +695,16 @@ , funProjection = Just projection , funMutual = Just [] -- Projections are not mutually recursive with anything , funTerminates = Just True - , funCopatternLHS = hasProjectionPatterns cc }) - { defArgOccurrences = [StrictPos] } + { defArgOccurrences = [StrictPos] + , defCopatternLHS = hasProjectionPatterns cc + } computePolarity [projname] - when (Info.defInstance info == InstanceDef) $ - addTypedInstance projname t + case Info.defInstance info of + -- fields do not have an @instance@ keyword!? + InstanceDef _r -> addTypedInstance projname t + NotInstanceDef -> pure () recurse diff --git a/src/full/Agda/TypeChecking/Rules/Term.hs b/src/full/Agda/TypeChecking/Rules/Term.hs --- a/src/full/Agda/TypeChecking/Rules/Term.hs +++ b/src/full/Agda/TypeChecking/Rules/Term.hs @@ -1,17 +1,9 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE NondecreasingIndentation #-} module Agda.TypeChecking.Rules.Term where -#if MIN_VERSION_base(4,11,0) -import Prelude hiding ( (<>), null ) -#else import Prelude hiding ( null ) -#endif -import Control.Monad.Trans -import Control.Monad.Trans.Maybe -import Control.Monad.State (get, put) import Control.Monad.Reader import Data.Maybe @@ -19,7 +11,6 @@ import Data.Monoid (mappend) import qualified Data.List as List import qualified Data.Map as Map -import qualified Data.Set as Set import Agda.Interaction.Options import Agda.Interaction.Highlighting.Generate (disambiguateRecordFields) @@ -32,15 +23,15 @@ import qualified Agda.Syntax.Concrete.Name as C import Agda.Syntax.Common import Agda.Syntax.Internal as I +import Agda.Syntax.Internal.MetaVars import Agda.Syntax.Position import Agda.Syntax.Literal import Agda.Syntax.Scope.Base ( ThingsInScope, AbstractName , emptyScopeInfo , exportedNamesInScope) -import Agda.Syntax.Scope.Monad (getNamedScope, freshAbstractQName) +import Agda.Syntax.Scope.Monad (getNamedScope) import Agda.Syntax.Translation.InternalToAbstract (reify) -import Agda.TypeChecking.Abstract import Agda.TypeChecking.CompiledClause import Agda.TypeChecking.Constraints import Agda.TypeChecking.Conversion @@ -53,7 +44,6 @@ import Agda.TypeChecking.IApplyConfluence import Agda.TypeChecking.Level import Agda.TypeChecking.MetaVars -import Agda.TypeChecking.Names import Agda.TypeChecking.Monad import Agda.TypeChecking.Monad.Builtin import Agda.TypeChecking.Patterns.Abstract @@ -79,24 +69,18 @@ import {-# SOURCE #-} Agda.TypeChecking.Rules.Application import Agda.Utils.Except - ( ExceptT - , MonadError(catchError, throwError) - , runExceptT - ) -import Agda.Utils.Function + (MonadError(catchError, throwError)) import Agda.Utils.Functor import Agda.Utils.Lens import Agda.Utils.List import Agda.Utils.Maybe import Agda.Utils.Monad import Agda.Utils.Null -import Agda.Utils.NonemptyList import Agda.Utils.Pretty ( prettyShow ) import qualified Agda.Utils.Pretty as P import Agda.Utils.Size import Agda.Utils.Tuple -#include "undefined.h" import Agda.Utils.Impossible --------------------------------------------------------------------------- @@ -105,15 +89,25 @@ -- | Check that an expression is a type. isType :: A.Expr -> Sort -> TCM Type -isType e s = - traceCall (IsTypeCall e s) $ do - v <- checkExpr e (sort s) +isType = isType' CmpLeq + +-- | Check that an expression is a type. +-- * If @c == CmpEq@, the given sort must be the minimal sort. +-- * If @c == CmpLeq@, the given sort may be any bigger sort. +isType' :: Comparison -> A.Expr -> Sort -> TCM Type +isType' c e s = + traceCall (IsTypeCall c e s) $ do + v <- checkExpr' c e (sort s) return $ El s v --- | Check that an expression is a type without knowing the sort. +-- | Check that an expression is a type and infer its (minimal) sort. isType_ :: A.Expr -> TCM Type isType_ e = traceCall (IsType_ e) $ do - let fallback = isType e =<< do workOnTypes $ newSortMeta + reportResult "tc.term.istype" 15 (\a -> vcat + [ "isType_" prettyTCM e + , nest 2 $ "returns" prettyTCM a + ]) $ do + let fallback = isType' CmpEq e =<< do workOnTypes $ newSortMeta case unScope e of A.Fun i (Arg info t) b -> do a <- setArgInfo info . defaultDom <$> isType_ t @@ -145,7 +139,7 @@ A.App i s arg | visible arg, A.Set _ 0 <- unScope s -> do - unlessM hasUniversePolymorphism $ typeError $ GenericError $ + unlessM hasUniversePolymorphism $ genericError "Use --universe-polymorphism to enable level arguments to Set" -- allow NonStrict variables when checking level -- Set : (NonStrict) Level -> Set\omega @@ -157,7 +151,7 @@ | visible arg, A.Prop _ 0 <- unScope s -> do unlessM isPropEnabled $ typeError NeedOptionProp - unlessM hasUniversePolymorphism $ typeError $ GenericError $ + unlessM hasUniversePolymorphism $ genericError "Use --universe-polymorphism to enable level arguments to Prop" applyRelevanceToContext NonStrict $ sort . Prop <$> checkLevel arg @@ -212,7 +206,9 @@ reportSDoc "tc.fun" 20 $ do let El s (Pi dom b) = tBlame sep [ "created function type " <+> prettyTCM tBlame - , "with pts rule" <+> prettyTCM (getSort dom, getSort b, s) + , "with pts rule (" <+> prettyTCM (getSort dom) <+> + "," <+> underAbstraction_ b (prettyTCM . getSort) <+> + "," <+> prettyTCM s <+> ")" ] s <- reduce $ getSort t when (s == SizeUniv) $ do @@ -278,28 +274,39 @@ -- is needed for irrelevance. checkTypedBindings :: LamOrPi -> A.TypedBinding -> (Telescope -> TCM a) -> TCM a -checkTypedBindings lamOrPi (A.TBind r xs' e) ret = do - let xs = (map . fmap . fmap) A.unBind xs' +checkTypedBindings lamOrPi (A.TBind r tac xps e) ret = do + let xs = map (updateNamedArg $ A.unBind . A.binderName) xps + tac <- traverse (checkTacticAttribute lamOrPi) tac + whenJust tac $ \ t -> reportSDoc "tc.term.tactic" 30 $ "Checked tactic attribute:" prettyTCM t -- Andreas, 2011-04-26 irrelevant function arguments may appear -- non-strictly in the codomain type -- 2011-10-04 if flag --experimental-irrelevance is set experimental <- optExperimentalIrrelevance <$> pragmaOptions - t <- modEnv lamOrPi $ isType_ e + let cs = map getCohesion xps + c = headWithDefault __IMPOSSIBLE__ cs + unless (all (c ==) cs) $ __IMPOSSIBLE__ + + t <- applyCohesionToContext c $ modEnv lamOrPi $ isType_ e + -- Jesper, 2019-02-12, Issue #3534: warn if the type of an -- instance argument does not have the right shape - unlessNull (filter isInstance xs') $ \ixs -> do + unlessNull (filter isInstance xps) $ \ixs -> do (tel, target) <- getOutputTypeName t case target of OutputTypeName{} -> return () OutputTypeVar{} -> return () - OutputTypeVisiblePi{} -> warning . InstanceArgWithExplicitArg =<< prettyTCM (A.TBind r ixs e) + OutputTypeVisiblePi{} -> warning . InstanceArgWithExplicitArg =<< prettyTCM (A.mkTBind r ixs e) OutputTypeNameNotYetKnown{} -> return () - NoOutputTypeName -> warning . InstanceNoOutputTypeName =<< prettyTCM (A.TBind r ixs e) + NoOutputTypeName -> warning . InstanceNoOutputTypeName =<< prettyTCM (A.mkTBind r ixs e) - let xs' = (map . mapRelevance) (modRel lamOrPi experimental) xs - addContext (xs', t) $ - ret $ namedBindsToTel xs t + let setTac tac EmptyTel = EmptyTel + setTac tac (ExtendTel dom tel) = ExtendTel dom{ domTactic = tac } $ setTac (raise 1 tac) <$> tel + xs' = map (modMod lamOrPi experimental) xs + let tel = setTac tac $ namedBindsToTel xs t + + addContext (xs', t) $ addTypedPatterns xps (ret tel) + where -- if we are checking a typed lambda, we resurrect before we check the -- types, but do not modify the new context entries @@ -307,19 +314,41 @@ -- modify the new context entries modEnv LamNotPi = workOnTypes modEnv _ = id - modRel PiNotLam xp = if xp then irrToNonStrict else id - modRel _ _ = id + modMod PiNotLam xp = (if xp then mapRelevance irrToNonStrict else id) + . (setQuantity topQuantity) + modMod _ _ = id checkTypedBindings lamOrPi (A.TLet _ lbs) ret = do checkLetBindings lbs (ret EmptyTel) +-- | After a typed binding has been checked, add the patterns it binds +addTypedPatterns :: [NamedArg A.Binder] -> TCM a -> TCM a +addTypedPatterns xps ret = do + let ps = mapMaybe (A.extractPattern . namedArg) xps + let lbs = fmap letBinding ps + checkLetBindings lbs ret + + where + + letBinding :: (A.Pattern, A.BindName) -> A.LetBinding + letBinding (p, n) = A.LetPatBind (A.LetRange r) p (A.Var $ A.unBind n) + where r = fuseRange p n + + +-- | Check a tactic attribute. Should have type Term → TC ⊤. +checkTacticAttribute :: LamOrPi -> A.Expr -> TCM Term +checkTacticAttribute LamNotPi e = genericDocError =<< "The @tactic attribute is not allowed here" +checkTacticAttribute PiNotLam e = do + expectedType <- el primAgdaTerm --> el (primAgdaTCM <#> primLevelZero <@> primUnit) + checkExpr e expectedType + ifPath :: Type -> TCM a -> TCM a -> TCM a ifPath ty fallback work = do pv <- pathView ty if isPathType pv then work else fallback checkPath :: A.TypedBinding -> A.Expr -> Type -> TCM Term -checkPath b@(A.TBind _ [x'] typ) body ty = do - let x = (fmap . fmap) A.unBind x' +checkPath b@(A.TBind _ _ [x'] typ) body ty = do + let x = updateNamedArg (A.unBind . A.binderName) x' info = getArgInfo x PathType s path level typ lhs rhs <- pathView ty interval <- elInf primInterval @@ -345,30 +374,33 @@ checkLambda :: Comparison -> A.TypedBinding -> A.Expr -> Type -> TCM Term checkLambda cmp (A.TLet _ lbs) body target = checkLetBindings lbs (checkExpr body target) -checkLambda cmp b@(A.TBind _ xs' typ) body target = do - reportSLn "tc.term.lambda" 60 $ "checkLambda xs = " ++ prettyShow xs - let numbinds = length xs - possiblePath = numbinds == 1 - && (case unScope typ of - A.Underscore{} -> True - _ -> False) - && isRelevant info && visible info - reportSLn "tc.term.lambda" 60 $ "possiblePath = " ++ show (possiblePath, numbinds, unScope typ, info) +checkLambda cmp b@(A.TBind _ _ xps typ) body target = do + reportSDoc "tc.term.lambda" 60 $ vcat + [ "checkLambda xs = " <+> prettyA xps + , "possiblePath = " <+> text (show (possiblePath, numbinds, unScope typ, info)) + ] TelV tel btyp <- telViewUpTo numbinds target if size tel < numbinds || numbinds /= 1 then (if possiblePath then trySeeingIfPath else dontUseTargetType) else useTargetType tel btyp + where - xs = (map . fmap . fmap) A.unBind xs' - info : _ = map getArgInfo xs + + xs = map (updateNamedArg (A.unBind . A.binderName)) xps + numbinds = length xps + isUnderscore e = case e of { A.Underscore{} -> True; _ -> False } + possiblePath = numbinds == 1 && isUnderscore (unScope typ) + && isRelevant info && visible info + info = getArgInfo (headWithDefault __IMPOSSIBLE__ xs) + trySeeingIfPath = do cubical <- optCubical <$> pragmaOptions - reportSLn "tc.term.lambda" 60 $ "trySeeingIfPath for " ++ show xs + reportSLn "tc.term.lambda" 60 $ "trySeeingIfPath for " ++ show xps let postpone' = if cubical then postpone else \ _ _ -> dontUseTargetType - ifBlockedType target postpone' $ \ _ t -> do - ifPath t dontUseTargetType $ - if cubical then checkPath b body t - else typeError $ GenericError $ "Option --cubical needed to build a path with a lambda abstraction" + ifBlocked target postpone' $ \ _ t -> do + ifPath t dontUseTargetType $ if cubical + then checkPath b body t + else genericError "Option --cubical needed to build a path with a lambda abstraction" postpone m tgt = postponeTypeCheckingProblem_ $ CheckExpr cmp (A.Lam A.exprNoRange (A.DomainFull b) body) tgt @@ -379,35 +411,44 @@ -- First check that argsT is a valid type argsT <- workOnTypes $ isType_ typ + let tel = namedBindsToTel xs argsT + reportSDoc "tc.term.lambda" 60 $ "dontUseTargetType tel =" <+> pretty tel + -- Andreas, 2015-05-28 Issue 1523 -- If argsT is a SizeLt, it must be non-empty to avoid non-termination. -- TODO: do we need to block checkExpr? checkSizeLtSat $ unEl argsT - -- In order to have as much type information as possible when checking - -- body, we first unify (xs : argsT) → ?t₁ with the target type. If this - -- is inconclusive we need to block the resulting term so we create a - -- fresh problem for the check. - let tel = namedBindsToTel xs argsT - reportSDoc "tc.term.lambda" 60 $ "dontUseTargetType tel =" <+> pretty tel + -- Jesper 2019-12-17, #4261: we need to postpone here if + -- checking of the record pattern fails; if we try to catch + -- higher up the metas created during checking of @argsT@ are + -- not available. + let postponeOnBlockedPattern m = m `catchIlltypedPatternBlockedOnMeta` \(err , x) -> do + reportSDoc "tc.term" 50 $ vcat $ + [ "checking record pattern stuck on meta: " <+> text (show x) ] + t1 <- addContext (xs, argsT) $ workOnTypes newTypeMeta_ + let e = A.Lam A.exprNoRange (A.DomainFull b) body + tgt' = telePi tel t1 + w <- postponeTypeCheckingProblem (CheckExpr cmp e tgt') $ isInstantiatedMeta x + return (tgt' , w) + + -- Now check body : ?t₁ -- DONT USE tel for addContext, as it loses NameIds. - -- WRONG: t1 <- addContext tel $ workOnTypes newTypeMeta_ - t1 <- addContext (xs, argsT) $ workOnTypes newTypeMeta_ + -- WRONG: v <- addContext tel $ checkExpr body t1 + (target0 , w) <- postponeOnBlockedPattern $ + addContext (xs, argsT) $ addTypedPatterns xps $ do + t1 <- workOnTypes newTypeMeta_ + v <- checkExpr' cmp body t1 + return (telePi tel t1 , teleLam tel v) + -- Do not coerce hidden lambdas if notVisible info || any notVisible xs then do - pid <- newProblem_ $ leqType (telePi tel t1) target - -- Now check body : ?t₁ - -- WRONG: v <- addContext tel $ checkExpr body t1 - v <- addContext (xs, argsT) $ checkExpr' cmp body t1 - -- Block on the type comparison - blockTermOnProblem target (teleLam tel v) pid - else do - -- Now check body : ?t₁ - -- WRONG: v <- addContext tel $ checkExpr body t1 - v <- addContext (xs, argsT) $ checkExpr' cmp body t1 - -- Block on the type comparison - coerce cmp (teleLam tel v) (telePi tel t1) target + pid <- newProblem_ $ leqType target0 target + blockTermOnProblem target w pid + else do + coerce cmp w target0 target + useTargetType tel@(ExtendTel dom (Abs y EmptyTel)) btyp = do verboseS "tc.term.lambda" 5 $ tick "lambda-with-target-type" reportSLn "tc.term.lambda" 60 $ "useTargetType y = " ++ y @@ -427,7 +468,8 @@ -- check. (pid, argT) <- newProblem $ isTypeEqualTo typ a -- Andreas, Issue 630: take name from function type if lambda name is "_" - v <- lambdaAddContext (namedArg x) y (defaultArgDom info argT) $ checkExpr' cmp body btyp + v <- lambdaAddContext (namedArg x) y (defaultArgDom info argT) $ + addTypedPatterns xps $ checkExpr' cmp body btyp blockTermOnProblem target (Lam info $ Abs (namedArgName x) v) pid useTargetType _ _ = __IMPOSSIBLE__ @@ -436,7 +478,7 @@ -- coming from the function type. -- If lambda has no user-given modality, copy that of function type. lambdaModalityCheck :: LensModality dom => dom -> ArgInfo -> TCM ArgInfo -lambdaModalityCheck dom = lambdaQuantityCheck m <=< lambdaIrrelevanceCheck m +lambdaModalityCheck dom = lambdaCohesionCheck m <=< lambdaQuantityCheck m <=< lambdaIrrelevanceCheck m where m = getModality dom -- | Check that irrelevance info in lambda is compatible with irrelevance @@ -468,17 +510,32 @@ lambdaQuantityCheck :: LensQuantity dom => dom -> ArgInfo -> TCM ArgInfo lambdaQuantityCheck dom info -- Case: no specific user annotation: use quantity of function type - | getQuantity info == defaultQuantity = return $ setQuantity (getQuantity dom) info + | noUserQuantity info = return $ setQuantity (getQuantity dom) info -- Case: explicit user annotation is taken seriously | otherwise = do let qPi = getQuantity dom -- quantity of function type let qLam = getQuantity info -- quantity of lambda - unless (moreQuantity qPi qLam) $ do - -- the expected use qPi cannot be unrestricted - when (qPi == Quantityω) __IMPOSSIBLE__ + unless (qPi `moreQuantity` qLam) $ do typeError WrongQuantityInLambda return info +-- | Check that cohesion info in lambda is compatible with cohesion +-- coming from the function type. +-- If lambda has no user-given cohesion, copy that of function type. +lambdaCohesionCheck :: LensCohesion dom => dom -> ArgInfo -> TCM ArgInfo +lambdaCohesionCheck dom info + -- Case: no specific user annotation: use cohesion of function type + | getCohesion info == defaultCohesion = return $ setCohesion (getCohesion dom) info + -- Case: explicit user annotation is taken seriously + | otherwise = do + let cPi = getCohesion dom -- cohesion of function type + let cLam = getCohesion info -- cohesion of lambda + unless (cPi `sameCohesion` cLam) $ do + -- if there is a cohesion annotation then + -- it better match the domain. + typeError WrongCohesionInLambda + return info + lambdaAddContext :: Name -> ArgName -> Dom Type -> TCM a -> TCM a lambdaAddContext x y dom | isNoName x = addContext (y, dom) -- Note: String instance @@ -504,6 +561,7 @@ -- to get better error messages. -- Using the type dom from the usage context would be more precise, -- though. + -- TODO: quantity let dom' = setRelevance (getRelevance info') . setHiding lamHiding $ maybe dom (dom $>) mt v <- lambdaAddContext x (absName b) dom' $ @@ -526,7 +584,7 @@ insertHiddenLambdas h target postpone ret = do -- If the target type is blocked, we postpone, -- because we do not know if a hidden lambda needs to be inserted. - ifBlockedType target postpone $ \ _ t -> do + ifBlocked target postpone $ \ _ t -> do case unEl t of Pi dom b -> do @@ -537,8 +595,8 @@ -- That's an error, as we cannot insert a visible lambda. if visible h' then typeError $ WrongHidingInLambda target else do -- Otherwise, we found a hidden argument that we can insert. - let x = absName b - Lam (domInfo dom) . Abs x <$> do + let x = absName b + Lam (setOrigin Inserted $ domInfo dom) . Abs x <$> do addContext (x, dom) $ insertHiddenLambdas h (absBody b) postpone ret _ -> typeError . GenericDocError =<< do @@ -547,9 +605,13 @@ -- | @checkAbsurdLambda i h e t@ checks absurd lambda against type @t@. -- Precondition: @e = AbsurdLam i h@ checkAbsurdLambda :: Comparison -> A.ExprInfo -> Hiding -> A.Expr -> Type -> TCM Term -checkAbsurdLambda cmp i h e t = do +checkAbsurdLambda cmp i h e t = localTC (set eQuantity topQuantity) $ do + -- Andreas, 2019-10-01: check absurd lambdas in non-erased mode. + -- Otherwise, they are not usable in meta-solutions in the term world. + -- See test/Succeed/Issue3176.agda for an absurd lambda + -- created in types. t <- instantiateFull t - ifBlockedType t (\ m t' -> postponeTypeCheckingProblem_ $ CheckExpr cmp e t') $ \ _ t' -> do + ifBlocked t (\ m t' -> postponeTypeCheckingProblem_ $ CheckExpr cmp e t') $ \ _ t' -> do case unEl t' of Pi dom@(Dom{domInfo = info', unDom = a}) b | not (sameHiding h info') -> typeError $ WrongHidingInLambda t' @@ -561,15 +623,15 @@ -- Add helper function top <- currentModule aux <- qualify top <$> freshName_ (getRange i, absurdLambdaName) - -- if we are in irrelevant position, the helper function - -- is added as irrelevant - rel <- asksTC envRelevance + -- if we are in irrelevant / erased position, the helper function + -- is added as irrelevant / erased + mod <- asksTC getModality reportSDoc "tc.term.absurd" 10 $ vcat - [ "Adding absurd function" <+> prettyTCM rel <> prettyTCM aux + [ ("Adding absurd function" <+> prettyTCM mod) <> prettyTCM aux , nest 2 $ "of type" <+> prettyTCM t' ] addConstant aux $ - (\ d -> (defaultDefn (setRelevance rel info') aux t' d) + (\ d -> (defaultDefn (setModality mod info') aux t' d) { defPolarity = [Nonvariant] , defArgOccurrences = [Unused] }) $ emptyFunction @@ -578,11 +640,13 @@ { clauseLHSRange = getRange e , clauseFullRange = getRange e , clauseTel = telFromList [fmap (absurdPatternName,) dom] - , namedClausePats = [Arg info' $ Named (Just $ unranged $ absName b) $ absurdP 0] + , namedClausePats = [Arg info' $ Named (Just $ WithOrigin Inserted $ unranged $ absName b) $ absurdP 0] , clauseBody = Nothing - , clauseType = Just $ setRelevance rel $ defaultArg $ absBody b + , clauseType = Just $ setModality mod $ defaultArg $ absBody b , clauseCatchall = False + , clauseRecursive = Just False , clauseUnreachable = Just True -- absurd clauses are unreachable + , clauseEllipsis = NoEllipsis } ] , funCompiled = Just Fail @@ -600,21 +664,25 @@ -- Precondition: @e = ExtendedLam i di qname cs@ checkExtendedLambda :: Comparison -> A.ExprInfo -> A.DefInfo -> QName -> [A.Clause] -> A.Expr -> Type -> TCM Term -checkExtendedLambda cmp i di qname cs e t = do +checkExtendedLambda cmp i di qname cs e t = localTC (set eQuantity topQuantity) $ do + -- Andreas, 2019-10-01: check extended lambdas in non-erased mode. + -- Otherwise, they are not usable in meta-solutions in the term world. + -- See test/Succeed/Issue{3581}.agda for an extended lambda + -- created in a type. -- Andreas, 2016-06-16 issue #2045 -- Try to get rid of unsolved size metas before we -- fix the type of the extended lambda auxiliary function solveSizeConstraints DontDefaultToInfty lamMod <- inFreshModuleIfFreeParams currentModule -- #2883: need a fresh module if refined params t <- instantiateFull t - ifBlockedType t (\ m t' -> postponeTypeCheckingProblem_ $ CheckExpr cmp e t') $ \ _ t -> do + ifBlocked t (\ m t' -> postponeTypeCheckingProblem_ $ CheckExpr cmp e t') $ \ _ t -> do j <- currentOrFreshMutualBlock - rel <- asksTC envRelevance - let info = setRelevance rel defaultArgInfo + mod <- asksTC getModality + let info = setModality mod defaultArgInfo reportSDoc "tc.term.exlam" 20 $ - text (show $ A.defAbstract di) <+> - "extended lambda's implementation \"" <> prettyTCM qname <> + (text (show $ A.defAbstract di) <+> + "extended lambda's implementation \"") <> prettyTCM qname <> "\" has type: " $$ prettyTCM t -- <+> " where clauses: " <+> text (show cs) args <- getContextArgs @@ -627,7 +695,7 @@ addConstant qname =<< do useTerPragma $ (defaultDefn info qname t emptyFunction) { defMutual = j } - checkFunDef' t info NotDelayed (Just $ ExtLamInfo lamMod Nothing) Nothing di qname cs + checkFunDef' t info NotDelayed (Just $ ExtLamInfo lamMod empty) Nothing di qname cs whenNothingM (asksTC envMutualBlock) $ -- Andrea 10-03-2018: Should other checks be performed here too? e.g. termination/positivity/.. checkIApplyConfluence_ qname @@ -672,7 +740,7 @@ TypeError s cl -> localTCState $ do putTC s enterClosure cl $ \case - IlltypedPattern p a -> isBlockedType a + IlltypedPattern p a -> isBlocked a SplitError (UnificationStuck c tel us vs _) -> do -- Andreas, 2018-11-23, re issue #3403 @@ -685,12 +753,12 @@ return $ firstMeta problem SplitError (NotADatatype aClosure) -> - enterClosure aClosure $ \ a -> isBlockedType a + enterClosure aClosure $ \ a -> isBlocked a -- Andrea: TODO look for blocking meta in tClosure and its Sort. -- SplitError (CannotCreateMissingClause _ _ _ tClosure) -> - CannotEliminateWithPattern p a -> isBlockedType a + CannotEliminateWithPattern p a -> isBlocked a _ -> return Nothing _ -> return Nothing @@ -737,22 +805,21 @@ :: [Either A.Assign A.ModuleName] -- ^ Modules and field assignments. -> [C.Name] -- ^ Names of fields of the record type. -> TCM A.Assigns -- ^ Completed field assignments from modules. -expandModuleAssigns mfs exs = do +expandModuleAssigns mfs xs = do let (fs , ms) = partitionEithers mfs - -- The visible fields of the record that have not been given by field assignments. - exs' = exs List.\\ map (view nameFieldA) fs - -- Getting assignments for the missing visible fields. - fs' <- forM exs' $ \ f -> do + -- The fields of the record that have not been given by field assignments @fs@ + -- are looked up in the given modules @ms@. + fs' <- forM (xs List.\\ map (view nameFieldA) fs) $ \ f -> do -- Get the possible assignments for field f from the modules. pms <- forM ms $ \ m -> do - modScope <- getNamedScope m - let names :: ThingsInScope AbstractName - names = exportedNamesInScope modScope - return $ + modScope <- getNamedScope m + let names :: ThingsInScope AbstractName + names = exportedNamesInScope modScope + return $ case Map.lookup f names of - Just [n] -> Just (m, FieldAssignment f (A.nameExpr n)) + Just [n] -> Just (m, FieldAssignment f $ killRange $ A.nameToExpr n) _ -> Nothing -- If we have several matching assignments, that's an error. @@ -780,7 +847,7 @@ [ "checking record expression" , prettyA e ] - ifBlockedType t (\ _ t -> guessRecordType t) {-else-} $ \ _ t -> do + ifBlocked t (\ _ t -> guessRecordType t) {-else-} $ \ _ t -> do case unEl t of -- Case: We know the type of the record already. Def r es -> do @@ -788,7 +855,7 @@ reportSDoc "tc.term.rec" 20 $ text $ " r = " ++ prettyShow r reportSDoc "tc.term.rec" 30 $ " xs = " <> do - text =<< prettyShow . map unArg <$> getRecordFieldNames r + text =<< prettyShow . map unDom <$> getRecordFieldNames r reportSDoc "tc.term.rec" 30 $ " ftel= " <> do prettyTCM =<< getRecordFieldTypes r reportSDoc "tc.term.rec" 30 $ " con = " <> do @@ -796,7 +863,7 @@ def <- getRecordDef r let -- Field names (C.Name) with ArgInfo from record type definition. - cxs = recordFieldNames def + cxs = map argFromDom $ recordFieldNames def -- Just field names. xs = map unArg cxs -- Record constructor. @@ -810,7 +877,7 @@ -- Andreas, 2018-09-06, issue #3122. -- Associate the concrete record field names used in the record expression -- to their counterpart in the record type definition. - disambiguateRecordFields (map _nameFieldA $ lefts mfs) (map unArg $ recFields def) + disambiguateRecordFields (map _nameFieldA $ lefts mfs) (map unDom $ recFields def) -- Compute the list of given fields, decorated with the ArgInfo from the record def. -- Andreas, 2019-03-18, issue #3122, also pick up non-visible fields from the modules. @@ -842,9 +909,9 @@ case rs of -- If there are no records with the right fields we might as well fail right away. [] -> case fields of - [] -> typeError $ GenericError "There are no records in scope" - [f] -> typeError $ GenericError $ "There is no known record with the field " ++ prettyShow f - _ -> typeError $ GenericError $ "There is no known record with the fields " ++ unwords (map prettyShow fields) + [] -> genericError "There are no records in scope" + [f] -> genericError $ "There is no known record with the field " ++ prettyShow f + _ -> genericError $ "There is no known record with the fields " ++ unwords (map prettyShow fields) -- If there's only one record with the appropriate fields, go with that. [r] -> do def <- getConstInfo r @@ -876,23 +943,32 @@ ] postponeTypeCheckingProblem_ $ CheckExpr cmp e t --- | @checkRecordUpdate ei recexpr fs e t@ --- Precondition @e = RecUpdate ei recexpr fs@. -checkRecordUpdate :: Comparison -> A.ExprInfo -> A.Expr -> A.Assigns -> A.Expr -> Type -> TCM Term +-- | @checkRecordUpdate cmp ei recexpr fs e t@ +-- +-- Preconditions: @e = RecUpdate ei recexpr fs@ and @t@ is reduced. +-- +checkRecordUpdate + :: Comparison -- ^ @cmp@ + -> A.ExprInfo -- ^ @ei@ + -> A.Expr -- ^ @recexpr@ + -> A.Assigns -- ^ @fs@ + -> A.Expr -- ^ @e = RecUpdate ei recexpr fs@ + -> Type -- ^ Reduced. + -> TCM Term checkRecordUpdate cmp ei recexpr fs e t = do case unEl t of Def r vs -> do v <- checkExpr' cmp recexpr t name <- freshNoName (getRange recexpr) addLetBinding defaultArgInfo name v t $ do - projs <- recFields <$> getRecordDef r + projs <- map argFromDom . recFields <$> getRecordDef r -- Andreas, 2018-09-06, issue #3122. -- Associate the concrete record field names used in the record expression -- to their counterpart in the record type definition. disambiguateRecordFields (map _nameFieldA fs) (map unArg projs) - axs <- getRecordFieldNames r + axs <- map argFromDom <$> getRecordFieldNames r let xs = map unArg axs es <- orderFields r (\ _ -> Nothing) axs $ map (\ (FieldAssignment x e) -> (x, Just e)) fs let es' = zipWith (replaceFields name ei) projs es @@ -937,30 +1013,46 @@ checkExpr :: A.Expr -> Type -> TCM Term checkExpr = checkExpr' CmpLeq -checkExpr' :: Comparison -> A.Expr -> Type -> TCM Term -checkExpr' cmp e t0 = +-- Andreas, 2019-10-13, issue #4125: +-- For the sake of readable types in interactive program construction, +-- avoid unnecessary unfoldings via 'reduce' in the type checker! +checkExpr' + :: Comparison + -> A.Expr + -> Type -- ^ Unreduced! + -> TCM Term +checkExpr' cmp e t = verboseBracket "tc.term.expr.top" 5 "checkExpr" $ - traceCall (CheckExprCall cmp e t0) $ localScope $ doExpandLast $ unfoldInlined =<< do + reportResult "tc.term.expr.top" 15 (\ v -> vcat + [ "checkExpr" fsep [ prettyTCM e, ":", prettyTCM t ] + , " returns" prettyTCM v ]) $ + traceCall (CheckExprCall cmp e t) $ localScope $ doExpandLast $ unfoldInlined =<< do reportSDoc "tc.term.expr.top" 15 $ "Checking" <+> sep - [ fsep [ prettyTCM e, ":", prettyTCM t0 ] + [ fsep [ prettyTCM e, ":", prettyTCM t ] , nest 2 $ "at " <+> (text . prettyShow =<< getCurrentRange) ] reportSDoc "tc.term.expr.top.detailed" 80 $ - "Checking" <+> fsep [ prettyTCM e, ":", text (show t0) ] - t <- reduce t0 + "Checking" <+> fsep [ prettyTCM e, ":", text (show t) ] + tReduced <- reduce t reportSDoc "tc.term.expr.top" 15 $ - " --> " <+> prettyTCM t + " --> " <+> prettyTCM tReduced e <- scopedExpr e - tryInsertHiddenLambda e t $ case e of + irrelevantIfProp <- isPropM t >>= \case + True -> do + let mod = defaultModality { modRelevance = Irrelevant } + return $ fmap dontCare . applyModalityToContext mod + False -> return id + irrelevantIfProp $ tryInsertHiddenLambda e tReduced $ case e of + A.ScopedExpr scope e -> __IMPOSSIBLE__ -- setScope scope >> checkExpr e t -- a meta variable without arguments: type check directly for efficiency - A.QuestionMark i ii -> checkQuestionMark (newValueMeta' RunMetaOccursCheck) t0 i ii - A.Underscore i -> checkUnderscore t0 i + A.QuestionMark i ii -> checkQuestionMark (newValueMeta' RunMetaOccursCheck) cmp t i ii + A.Underscore i -> checkUnderscore cmp t i A.WithApp _ e es -> typeError $ NotImplemented "type checking of with application" @@ -968,7 +1060,7 @@ A.App i s arg@(Arg ai l) | A.Set _ 0 <- unScope s, visible ai -> ifNotM hasUniversePolymorphism - (typeError $ GenericError "Use --universe-polymorphism to enable level arguments to Set") + (genericError "Use --universe-polymorphism to enable level arguments to Set") $ {- else -} do -- allow NonStrict variables when checking level -- Set : (NonStrict) Level -> Set\omega @@ -983,7 +1075,7 @@ A.App i s arg@(Arg ai l) | A.Prop _ 0 <- unScope s, visible ai -> ifNotM hasUniversePolymorphism - (typeError $ GenericError "Use --universe-polymorphism to enable level arguments to Prop") + (genericError "Use --universe-polymorphism to enable level arguments to Prop") $ {- else -} do n <- applyRelevanceToContext NonStrict $ checkLevel arg reportSDoc "tc.univ.poly" 10 $ @@ -997,13 +1089,13 @@ quoted (A.Macro x) = return x quoted (A.Proj o p) | Just x <- getUnambiguous p = return x quoted (A.Proj o p) = - typeError $ GenericError $ "quote: Ambigous name: " ++ prettyShow (unAmbQ p) + genericError $ "quote: Ambigous name: " ++ prettyShow (unAmbQ p) quoted (A.Con c) | Just x <- getUnambiguous c = return x quoted (A.Con c) = - typeError $ GenericError $ "quote: Ambigous name: " ++ prettyShow (unAmbQ c) + genericError $ "quote: Ambigous name: " ++ prettyShow (unAmbQ c) quoted (A.ScopedExpr _ e) = quoted e quoted _ = - typeError $ GenericError $ "quote: not a defined name" + genericError "quote: not a defined name" x <- quoted (namedThing e) ty <- qNameType coerce cmp (quoteName x) ty t @@ -1012,9 +1104,9 @@ (et, _) <- inferExpr (namedThing e) doQuoteTerm cmp et t - A.Quote _ -> typeError $ GenericError "quote must be applied to a defined name" - A.QuoteTerm _ -> typeError $ GenericError "quoteTerm must be applied to a term" - A.Unquote _ -> typeError $ GenericError "unquote must be applied to a term" + A.Quote{} -> genericError "quote must be applied to a defined name" + A.QuoteTerm{} -> genericError "quoteTerm must be applied to a term" + A.Unquote{} -> genericError "unquote must be applied to a term" A.AbsurdLam i h -> checkAbsurdLambda cmp i h e t @@ -1022,8 +1114,9 @@ A.Lam i (A.DomainFull b) e -> checkLambda cmp b e t - A.Lam i (A.DomainFree x) e0 - | isNothing (nameOf $ unArg x) -> checkExpr' cmp (A.Lam i (domainFree (getArgInfo x) $ A.unBind $ namedArg x) e0) t + A.Lam i (A.DomainFree _ x) e0 + | isNothing (nameOf $ unArg x) && isNothing (A.binderPattern $ namedArg x) -> + checkExpr' cmp (A.Lam i (domainFree (getArgInfo x) $ fmap A.unBind $ namedArg x) e0) t | otherwise -> typeError $ NotImplemented "named arguments in lambdas" A.Lit lit -> checkLiteral lit t @@ -1059,9 +1152,10 @@ A.Fun _ (Arg info a) b -> do a' <- isType_ a + let adom = defaultArgDom info a' b' <- isType_ b s <- inferFunSort (getSort a') (getSort b') - let v = Pi (defaultArgDom info a') (NoAbs underscore b') + let v = Pi adom (NoAbs underscore b') noFunctionsIntoSize b' $ El s v coerce cmp v (sort s) t A.Set _ n -> do @@ -1072,47 +1166,16 @@ A.Rec _ fs -> checkRecordExpression cmp fs e t - A.RecUpdate ei recexpr fs -> checkRecordUpdate cmp ei recexpr fs e t + A.RecUpdate ei recexpr fs -> checkRecordUpdate cmp ei recexpr fs e tReduced A.DontCare e -> -- resurrect vars - ifM ((Irrelevant ==) <$> asksTC envRelevance) + ifM ((Irrelevant ==) <$> asksTC getRelevance) (dontCare <$> do applyRelevanceToContext Irrelevant $ checkExpr' cmp e t) (internalError "DontCare may only appear in irrelevant contexts") - e0@(A.QuoteGoal _ x e) -> do - qg <- quoteGoal t - case qg of - Left metas -> postponeTypeCheckingProblem (CheckExpr cmp e0 t) $ andM $ map isInstantiatedMeta metas - Right quoted -> do - tmType <- agdaTermType - (v, ty) <- addLetBinding defaultArgInfo x quoted tmType (inferExpr e) - coerce cmp v ty t - e0@(A.QuoteContext _) -> do - qc <- quoteContext - case qc of - Left metas -> postponeTypeCheckingProblem (CheckExpr cmp e0 t) $ andM $ map isInstantiatedMeta metas - Right quotedContext -> do - ctxType <- el $ list $ primArg <@> (unEl <$> agdaTypeType) - coerce cmp quotedContext ctxType t - e0@(A.Tactic i e xs ys) -> do - qc <- quoteContext - qg <- quoteGoal t - let postpone metas = postponeTypeCheckingProblem (CheckExpr cmp e0 t) $ andM $ map isInstantiatedMeta metas - case (qc, qg) of - (Left metas1, Left metas2) -> postpone $ metas1 ++ metas2 - (Left metas , Right _ ) -> postpone $ metas - (Right _ , Left metas ) -> postpone $ metas - (Right quotedCtx, Right quotedGoal) -> do - quotedCtx <- defaultNamedArg <$> reify quotedCtx - quotedGoal <- defaultNamedArg <$> reify quotedGoal - let ai = A.defaultAppInfo (getRange i) - tac = foldl (A.App ai) (A.App ai (A.App ai e quotedCtx) quotedGoal) xs - result = foldl (A.App ai) (A.Unquote i) (defaultNamedArg tac : ys) - checkExpr' cmp result t - A.ETel _ -> __IMPOSSIBLE__ - A.Dot{} -> typeError $ GenericError $ "Invalid dotted expression" + A.Dot{} -> genericError "Invalid dotted expression" -- Application _ | Application hd args <- appView e -> checkApplication cmp hd args e t @@ -1129,20 +1192,28 @@ where -- | Call checkExpr with an hidden lambda inserted if appropriate, -- else fallback. - tryInsertHiddenLambda :: A.Expr -> Type -> TCM Term -> TCM Term - tryInsertHiddenLambda e t fallback + tryInsertHiddenLambda + :: A.Expr + -> Type -- ^ Reduced. + -> TCM Term + -> TCM Term + tryInsertHiddenLambda e tReduced fallback -- Insert hidden lambda if all of the following conditions are met: - -- type is a hidden function type, {x : A} -> B or {{x : A}} -> B - | Pi (Dom{domInfo = info, unDom = a}) b <- unEl t + -- type is a hidden function type, {x : A} -> B or {{x : A}} -> B + -- expression is not a lambda with the appropriate hiding yet + | Pi (Dom{domInfo = info, unDom = a}) b <- unEl tReduced , let h = getHiding info , notVisible h -- expression is not a matching hidden lambda or question mark , not (hiddenLambdaOrHole h e) = do - let proceed = doInsert info $ absName b + let proceed = doInsert (setOrigin Inserted info) $ absName b + expandHidden <- asksTC envExpandLast -- If we skip the lambda insertion for an introduction, -- we will hit a dead end, so proceed no matter what. - if definitelyIntroduction then proceed else do + if definitelyIntroduction then proceed else + -- #3019 and #4170: don't insert implicit lambdas in arguments to existing metas + if expandHidden == ReallyDontExpandLast then fallback else do -- Andreas, 2017-01-19, issue #2412: -- We do not want to insert a hidden lambda if A is -- possibly empty type of sizes, as this will produce an error. @@ -1161,7 +1232,7 @@ doInsert info y = do x <- C.setNotInScope <$> freshName rx y reportSLn "tc.term.expr.impl" 15 $ "Inserting implicit lambda" - checkExpr' cmp (A.Lam (A.ExprRange re) (domainFree info x) e) t + checkExpr' cmp (A.Lam (A.ExprRange re) (domainFree info $ A.mkBinder x) e) tReduced hiddenLambdaOrHole h e = case e of A.AbsurdLam _ h' -> sameHiding h h' @@ -1188,6 +1259,7 @@ A.ScopedExpr{} -> __IMPOSSIBLE__ A.ETel{} -> __IMPOSSIBLE__ _ -> False + --------------------------------------------------------------------------- -- * Reflection --------------------------------------------------------------------------- @@ -1202,27 +1274,6 @@ coerce cmp q ty t metas -> postponeTypeCheckingProblem (DoQuoteTerm cmp et t) $ andM $ map isInstantiatedMeta metas --- | Checking `quoteGoal` (deprecated) -quoteGoal :: Type -> TCM (Either [MetaId] Term) -quoteGoal t = do - t' <- etaContract =<< instantiateFull t - case allMetasList t' of - [] -> do - quotedGoal <- quoteTerm (unEl t') - return $ Right quotedGoal - metas -> return $ Left metas - --- | Checking `quoteContext` (deprecated) -quoteContext :: TCM (Either [MetaId] Term) -quoteContext = do - contextTypes <- map (fmap snd) <$> getContext - contextTypes <- etaContract =<< instantiateFull contextTypes - case allMetasList contextTypes of - [] -> do - quotedContext <- buildList <*> mapM quoteDom contextTypes - return $ Right quotedContext - metas -> return $ Left metas - -- | Unquote a TCM computation in a given hole. unquoteM :: A.Expr -> Term -> Type -> TCM () unquoteM tacA hole holeType = do @@ -1233,6 +1284,9 @@ -- given by the third argument. Runs the continuation if successful. unquoteTactic :: Term -> Term -> Type -> TCM () unquoteTactic tac hole goal = do + reportSDoc "tc.term.tactic" 40 $ sep + [ "Running tactic" <+> prettyTCM tac + , nest 2 $ "on" <+> prettyTCM hole <+> ":" <+> prettyTCM goal ] ok <- runUnquoteM $ unquoteTCM tac hole case ok of Left (BlockedOnMeta oldState x) -> do @@ -1255,10 +1309,17 @@ --------------------------------------------------------------------------- -- | Check an interaction point without arguments. -checkQuestionMark :: (Type -> TCM (MetaId, Term)) -> Type -> A.MetaInfo -> InteractionId -> TCM Term -checkQuestionMark new t0 i ii = do +checkQuestionMark + :: (Comparison -> Type -> TCM (MetaId, Term)) + -> Comparison + -> Type -- ^ Not reduced! + -> A.MetaInfo + -> InteractionId + -> TCM Term +checkQuestionMark new cmp t0 i ii = do reportSDoc "tc.interaction" 20 $ sep [ "Found interaction point" + , text . show =<< asksTC (^. lensIsAbstract) , pretty ii , ":" , prettyTCM t0 @@ -1267,32 +1328,36 @@ [ "Raw:" , text (show t0) ] - checkMeta (newQuestionMark' new ii) t0 i -- Andreas, 2013-05-22 use unreduced type t0! + checkMeta (newQuestionMark' new ii) cmp t0 i -- Andreas, 2013-05-22 use unreduced type t0! -- | Check an underscore without arguments. -checkUnderscore :: Type -> A.MetaInfo -> TCM Term +checkUnderscore :: Comparison -> Type -> A.MetaInfo -> TCM Term checkUnderscore = checkMeta (newValueMeta RunMetaOccursCheck) -- | Type check a meta variable. -checkMeta :: (Type -> TCM (MetaId, Term)) -> Type -> A.MetaInfo -> TCM Term -checkMeta newMeta t i = fst <$> checkOrInferMeta newMeta (Just t) i +checkMeta :: (Comparison -> Type -> TCM (MetaId, Term)) -> Comparison -> Type -> A.MetaInfo -> TCM Term +checkMeta newMeta cmp t i = fst <$> checkOrInferMeta newMeta (Just (cmp , t)) i -- | Infer the type of a meta variable. -- If it is a new one, we create a new meta for its type. -inferMeta :: (Type -> TCM (MetaId, Term)) -> A.MetaInfo -> TCM (Elims -> Term, Type) +inferMeta :: (Comparison -> Type -> TCM (MetaId, Term)) -> A.MetaInfo -> TCM (Elims -> Term, Type) inferMeta newMeta i = mapFst applyE <$> checkOrInferMeta newMeta Nothing i -- | Type check a meta variable. -- If its type is not given, we return its type, or a fresh one, if it is a new meta. -- If its type is given, we check that the meta has this type, and we return the same -- type. -checkOrInferMeta :: (Type -> TCM (MetaId, Term)) -> Maybe Type -> A.MetaInfo -> TCM (Term, Type) +checkOrInferMeta + :: (Comparison -> Type -> TCM (MetaId, Term)) + -> Maybe (Comparison , Type) + -> A.MetaInfo + -> TCM (Term, Type) checkOrInferMeta newMeta mt i = do case A.metaNumber i of Nothing -> do setScope (A.metaScope i) - t <- maybe (workOnTypes $ newTypeMeta_) return mt - (x, v) <- newMeta t + (cmp , t) <- maybe ((CmpEq,) <$> workOnTypes newTypeMeta_) return mt + (x, v) <- newMeta cmp t setMetaNameSuggestion x (A.metaNameSuggestion i) return (v, t) -- Rechecking an existing metavariable @@ -1300,25 +1365,26 @@ let v = MetaV x [] reportSDoc "tc.meta.check" 20 $ "checking existing meta " <+> prettyTCM v - t' <- jMetaType . mvJudgement <$> lookupMeta x + t' <- metaType x reportSDoc "tc.meta.check" 20 $ nest 2 $ "of type " <+> prettyTCM t' case mt of Nothing -> return (v, t') - Just t -> (,t) <$> coerce CmpLeq v t' t + Just (cmp , t) -> (,t) <$> coerce cmp v t' t -- | Turn a domain-free binding (e.g. lambda) into a domain-full one, -- by inserting an underscore for the missing type. -domainFree :: ArgInfo -> A.Name -> A.LamBinding +domainFree :: ArgInfo -> A.Binder' A.Name -> A.LamBinding domainFree info x = - A.DomainFull $ A.TBind r [unnamedArg info $ A.BindName x] $ A.Underscore underscoreInfo + A.DomainFull $ A.mkTBind r [unnamedArg info $ fmap A.mkBindName x] + $ A.Underscore underscoreInfo where r = getRange x underscoreInfo = A.MetaInfo { A.metaRange = r , A.metaScope = emptyScopeInfo , A.metaNumber = Nothing - , A.metaNameSuggestion = prettyShow $ A.nameConcrete x + , A.metaNameSuggestion = prettyShow $ A.nameConcrete $ A.binderName x } @@ -1348,11 +1414,17 @@ -> TCM (Args, Type) -- ^ Remaining inferred arguments, remaining type. checkKnownArgument arg [] _ = genericDocError =<< do "Invalid projection parameter " <+> prettyA arg -checkKnownArgument arg@(Arg info e) (Arg _infov v : vs) t = do - (Dom{domInfo = info',unDom = a}, b) <- mustBePi t +-- Andreas, 2019-07-22, while #3353: we should use domName, not absName !! +-- WAS: +-- checkKnownArgument arg@(Arg info e) (Arg _infov v : vs) t = do +-- (dom@Dom{domInfo = info',unDom = a}, b) <- mustBePi t +-- -- Skip the arguments from vs that do not correspond to e +-- if not (sameHiding info info' +-- && (visible info || maybe True (absName b ==) (bareNameOf e))) +checkKnownArgument arg (Arg _ v : vs) t = do -- Skip the arguments from vs that do not correspond to e - if not (sameHiding info info' - && (visible info || maybe True ((absName b ==) . rangedThing) (nameOf e))) + (dom@Dom{ unDom = a }, b) <- mustBePi t + if not $ fromMaybe __IMPOSSIBLE__ $ fittingNamedArg arg dom -- Continue with the next one then checkKnownArgument arg vs (b `absApp` v) -- Found the right argument @@ -1366,7 +1438,7 @@ checkNamedArg :: NamedArg A.Expr -> Type -> TCM Term checkNamedArg arg@(Arg info e0) t0 = do let e = namedThing e0 - let x = maybe "" rangedThing $ nameOf e0 + let x = bareNameWithDefault "" e0 traceCall (CheckExprCall CmpLeq e t0) $ do reportSDoc "tc.term.args.named" 15 $ do "Checking named arg" <+> sep @@ -1375,8 +1447,8 @@ reportSLn "tc.term.args.named" 75 $ " arg = " ++ show (deepUnscope arg) -- Ulf, 2017-03-24: (#2172) Always treat explicit _ and ? as implicit -- argument (i.e. solve with unification). - let checkU = checkMeta (newMetaArg (setHiding Hidden info) x) t0 - let checkQ = checkQuestionMark (newInteractionMetaArg (setHiding Hidden info) x) t0 + let checkU = checkMeta (newMetaArg (setHiding Hidden info) x) CmpLeq t0 + let checkQ = checkQuestionMark (newInteractionMetaArg (setHiding Hidden info) x) CmpLeq t0 if not $ isHole e then checkExpr e t0 else localScope $ do -- Note: we need localScope here, -- as scopedExpr manipulates the scope in the state. @@ -1498,7 +1570,8 @@ , nest 2 $ vcat [ "p (A) =" <+> prettyA p , "t =" <+> prettyTCM t - , "cxtRel=" <+> do pretty =<< asksTC envRelevance + , "cxtRel=" <+> do pretty =<< asksTC getRelevance + , "cxtQnt=" <+> do pretty =<< asksTC getQuantity ] ] fvs <- getContextSize @@ -1510,7 +1583,8 @@ reportSDoc "tc.term.let.pattern" 20 $ nest 2 $ vcat [ "p (I) =" <+> prettyTCM p , "delta =" <+> prettyTCM delta - , "cxtRel=" <+> do pretty =<< asksTC envRelevance + , "cxtRel=" <+> do pretty =<< asksTC getRelevance + , "cxtQnt=" <+> do pretty =<< asksTC getQuantity ] reportSDoc "tc.term.let.pattern" 80 $ nest 2 $ vcat [ "p (I) =" <+> (text . show) p diff --git a/src/full/Agda/TypeChecking/Serialise.hs b/src/full/Agda/TypeChecking/Serialise.hs --- a/src/full/Agda/TypeChecking/Serialise.hs +++ b/src/full/Agda/TypeChecking/Serialise.hs @@ -1,3 +1,4 @@ +{-# LANGUAGE CPP #-} -- Andreas, Makoto, Francesco 2014-10-15 AIM XX: -- -O2 does not have any noticable effect on runtime @@ -22,6 +23,9 @@ ) where +import System.Directory ( createDirectoryIfMissing ) +import System.FilePath ( takeDirectory ) + import Control.Arrow (second) import Control.DeepSeq import qualified Control.Exception as E @@ -31,6 +35,7 @@ import Data.Array.IArray import Data.Word +import qualified Data.ByteString.Builder as L import qualified Data.ByteString.Lazy as L import qualified Data.HashTable.IO as H import qualified Data.Map as Map @@ -39,33 +44,51 @@ import qualified Data.Binary.Put as B import qualified Data.List as List import Data.Function +import Data.Monoid import qualified Codec.Compression.GZip as G +import qualified Codec.Compression.Zlib.Internal as Z +#if __GLASGOW_HASKELL__ >= 804 +import GHC.Compact as C +#endif + +import Agda.Interaction.Options + import qualified Agda.TypeChecking.Monad.Benchmark as Bench import Agda.TypeChecking.Serialise.Base -import Agda.TypeChecking.Serialise.Instances () +import Agda.TypeChecking.Serialise.Instances () --instance only import Agda.TypeChecking.Monad import Agda.Utils.Hash import Agda.Utils.IORef -import Agda.Utils.Lens import Agda.Utils.Except +import Agda.Utils.Monad -- Note that the Binary instance for Int writes 64 bits, but throws -- away the 32 high bits when reading (at the time of writing, on -- 32-bit machines). Word64 does not have these problems. currentInterfaceVersion :: Word64 -currentInterfaceVersion = 20190328 * 10 + 0 +currentInterfaceVersion = 20200305 * 10 + 0 +-- | The result of 'encode' and 'encodeInterface'. + +data Encoded = Encoded + { uncompressed :: L.ByteString + -- ^ The uncompressed bytestring, without hashes and the interface + -- version. + , compressed :: L.ByteString + -- ^ The compressed bytestring. + } + -- | Encodes something. To ensure relocatability file paths in -- positions are replaced with module names. -encode :: EmbPrj a => a -> TCM L.ByteString +encode :: EmbPrj a => a -> TCM Encoded encode a = do collectStats <- hasVerbosity "profile.serialize" 20 fileMod <- sourceToModule @@ -110,15 +133,21 @@ cbits <- Bench.billTo [ Bench.Serialization, Bench.Compress ] $ return $!! G.compressWith compressParams bits1 let x = B.encode currentInterfaceVersion `L.append` cbits - return x + return (Encoded { uncompressed = bits1, compressed = x }) where l h = List.map fst . List.sortBy (compare `on` snd) <$> H.toList h benchSort = Bench.billTo [Bench.Serialization, Bench.Sort] . liftIO statistics :: String -> IORef FreshAndReuse -> TCM () statistics kind ioref = do - FreshAndReuse fresh reused <- liftIO $ readIORef ioref + FreshAndReuse fresh +#ifdef DEBUG + reused +#endif + <- liftIO $ readIORef ioref tickN (kind ++ " (fresh)") $ fromIntegral fresh +#ifdef DEBUG tickN (kind ++ " (reused)") $ fromIntegral reused +#endif -- encode :: EmbPrj a => a -> TCM L.ByteString -- encode a = do @@ -137,48 +166,49 @@ -- where -- l h = List.map fst . List.sortBy (compare `on` snd) <$> H.toList h --- | Decodes something. The result depends on the include path. +-- | Decodes an uncompressed bytestring (without extra hashes or magic +-- numbers). The result depends on the include path. -- --- Returns 'Nothing' if the input does not start with the right magic --- number or some other decoding error is encountered. +-- Returns 'Nothing' if a decoding error is encountered. decode :: EmbPrj a => L.ByteString -> TCM (Maybe a) decode s = do mf <- useTC stModuleToSource incs <- getIncludeDirs - -- Note that B.runGetState and G.decompress can raise errors if the - -- input is malformed. The decoder is (intended to be) strict enough - -- to ensure that all such errors can be caught by the handler here. + -- Note that runGetState can raise errors if the input is malformed. + -- The decoder is (intended to be) strict enough to ensure that all + -- such errors can be caught by the handler here. (mf, r) <- liftIO $ E.handle (\(E.ErrorCall s) -> noResult s) $ do - (ver, s, _) <- return $ runGetState B.get s 0 - if ver /= currentInterfaceVersion - then noResult "Wrong interface version." + ((r, nL, sL, bL, iL, dL), s, _) <- return $ runGetState B.get s 0 + if s /= L.empty + then noResult "Garbage at end." else do - ((r, nL, sL, bL, iL, dL), s, _) <- - return $ runGetState B.get (G.decompress s) 0 - if s /= L.empty - -- G.decompress seems to throw away garbage at the end, so - -- the then branch is possibly dead code. - then noResult "Garbage at end." - else do - - st <- St (ar nL) (ar sL) (ar bL) (ar iL) (ar dL) - <$> liftIO H.new - <*> return mf <*> return incs - (r, st) <- runStateT (runExceptT (value r)) st - return (Just $ modFile st, r) + st <- St (ar nL) (ar sL) (ar bL) (ar iL) (ar dL) + <$> liftIO H.new + <*> return mf <*> return incs + (r, st) <- runStateT (runExceptT (value r)) st + return (Just $ modFile st, r) case mf of Nothing -> return () Just mf -> stModuleToSource `setTCLens` mf case r of - Right x -> return (Just x) - Left err -> do + Right x -> do +#if __GLASGOW_HASKELL__ >= 804 + -- "Compact" the interfaces (without breaking sharing) to + -- reduce the amount of memory that is traversed by the + -- garbage collector. + Bench.billTo [Bench.Deserialization, Bench.Compaction] $ + liftIO (Just . C.getCompact <$> C.compactWithSharing x) +#else + return (Just x) +#endif + Left err -> do reportSLn "import.iface" 5 $ "Error when decoding interface file" -- Andreas, 2014-06-11 deactivated debug printing -- in order to get rid of dependency of Serialize on TCM.Pretty @@ -192,25 +222,63 @@ noResult s = return (Nothing, Left $ GenericError s) -encodeInterface :: Interface -> TCM L.ByteString -encodeInterface i = L.append hashes <$> encode i +encodeInterface :: Interface -> TCM Encoded +encodeInterface i = do + r <- encode i + return (r { compressed = L.append hashes (compressed r) }) where hashes :: L.ByteString hashes = B.runPut $ B.put (iSourceHash i) >> B.put (iFullHash i) --- | Encodes something. To ensure relocatability file paths in +-- | Encodes an interface. To ensure relocatability file paths in -- positions are replaced with module names. +-- +-- An uncompressed bytestring corresponding to the encoded interface +-- is returned. -encodeFile :: FilePath -> Interface -> TCM () -encodeFile f i = liftIO . L.writeFile f =<< encodeInterface i +encodeFile :: FilePath -> Interface -> TCM L.ByteString +encodeFile f i = do + r <- encodeInterface i + liftIO $ createDirectoryIfMissing True (takeDirectory f) + liftIO $ L.writeFile f (compressed r) + return (uncompressed r) --- | Decodes something. The result depends on the include path. +-- | Decodes an interface. The result depends on the include path. -- -- Returns 'Nothing' if the file does not start with the right magic -- number or some other decoding error is encountered. decodeInterface :: L.ByteString -> TCM (Maybe Interface) -decodeInterface s = decode $ L.drop 16 s +decodeInterface s = do + + -- Note that runGetState and the decompression code below can raise + -- errors if the input is malformed. The decoder is (intended to be) + -- strict enough to ensure that all such errors can be caught by the + -- handler here or the one in decode. + + s <- liftIO $ + E.handle (\(E.ErrorCall s) -> return (Left s)) $ + E.evaluate $ + let (ver, s', _) = runGetState B.get (L.drop 16 s) 0 in + if ver /= currentInterfaceVersion + then Left "Wrong interface version." + else Right $ + L.toLazyByteString $ + Z.foldDecompressStreamWithInput + (\s -> (L.byteString s <>)) + (\s -> if L.null s + then mempty + else error "Garbage at end.") + (\err -> error (show err)) + (Z.decompressST Z.gzipFormat Z.defaultDecompressParams) + s' + + case s of + Right s -> decode s + Left err -> do + reportSLn "import.iface" 5 $ + "Error when decoding interface file: " ++ err + return Nothing decodeHashes :: L.ByteString -> Maybe (Hash, Hash) decodeHashes s diff --git a/src/full/Agda/TypeChecking/Serialise/Base.hs b/src/full/Agda/TypeChecking/Serialise/Base.hs --- a/src/full/Agda/TypeChecking/Serialise/Base.hs +++ b/src/full/Agda/TypeChecking/Serialise/Base.hs @@ -1,13 +1,13 @@ {-# LANGUAGE CPP #-} -{-# LANGUAGE DataKinds #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-} +{-# LANGUAGE DataKinds #-} {-# LANGUAGE UndecidableInstances #-} module Agda.TypeChecking.Serialise.Base where import Control.Exception (evaluate) -import Control.Monad + import Control.Monad.Catch (catchAll) import Control.Monad.Reader import Control.Monad.State.Strict (StateT, gets) @@ -56,19 +56,30 @@ -- | Structure providing fresh identifiers for hash map -- and counting hash map hits (i.e. when no fresh identifier required). +#ifdef DEBUG data FreshAndReuse = FreshAndReuse { farFresh :: !Int32 -- ^ Number of hash map misses. , farReuse :: !Int32 -- ^ Number of hash map hits. } +#else +newtype FreshAndReuse = FreshAndReuse + { farFresh :: Int32 -- ^ Number of hash map misses. + } +#endif farEmpty :: FreshAndReuse -farEmpty = FreshAndReuse 0 0 +farEmpty = FreshAndReuse 0 +#ifdef DEBUG + 0 +#endif lensFresh :: Lens' Int32 FreshAndReuse lensFresh f r = f (farFresh r) <&> \ i -> r { farFresh = i } +#ifdef DEBUG lensReuse :: Lens' Int32 FreshAndReuse lensReuse f r = f (farReuse r) <&> \ i -> r { farReuse = i } +#endif -- | Two 'QName's are equal if their @QNameId@ is equal. type QNameId = [NameId] @@ -243,7 +254,9 @@ mi <- H.lookup d key case mi of Just i -> do +#ifdef DEBUG modifyIORef' c $ over lensReuse (+1) +#endif return i Nothing -> do fresh <- (^.lensFresh) <$> do readModifyIORef' c $ over lensFresh (+1) @@ -262,7 +275,9 @@ mi <- H.lookup d key case mi of Just i -> do +#ifdef DEBUG modifyIORef' c $ over lensReuse (+1) +#endif return i Nothing -> do fresh <- (^.lensFresh) <$> do readModifyIORef' c $ over lensFresh (+1) @@ -277,7 +292,9 @@ mi <- H.lookup d key case mi of Just i -> do +#ifdef DEBUG modifyIORef' c $ over lensReuse (+1) +#endif return i Nothing -> do fresh <- (^.lensFresh) <$> do readModifyIORef' c $ over lensFresh (+1) @@ -292,7 +309,9 @@ mi <- H.lookup d key case mi of Just i -> do +#ifdef DEBUG modifyIORef' c $ over lensReuse (+1) +#endif return i Nothing -> do fresh <- (^.lensFresh) <$> do readModifyIORef' c $ over lensFresh (+1) @@ -307,7 +326,9 @@ mi <- H.lookup d key case mi of Just i -> do +#ifdef DEBUG modifyIORef' c $ over lensReuse (+1) +#endif return i Nothing -> do fresh <- (^.lensFresh) <$> do readModifyIORef' c $ over lensFresh (+1) @@ -331,7 +352,9 @@ st <- asks getCounter case mi of Just i -> liftIO $ do +#ifdef DEBUG modifyIORef' st $ over lensReuse (+ 1) +#endif return i Nothing -> do liftIO $ modifyIORef' st $ over lensFresh (+1) diff --git a/src/full/Agda/TypeChecking/Serialise/Instances.hs b/src/full/Agda/TypeChecking/Serialise/Instances.hs --- a/src/full/Agda/TypeChecking/Serialise/Instances.hs +++ b/src/full/Agda/TypeChecking/Serialise/Instances.hs @@ -5,18 +5,18 @@ import Agda.TypeChecking.Monad.Base import Agda.TypeChecking.Serialise.Base -import Agda.TypeChecking.Serialise.Instances.Abstract () -import Agda.TypeChecking.Serialise.Instances.Common () -import Agda.TypeChecking.Serialise.Instances.Compilers () +--import Agda.TypeChecking.Serialise.Instances.Abstract () +--import Agda.TypeChecking.Serialise.Instances.Common () +--import Agda.TypeChecking.Serialise.Instances.Compilers () import Agda.TypeChecking.Serialise.Instances.Highlighting () -import Agda.TypeChecking.Serialise.Instances.Internal () +--import Agda.TypeChecking.Serialise.Instances.Internal () import Agda.TypeChecking.Serialise.Instances.Errors () instance EmbPrj Interface where - icod_ (Interface a b c d e f g h i j k l m n o p q) = - icodeN' Interface a b c d e f g h i j k l m n o p q + icod_ (Interface a b c d e f g h i j k l m n o p q r s) = + icodeN' Interface a b c d e f g h i j k l m n o p q r s value = vcase valu where - valu [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q] = - valuN Interface a b c d e f g h i j k l m n o p q + valu [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s] = + valuN Interface a b c d e f g h i j k l m n o p q r s valu _ = malformed diff --git a/src/full/Agda/TypeChecking/Serialise/Instances/Abstract.hs b/src/full/Agda/TypeChecking/Serialise/Instances/Abstract.hs --- a/src/full/Agda/TypeChecking/Serialise/Instances/Abstract.hs +++ b/src/full/Agda/TypeChecking/Serialise/Instances/Abstract.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# OPTIONS_GHC -fno-warn-orphans #-} @@ -11,21 +10,18 @@ import qualified Agda.Syntax.Abstract as A import Agda.Syntax.Info import Agda.Syntax.Scope.Base -import Agda.Syntax.Position as P import Agda.Syntax.Fixity import Agda.TypeChecking.Serialise.Base -import Agda.TypeChecking.Serialise.Instances.Common () - -import Agda.TypeChecking.Monad - -import Agda.Utils.Except +import Agda.TypeChecking.Serialise.Instances.Common () --instance only -#include "undefined.h" +import Agda.Utils.Functor +import Agda.Utils.Lens import Agda.Utils.Impossible +-- Don't serialize the tactic. instance EmbPrj A.BindName where - icod_ (A.BindName n) = icodeN' A.BindName n + icod_ (A.BindName a) = icodeN' A.BindName a value = valueN A.BindName instance EmbPrj Scope where @@ -37,26 +33,22 @@ icod_ PublicNS = icodeN' PublicNS icod_ PrivateNS = icodeN 1 PrivateNS icod_ ImportedNS = icodeN 2 ImportedNS - icod_ OnlyQualifiedNS = icodeN 3 OnlyQualifiedNS value = vcase valu where valu [] = valuN PublicNS valu [1] = valuN PrivateNS valu [2] = valuN ImportedNS - valu [3] = valuN OnlyQualifiedNS valu _ = malformed instance EmbPrj Access where icod_ (PrivateAccess UserWritten) = icodeN 0 () icod_ PrivateAccess{} = icodeN 1 () icod_ PublicAccess = icodeN' PublicAccess - icod_ OnlyQualified = icodeN 2 () value = vcase valu where valu [0] = valuN $ PrivateAccess UserWritten valu [1] = valuN $ PrivateAccess Inserted valu [] = valuN PublicAccess - valu [2] = valuN OnlyQualified valu _ = malformed instance EmbPrj NameSpace where @@ -75,11 +67,26 @@ valu [1, a, b] = valuN Applied a b valu _ = malformed -instance EmbPrj AbstractName where - icod_ (AbsName a b c d) = icodeN' AbsName a b c d +-- Issue #1346: QNames are shared on their nameIds, so serializing will lose fixity information for +-- rebound fixities. We don't care about that in terms, but in the scope it's important to keep the +-- right fixity. Thus serialize the fixity separately. - value = valueN AbsName +data AbsNameWithFixity = AbsNameWithFixity Fixity A.QName KindOfName WhyInScope NameMetadata +toAbsName :: AbsNameWithFixity -> AbstractName +toAbsName (AbsNameWithFixity fx a b c d) = AbsName (set lensFixity fx a) b c d + +fromAbsName :: AbstractName -> AbsNameWithFixity +fromAbsName (AbsName a b c d) = AbsNameWithFixity (a ^. lensFixity) a b c d + +instance EmbPrj AbsNameWithFixity where + icod_ (AbsNameWithFixity a b c d e) = icodeN' AbsNameWithFixity a b c d e + value = valueN AbsNameWithFixity + +instance EmbPrj AbstractName where + icod_ a = icod_ (fromAbsName a) + value = toAbsName <.> value + instance EmbPrj NameMetadata where icod_ NoMetadata = icodeN' NoMetadata icod_ (GeneralizedVarsMetadata a) = icodeN' GeneralizedVarsMetadata a @@ -95,27 +102,29 @@ value = valueN AbsModule instance EmbPrj KindOfName where - icod_ DefName = icodeN' DefName - icod_ ConName = icodeN 1 ConName - icod_ FldName = icodeN 2 FldName - icod_ PatternSynName = icodeN 3 PatternSynName - icod_ QuotableName = icodeN 4 QuotableName - icod_ MacroName = icodeN 5 MacroName - icod_ GeneralizeName = icodeN 6 GeneralizeName - icod_ DisallowedGeneralizeName = icodeN 7 DisallowedGeneralizeName + -- -- Enums have a generic EmbPrj + -- + -- icod_ DefName = icodeN' DefName + -- icod_ ConName = icodeN 1 ConName + -- icod_ FldName = icodeN 2 FldName + -- icod_ PatternSynName = icodeN 3 PatternSynName + -- icod_ QuotableName = icodeN 4 QuotableName + -- icod_ MacroName = icodeN 5 MacroName + -- icod_ GeneralizeName = icodeN 6 GeneralizeName + -- icod_ DisallowedGeneralizeName = icodeN 7 DisallowedGeneralizeName - value = vcase valu where - valu [] = valuN DefName - valu [1] = valuN ConName - valu [2] = valuN FldName - valu [3] = valuN PatternSynName - valu [4] = valuN QuotableName - valu [5] = valuN MacroName - valu [6] = valuN GeneralizeName - valu [7] = valuN DisallowedGeneralizeName - valu _ = malformed + -- value = vcase valu where + -- valu [] = valuN DefName + -- valu [1] = valuN ConName + -- valu [2] = valuN FldName + -- valu [3] = valuN PatternSynName + -- valu [4] = valuN QuotableName + -- valu [5] = valuN MacroName + -- valu [6] = valuN GeneralizeName + -- valu [7] = valuN DisallowedGeneralizeName + -- valu _ = malformed -instance EmbPrj Binder where +instance EmbPrj BindingSource where icod_ LambdaBound = icodeN' LambdaBound icod_ PatternBound = icodeN 1 PatternBound icod_ LetBound = icodeN 2 LetBound @@ -208,3 +217,5 @@ icod_ (ScopeInfo a b c d e f g h i j) = icodeN' (\ a b c d e -> ScopeInfo a b c d e f g h i j) a b c d e value = valueN (\ a b c d e -> ScopeInfo a b c d e Map.empty Map.empty Set.empty Map.empty Map.empty) + +instance EmbPrj NameOrModule diff --git a/src/full/Agda/TypeChecking/Serialise/Instances/Common.hs b/src/full/Agda/TypeChecking/Serialise/Instances/Common.hs --- a/src/full/Agda/TypeChecking/Serialise/Instances/Common.hs +++ b/src/full/Agda/TypeChecking/Serialise/Instances/Common.hs @@ -1,5 +1,3 @@ -{-# LANGUAGE CPP #-} -{-# LANGUAGE DeriveDataTypeable #-} {-# OPTIONS_GHC -fno-warn-orphans #-} @@ -9,26 +7,30 @@ import Control.Monad.Reader hiding (mapM) import Control.Monad.State.Strict (gets, modify) -import Control.Exception + import Data.Array.IArray import Data.Word import qualified Data.Foldable as Fold import Data.Hashable import qualified Data.HashTable.IO as H import Data.Int (Int32) -import Data.Maybe + import Data.Map (Map) import qualified Data.Map as Map import Data.Set (Set) import qualified Data.IntSet as IntSet import Data.IntSet (IntSet) +import Data.List.NonEmpty (NonEmpty(..), nonEmpty) +import qualified Data.List.NonEmpty as NonEmpty import qualified Data.Set as Set import Data.Sequence (Seq) import qualified Data.Sequence as Seq import Data.Text.Lazy (Text) import Data.Traversable ( mapM ) import Data.Typeable +import Data.HashMap.Strict (HashMap) +import qualified Data.HashMap.Strict as HMap import Data.Void @@ -36,8 +38,8 @@ import Agda.Syntax.Concrete.Name as C import qualified Agda.Syntax.Concrete as C import qualified Agda.Syntax.Abstract as A +import Agda.Syntax.Info import Agda.Syntax.Position as P -import Agda.Syntax.Fixity import Agda.Syntax.Notation import Agda.Syntax.Literal import Agda.Interaction.FindFile @@ -46,15 +48,12 @@ import Agda.Utils.BiMap (BiMap) import qualified Agda.Utils.BiMap as BiMap -import Agda.Utils.HashMap (HashMap) -import qualified Agda.Utils.HashMap as HMap import Agda.Utils.FileName import Agda.Utils.Maybe -import Agda.Utils.NonemptyList import qualified Agda.Utils.Maybe.Strict as Strict import Agda.Utils.Trie (Trie(..)) -import qualified Agda.Utils.Trie as Trie + import Agda.Utils.Except import Agda.Utils.Empty (Empty) @@ -62,7 +61,6 @@ import Agda.Utils.WithDefault -#include "undefined.h" import Agda.Utils.Impossible instance {-# OVERLAPPING #-} EmbPrj String where @@ -204,7 +202,7 @@ modify $ \s -> s { modFile = mf } case r of Left err -> throwError $ findErrorToTypeError m err - Right f -> return f + Right f -> return (srcFilePath f) instance EmbPrj a => EmbPrj (Position' a) where icod_ (P.Pn file pos line col) = icodeN' P.Pn file pos line col @@ -235,9 +233,9 @@ -- valu [x, xs] = valu2 (:) x xs -- valu _ = malformed -instance EmbPrj a => EmbPrj (NonemptyList a) where - icod_ = icod_ . toList - value = listCaseNe malformed return <=< value +instance EmbPrj a => EmbPrj (NonEmpty a) where + icod_ = icod_ . NonEmpty.toList + value = maybe malformed return . nonEmpty <=< value instance (Ord a, Ord b, EmbPrj a, EmbPrj b) => EmbPrj (BiMap a b) where icod_ m = icode (BiMap.toList m) @@ -333,7 +331,7 @@ valu [2, a] = valuN ImportedName a valu _ = malformed -instance EmbPrj Agda.Syntax.Fixity.Associativity where +instance EmbPrj Associativity where icod_ LeftAssoc = icodeN' LeftAssoc icod_ RightAssoc = icodeN 1 RightAssoc icod_ NonAssoc = icodeN 2 NonAssoc @@ -344,7 +342,7 @@ valu [2] = valuN NonAssoc valu _ = malformed -instance EmbPrj Agda.Syntax.Fixity.PrecedenceLevel where +instance EmbPrj FixityLevel where icod_ Unrelated = icodeN' Unrelated icod_ (Related a) = icodeN' Related a @@ -353,12 +351,12 @@ valu [a] = valuN Related a valu _ = malformed -instance EmbPrj Agda.Syntax.Fixity.Fixity where +instance EmbPrj Fixity where icod_ (Fixity a b c) = icodeN' Fixity a b c value = valueN Fixity -instance EmbPrj Agda.Syntax.Fixity.Fixity' where +instance EmbPrj Fixity' where icod_ (Fixity' a b r) = icodeN' (\ a b -> Fixity' a b r) a b -- discard theNameRange value = valueN (\ f n -> Fixity' f n noRange) @@ -438,11 +436,6 @@ value = valueN Arg -instance EmbPrj a => EmbPrj (Dom a) where - icod_ (Dom a b c d) = icodeN' Dom a b c d - - value = valueN Dom - instance EmbPrj HasEta where icod_ YesEta = icodeN' YesEta icod_ NoEta = icodeN 1 NoEta @@ -473,21 +466,80 @@ value 3 = return (Instance YesOverlap) value _ = malformed +instance EmbPrj Q0Origin where + icod_ = \case + Q0Inferred -> return 0 + Q0 _ -> return 1 + Q0Erased _ -> return 2 + + value = \case + 0 -> return $ Q0Inferred + 1 -> return $ Q0 noRange + 2 -> return $ Q0Erased noRange + _ -> malformed + +instance EmbPrj Q1Origin where + icod_ = \case + Q1Inferred -> return 0 + Q1 _ -> return 1 + Q1Linear _ -> return 2 + + value = \case + 0 -> return $ Q1Inferred + 1 -> return $ Q1 noRange + 2 -> return $ Q1Linear noRange + _ -> malformed + +instance EmbPrj QωOrigin where + icod_ = \case + QωInferred -> return 0 + Qω _ -> return 1 + QωPlenty _ -> return 2 + + value = \case + 0 -> return $ QωInferred + 1 -> return $ Qω noRange + 2 -> return $ QωPlenty noRange + _ -> malformed + instance EmbPrj Quantity where - icod_ Quantity0 = return 0 - icod_ Quantity1 = return 1 - icod_ Quantityω = return 2 + icod_ = \case + Quantity0 a -> icodeN 0 Quantity0 a + Quantity1 a -> icodeN 1 Quantity1 a + Quantityω a -> icodeN' Quantityω a -- default quantity, shorter code - value 0 = return Quantity0 - value 1 = return Quantity1 - value 2 = return Quantityω + value = vcase $ \case + [0, a] -> valuN Quantity0 a + [1, a] -> valuN Quantity1 a + [a] -> valuN Quantityω a + _ -> malformed + +-- -- ALT: forget quantity origin when serializing? +-- instance EmbPrj Quantity where +-- icod_ Quantity0 = return 0 +-- icod_ Quantity1 = return 1 +-- icod_ Quantityω = return 2 + +-- value 0 = return Quantity0 +-- value 1 = return Quantity1 +-- value 2 = return Quantityω +-- value _ = malformed + +instance EmbPrj Cohesion where + icod_ Flat = return 0 + icod_ Continuous = return 1 + icod_ Squash = return 2 + + value 0 = return Flat + value 1 = return Continuous + value 2 = return Squash value _ = malformed instance EmbPrj Modality where - icod_ (Modality a b) = icodeN' Modality a b + icod_ (Modality a b c) = icodeN' Modality a b c value = vcase $ \case - [a, b] -> valuN Modality a b + [a, b, c] -> valuN Modality a b c _ -> malformed instance EmbPrj Relevance where @@ -514,6 +566,11 @@ value 4 = return Substitution value _ = malformed +instance EmbPrj a => EmbPrj (WithOrigin a) where + icod_ (WithOrigin a b) = icodeN' WithOrigin a b + + value = valueN WithOrigin + instance EmbPrj FreeVariables where icod_ UnknownFVs = icodeN' UnknownFVs icod_ (KnownFVs a) = icodeN' KnownFVs a @@ -597,3 +654,12 @@ icod_ a = icod_ =<< lift (Empty.toImpossible a) value = fmap throwImpossible . value + +instance EmbPrj ExpandedEllipsis where + icod_ NoEllipsis = icodeN' NoEllipsis + icod_ (ExpandedEllipsis a b) = icodeN 1 ExpandedEllipsis a b + + value = vcase valu where + valu [] = valuN NoEllipsis + valu [1,a,b] = valuN ExpandedEllipsis a b + valu _ = malformed diff --git a/src/full/Agda/TypeChecking/Serialise/Instances/Errors.hs b/src/full/Agda/TypeChecking/Serialise/Instances/Errors.hs --- a/src/full/Agda/TypeChecking/Serialise/Instances/Errors.hs +++ b/src/full/Agda/TypeChecking/Serialise/Instances/Errors.hs @@ -1,35 +1,22 @@ -{-# LANGUAGE RecordWildCards #-} -{-# LANGUAGE CPP #-} {-# OPTIONS_GHC -fno-warn-orphans #-} module Agda.TypeChecking.Serialise.Instances.Errors where -import Data.Maybe - import Control.Monad import Agda.TypeChecking.Serialise.Base -import Agda.TypeChecking.Serialise.Instances.Common -import Agda.TypeChecking.Serialise.Instances.Internal () -import Agda.TypeChecking.Serialise.Instances.Abstract () +import Agda.TypeChecking.Serialise.Instances.Internal () --instance only +import Agda.TypeChecking.Serialise.Instances.Abstract () --instance only -import Agda.Syntax.Common import Agda.Syntax.Concrete.Definitions (DeclarationWarning(..)) -import Agda.Syntax.Abstract.Name (ModuleName) import Agda.TypeChecking.Monad.Base import Agda.Interaction.Options import Agda.Interaction.Options.Warnings import Agda.Interaction.Library import Agda.Interaction.Library.Parse import Agda.Termination.CutOff -import Agda.TypeChecking.Positivity.Occurrence () -import Agda.Syntax.Parser.Monad (ParseWarning( OverlappingTokensWarning )) import Agda.Utils.Pretty -import Agda.Utils.FileName () -import Agda.Utils.Lens - -#include "undefined.h" import Agda.Utils.Impossible instance EmbPrj TCWarning where @@ -60,6 +47,9 @@ icod_ SafeFlagNoPositivityCheck = __IMPOSSIBLE__ icod_ SafeFlagPolarity = __IMPOSSIBLE__ icod_ SafeFlagNoUniverseCheck = __IMPOSSIBLE__ + icod_ SafeFlagNoCoverageCheck = __IMPOSSIBLE__ + icod_ SafeFlagInjective = __IMPOSSIBLE__ + icod_ SafeFlagEta = __IMPOSSIBLE__ icod_ (ParseWarning a) = __IMPOSSIBLE__ icod_ (DeprecationWarning a b c) = icodeN 6 DeprecationWarning a b c icod_ (NicifierIssue a) = icodeN 7 NicifierIssue a @@ -78,6 +68,12 @@ icod_ (InstanceNoOutputTypeName a) = icodeN 20 InstanceNoOutputTypeName a icod_ (InstanceArgWithExplicitArg a) = icodeN 21 InstanceArgWithExplicitArg a icod_ WrongInstanceDeclaration = icodeN 22 WrongInstanceDeclaration + icod_ (RewriteNonConfluent a b c d) = icodeN 23 RewriteNonConfluent a b c d + icod_ (RewriteMaybeNonConfluent a b c) = icodeN 24 RewriteMaybeNonConfluent a b c + icod_ (PragmaCompileErased a b) = icodeN 25 PragmaCompileErased a b + icod_ (FixityInRenamingModule a) = icodeN 26 FixityInRenamingModule a + icod_ (NotInScopeW ns) = icodeN 27 NotInScopeW ns + icod_ (ClashesViaRenaming a b) = icodeN 28 ClashesViaRenaming a b value = vcase valu where valu [0, a, b] = valuN UnreachableClauses a b @@ -103,6 +99,12 @@ valu [20, a] = valuN InstanceNoOutputTypeName a valu [21, a] = valuN InstanceArgWithExplicitArg a valu [22] = valuN WrongInstanceDeclaration + valu [23, a, b, c, d] = valuN RewriteNonConfluent a b c d + valu [24, a, b, c] = valuN RewriteMaybeNonConfluent a b c + valu [25, a, b] = valuN PragmaCompileErased a b + valu [26, a] = valuN FixityInRenamingModule a + valu [27, ns] = valuN NotInScopeW ns + valu [28, a, b] = valuN ClashesViaRenaming a b valu _ = malformed instance EmbPrj DeclarationWarning where @@ -130,6 +132,11 @@ EmptyGeneralize a -> icodeN 20 EmptyGeneralize a PragmaCompiled r -> icodeN 21 PragmaCompiled r EmptyPrimitive a -> icodeN 22 EmptyPrimitive a + EmptyField r -> icodeN 23 EmptyField r + ShadowingInTelescope nrs -> icodeN 24 ShadowingInTelescope nrs + InvalidCoverageCheckPragma r -> icodeN 25 InvalidCoverageCheckPragma r + OpenPublicAbstract r -> icodeN 26 OpenPublicAbstract r + OpenPublicPrivate r -> icodeN 27 OpenPublicPrivate r value = vcase $ \case [0, a] -> valuN UnknownNamesInFixityDecl a @@ -155,6 +162,11 @@ [20,a] -> valuN EmptyGeneralize a [21,a] -> valuN PragmaCompiled a [22,a] -> valuN EmptyPrimitive a + [23,r] -> valuN EmptyField r + [24,nrs] -> valuN ShadowingInTelescope nrs + [25,r] -> valuN InvalidCoverageCheckPragma r + [26,r] -> valuN OpenPublicAbstract r + [27,r] -> valuN OpenPublicPrivate r _ -> malformed instance EmbPrj LibWarning where @@ -188,10 +200,12 @@ instance EmbPrj PragmaOptions where icod_ = \case - PragmaOptions a b c d e f g h i j k l m n o p q r s t u v w x y z aa bb cc dd ee ff gg hh ii jj kk ll mm -> icodeN' PragmaOptions a b c d e f g h i j k l m n o p q r s t u v w x y z aa bb cc dd ee ff gg hh ii jj kk ll mm + PragmaOptions a b c d e f g h i j k l m n o p q r s t u v w x y z aa bb cc dd ee ff gg hh ii jj kk ll mm nn oo pp qq rr ss tt uu vv -> + icodeN' PragmaOptions a b c d e f g h i j k l m n o p q r s t u v w x y z aa bb cc dd ee ff gg hh ii jj kk ll mm nn oo pp qq rr ss tt uu vv value = vcase $ \case - [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, aa, bb, cc, dd, ee, ff, gg, hh, ii, jj, kk, ll, mm] -> valuN PragmaOptions a b c d e f g h i j k l m n o p q r s t u v w x y z aa bb cc dd ee ff gg hh ii jj kk ll mm + [a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x, y, z, aa, bb, cc, dd, ee, ff, gg, hh, ii, jj, kk, ll, mm, nn, oo, pp, qq, rr, ss, tt, uu, vv] -> + valuN PragmaOptions a b c d e f g h i j k l m n o p q r s t u v w x y z aa bb cc dd ee ff gg hh ii jj kk ll mm nn oo pp qq rr ss tt uu vv _ -> malformed instance EmbPrj WarningMode where diff --git a/src/full/Agda/TypeChecking/Serialise/Instances/Highlighting.hs b/src/full/Agda/TypeChecking/Serialise/Instances/Highlighting.hs --- a/src/full/Agda/TypeChecking/Serialise/Instances/Highlighting.hs +++ b/src/full/Agda/TypeChecking/Serialise/Instances/Highlighting.hs @@ -6,7 +6,7 @@ import qualified Agda.Interaction.Highlighting.Precise as HP import Agda.TypeChecking.Serialise.Base -import Agda.TypeChecking.Serialise.Instances.Common () +import Agda.TypeChecking.Serialise.Instances.Common () --instance only instance EmbPrj HR.Range where icod_ (HR.Range a b) = icodeN' HR.Range a b @@ -68,17 +68,20 @@ valu _ = malformed instance EmbPrj HP.OtherAspect where - icod_ HP.Error = icodeN 0 () - icod_ HP.DottedPattern = icodeN' HP.DottedPattern - icod_ HP.UnsolvedMeta = icodeN 2 () - icod_ HP.TerminationProblem = icodeN 3 () - icod_ HP.IncompletePattern = icodeN 4 () - icod_ HP.TypeChecks = icodeN 5 () - icod_ HP.UnsolvedConstraint = icodeN 6 () - icod_ HP.PositivityProblem = icodeN 7 () - icod_ HP.Deadcode = icodeN 8 () - icod_ HP.CoverageProblem = icodeN 9 () - icod_ HP.CatchallClause = icodeN 10 () + icod_ HP.Error = icodeN 0 () + icod_ HP.DottedPattern = icodeN' HP.DottedPattern + icod_ HP.UnsolvedMeta = icodeN 2 () + icod_ HP.TerminationProblem = icodeN 3 () + icod_ HP.IncompletePattern = icodeN 4 () + icod_ HP.TypeChecks = icodeN 5 () + icod_ HP.UnsolvedConstraint = icodeN 6 () + icod_ HP.PositivityProblem = icodeN 7 () + icod_ HP.Deadcode = icodeN 8 () + icod_ HP.CoverageProblem = icodeN 9 () + icod_ HP.CatchallClause = icodeN 10 () + icod_ HP.ConfluenceProblem = icodeN 11 () + icod_ HP.MissingDefinition = icodeN 12 () + icod_ HP.ShadowingInTelescope = icodeN 13 () value = vcase valu where valu [0] = valuN HP.Error @@ -92,6 +95,9 @@ valu [8] = valuN HP.Deadcode valu [9] = valuN HP.CoverageProblem valu [10] = valuN HP.CatchallClause + valu [11] = valuN HP.ConfluenceProblem + valu [12] = valuN HP.MissingDefinition + valu [13] = valuN HP.ShadowingInTelescope valu _ = malformed instance EmbPrj HP.Aspects where diff --git a/src/full/Agda/TypeChecking/Serialise/Instances/Internal.hs b/src/full/Agda/TypeChecking/Serialise/Instances/Internal.hs --- a/src/full/Agda/TypeChecking/Serialise/Instances/Internal.hs +++ b/src/full/Agda/TypeChecking/Serialise/Instances/Internal.hs @@ -1,17 +1,15 @@ -{-# LANGUAGE CPP #-} {-# OPTIONS_GHC -fno-warn-orphans #-} module Agda.TypeChecking.Serialise.Instances.Internal where -import Control.Monad.State.Strict +import Control.Monad.IO.Class import Agda.Syntax.Internal as I import Agda.Syntax.Position as P import Agda.TypeChecking.Serialise.Base -import Agda.TypeChecking.Serialise.Instances.Common () -import Agda.TypeChecking.Serialise.Instances.Compilers () +import Agda.TypeChecking.Serialise.Instances.Compilers () --instance only import Agda.TypeChecking.Monad import Agda.TypeChecking.CompiledClause @@ -20,9 +18,13 @@ import Agda.Utils.Permutation -#include "undefined.h" import Agda.Utils.Impossible +instance EmbPrj a => EmbPrj (Dom a) where + icod_ (Dom a b c d e) = icodeN' Dom a b c d e + + value = valueN Dom + instance EmbPrj Signature where icod_ (Sig a b c) = icodeN' Sig a b c @@ -94,7 +96,9 @@ icod_ (MetaV a b) = __IMPOSSIBLE__ icod_ (DontCare a ) = icodeN 8 DontCare a icod_ (Level a ) = icodeN 9 Level a - icod_ (Dummy s) = __IMPOSSIBLE__ + icod_ (Dummy s _) = do + liftIO $ putStrLn $ "Dummy term in serialization: " ++ s + __IMPOSSIBLE__ value = vcase valu where valu [a] = valuN var a @@ -110,18 +114,14 @@ valu _ = malformed instance EmbPrj Level where - icod_ (Max a) = icodeN' Max a + icod_ (Max a b) = icodeN' Max a b value = valueN Max instance EmbPrj PlusLevel where - icod_ (ClosedLevel a) = icodeN' ClosedLevel a - icod_ (Plus a b) = icodeN' Plus a b + icod_ (Plus a b) = icodeN' Plus a b - value = vcase valu where - valu [a] = valuN ClosedLevel a - valu [a, b] = valuN Plus a b - valu _ = malformed + value = valueN Plus instance EmbPrj LevelAtom where icod_ (NeutralLevel r a) = icodeN' (NeutralLevel r) a @@ -142,10 +142,13 @@ icod_ SizeUniv = icodeN 2 SizeUniv icod_ Inf = icodeN 3 Inf icod_ (PiSort a b) = icodeN 4 PiSort a b - icod_ (UnivSort a) = icodeN 5 UnivSort a + icod_ (FunSort a b) = icodeN 5 FunSort a b + icod_ (UnivSort a) = icodeN 6 UnivSort a icod_ (MetaS a b) = __IMPOSSIBLE__ - icod_ (DefS a b) = icodeN 6 DefS a b - icod_ (DummyS s) = __IMPOSSIBLE__ + icod_ (DefS a b) = icodeN 7 DefS a b + icod_ (DummyS s) = do + liftIO $ putStrLn $ "Dummy sort in serialization: " ++ s + __IMPOSSIBLE__ value = vcase valu where valu [0, a] = valuN Type a @@ -153,8 +156,9 @@ valu [2] = valuN SizeUniv valu [3] = valuN Inf valu [4, a, b] = valuN PiSort a b - valu [5, a] = valuN UnivSort a - valu [6, a, b] = valuN DefS a b + valu [5, a, b] = valuN FunSort a b + valu [6, a] = valuN UnivSort a + valu [7, a, b] = valuN DefS a b valu _ = malformed instance EmbPrj DisplayForm where @@ -195,25 +199,46 @@ value = valueN CompKit instance EmbPrj Definition where - icod_ (Defn a b c d e f g h i j k l m n o p) = icodeN' Defn a b (P.killRange c) d e f g h i j k l m n o p + icod_ (Defn a b c d e f g h i j k l m n o p q r) = icodeN' Defn a b (P.killRange c) d e f g h i j k l m n o p q r value = valueN Defn +instance EmbPrj NotBlocked where + icod_ ReallyNotBlocked = icodeN' ReallyNotBlocked + icod_ (StuckOn a) = icodeN 0 StuckOn a + icod_ Underapplied = icodeN 1 Underapplied + icod_ AbsurdMatch = icodeN 2 AbsurdMatch + icod_ MissingClauses = icodeN 3 MissingClauses + + value = vcase valu where + valu [] = valuN ReallyNotBlocked + valu [0, a] = valuN StuckOn a + valu [1] = valuN Underapplied + valu [2] = valuN AbsurdMatch + valu [3] = valuN MissingClauses + valu _ = malformed + +instance EmbPrj Blocked_ where + icod_ (NotBlocked a b) = icodeN' NotBlocked a b + icod_ Blocked{} = __IMPOSSIBLE__ + + value = valueN NotBlocked + instance EmbPrj NLPat where icod_ (PVar a b) = icodeN 0 PVar a b - icod_ (PWild) = icodeN 1 PWild - icod_ (PDef a b) = icodeN 2 PDef a b - icod_ (PLam a b) = icodeN 3 PLam a b - icod_ (PPi a b) = icodeN 4 PPi a b + icod_ (PDef a b) = icodeN 1 PDef a b + icod_ (PLam a b) = icodeN 2 PLam a b + icod_ (PPi a b) = icodeN 3 PPi a b + icod_ (PSort a) = icodeN 4 PSort a icod_ (PBoundVar a b) = icodeN 5 PBoundVar a b icod_ (PTerm a) = icodeN 6 PTerm a value = vcase valu where valu [0, a, b] = valuN PVar a b - valu [1] = valuN PWild - valu [2, a, b] = valuN PDef a b - valu [3, a, b] = valuN PLam a b - valu [4, a, b] = valuN PPi a b + valu [1, a, b] = valuN PDef a b + valu [2, a, b] = valuN PLam a b + valu [3, a, b] = valuN PPi a b + valu [4, a] = valuN PSort a valu [5, a, b] = valuN PBoundVar a b valu [6, a] = valuN PTerm a valu _ = malformed @@ -223,6 +248,19 @@ value = valueN NLPType +instance EmbPrj NLPSort where + icod_ (PType a) = icodeN 0 PType a + icod_ (PProp a) = icodeN 1 PProp a + icod_ PInf = icodeN 2 PInf + icod_ PSizeUniv = icodeN 3 PSizeUniv + + value = vcase valu where + valu [0, a] = valuN PType a + valu [1, a] = valuN PProp a + valu [2] = valuN PInf + valu [3] = valuN PSizeUniv + valu _ = malformed + instance EmbPrj RewriteRule where icod_ (RewriteRule a b c d e f) = icodeN' RewriteRule a b c d e f @@ -312,12 +350,12 @@ instance EmbPrj Defn where icod_ Axiom = icodeN 0 Axiom - icod_ (Function a b s t (_:_) c d e f g h i j k m) = __IMPOSSIBLE__ - icod_ (Function a b s t [] c d e f g h i j k m) = - icodeN 1 (\ a b s -> Function a b s t []) a b s c d e f g h i j k m - icod_ (Datatype a b c d e f g h i) = icodeN 2 Datatype a b c d e f g h i + icod_ (Function a b s t (_:_) c d e f g h i j k) = __IMPOSSIBLE__ + icod_ (Function a b s t [] c d e f g h i j k) = + icodeN 1 (\ a b s -> Function a b s t []) a b s c d e f g h i j k + icod_ (Datatype a b c d e f g h) = icodeN 2 Datatype a b c d e f g h icod_ (Record a b c d e f g h i j k) = icodeN 3 Record a b c d e f g h i j k - icod_ (Constructor a b c d e f g h i) = icodeN 4 Constructor a b c d e f g h i + icod_ (Constructor a b c d e f g h i j) = icodeN 4 Constructor a b c d e f g h i j icod_ (Primitive a b c d e) = icodeN 5 Primitive a b c d e icod_ AbstractDefn{} = __IMPOSSIBLE__ icod_ GeneralizableVar = icodeN 6 GeneralizableVar @@ -325,14 +363,23 @@ value = vcase valu where valu [0] = valuN Axiom - valu [1, a, b, s, c, d, e, f, g, h, i, j, k, m] = valuN (\ a b s -> Function a b s Nothing []) a b s c d e f g h i j k m - valu [2, a, b, c, d, e, f, g, h, i] = valuN Datatype a b c d e f g h i + valu [1, a, b, s, c, d, e, f, g, h, i, j, k] = valuN (\ a b s -> Function a b s Nothing []) a b s c d e f g h i j k + valu [2, a, b, c, d, e, f, g, h] = valuN Datatype a b c d e f g h valu [3, a, b, c, d, e, f, g, h, i, j, k] = valuN Record a b c d e f g h i j k - valu [4, a, b, c, d, e, f, g, h, i] = valuN Constructor a b c d e f g h i + valu [4, a, b, c, d, e, f, g, h, i, j] = valuN Constructor a b c d e f g h i j valu [5, a, b, c, d, e] = valuN Primitive a b c d e valu [6] = valuN GeneralizableVar valu _ = malformed +instance EmbPrj LazySplit where + icod_ StrictSplit = icodeN' StrictSplit + icod_ LazySplit = icodeN 0 LazySplit + + value = vcase valu where + valu [] = valuN StrictSplit + valu [0] = valuN LazySplit + valu _ = malformed + instance EmbPrj SplitTag where icod_ (SplitCon c) = icodeN 0 SplitCon c icod_ (SplitLit l) = icodeN 1 SplitLit l @@ -346,12 +393,12 @@ instance EmbPrj a => EmbPrj (SplitTree' a) where icod_ (SplittingDone a) = icodeN' SplittingDone a - icod_ (SplitAt a b) = icodeN 0 SplitAt a b + icod_ (SplitAt a b c) = icodeN 0 SplitAt a b c value = vcase valu where - valu [a] = valuN SplittingDone a - valu [0, a, b] = valuN SplitAt a b - valu _ = malformed + valu [a] = valuN SplittingDone a + valu [0, a, b, c] = valuN SplitAt a b c + valu _ = malformed instance EmbPrj FunctionFlag where icod_ FunStatic = icodeN 0 FunStatic @@ -410,12 +457,12 @@ valu _ = malformed instance EmbPrj I.Clause where - icod_ (Clause a b c d e f g h) = icodeN' Clause a b c d e f g h + icod_ (Clause a b c d e f g h i j) = icodeN' Clause a b c d e f g h i j value = valueN Clause instance EmbPrj I.ConPatternInfo where - icod_ (ConPatternInfo a b c d) = icodeN' ConPatternInfo a b c d + icod_ (ConPatternInfo a b c d e) = icodeN' ConPatternInfo a b c d e value = valueN ConPatternInfo @@ -424,6 +471,11 @@ value = valueN DBPatVar +instance EmbPrj I.PatternInfo where + icod_ (PatternInfo a b) = icodeN' PatternInfo a b + + value = valueN PatternInfo + instance EmbPrj I.PatOrigin where icod_ PatOSystem = icodeN' PatOSystem icod_ PatOSplit = icodeN 1 PatOSplit @@ -450,7 +502,7 @@ instance EmbPrj a => EmbPrj (I.Pattern' a) where icod_ (VarP a b ) = icodeN 0 VarP a b icod_ (ConP a b c) = icodeN 1 ConP a b c - icod_ (LitP a ) = icodeN 2 LitP a + icod_ (LitP a b ) = icodeN 2 LitP a b icod_ (DotP a b ) = icodeN 3 DotP a b icod_ (ProjP a b ) = icodeN 4 ProjP a b icod_ (IApplyP a b c d) = icodeN 5 IApplyP a b c d @@ -459,7 +511,7 @@ value = vcase valu where valu [0, a, b] = valuN VarP a b valu [1, a, b, c] = valuN ConP a b c - valu [2, a] = valuN LitP a + valu [2, a, b] = valuN LitP a b valu [3, a, b] = valuN DotP a b valu [4, a, b] = valuN ProjP a b valu [5, a, b, c, d] = valuN IApplyP a b c d diff --git a/src/full/Agda/TypeChecking/SizedTypes.hs b/src/full/Agda/TypeChecking/SizedTypes.hs --- a/src/full/Agda/TypeChecking/SizedTypes.hs +++ b/src/full/Agda/TypeChecking/SizedTypes.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE NondecreasingIndentation #-} module Agda.TypeChecking.SizedTypes where @@ -9,6 +8,8 @@ import qualified Data.Foldable as Fold import qualified Data.List as List +import Data.List.NonEmpty (NonEmpty(..)) +import qualified Data.List.NonEmpty as NonEmpty import qualified Data.Map as Map import Agda.Syntax.Common @@ -25,10 +26,10 @@ import {-# SOURCE #-} Agda.TypeChecking.Constraints import Agda.Utils.Except ( MonadError(catchError, throwError) ) +import Agda.Utils.Functor import Agda.Utils.List as List import Agda.Utils.Maybe import Agda.Utils.Monad -import Agda.Utils.NonemptyList import Agda.Utils.Null import Agda.Utils.Pretty (Pretty) import Agda.Utils.Singleton @@ -38,7 +39,6 @@ import qualified Agda.Utils.Pretty as P import qualified Agda.Utils.Warshall as W -#include "undefined.h" import Agda.Utils.Impossible ------------------------------------------------------------------------ @@ -115,7 +115,7 @@ -- let yes = return True -- no = cont -- perhaps = cont >>= \ res -> if res then return res else patternViolation --- ifBlockedType t (\ _ _ -> perhaps) $ \ t -> do +-- ifBlocked t (\ _ _ -> perhaps) $ \ t -> do -- caseMaybeM (isSizeType t) no $ \ b -> do -- case b of -- BoundedNo -> no @@ -156,7 +156,7 @@ perhaps = tell (Any True) >> cont -- If we encounter a blocked type in the context, we cannot -- give a definite answer. - ifBlockedType t (\ _ _ -> perhaps) $ \ _ t -> do + ifBlocked t (\ _ _ -> perhaps) $ \ _ t -> do caseMaybeM (liftTCM $ isSizeType t) cont $ \ b -> do case b of BoundedNo -> cont @@ -177,8 +177,9 @@ -- | Check whether a variable in the context is bounded by a size expression. -- If @x : Size< a@, then @a@ is returned. -isBounded :: MonadTCM tcm => Nat -> tcm BoundedSize -isBounded i = liftTCM $ do +isBounded :: (MonadReduce m, MonadTCEnv m, HasBuiltins m) + => Nat -> m BoundedSize +isBounded i = do t <- reduce =<< typeOfBV i case unEl t of Def x [Apply u] -> do @@ -189,7 +190,15 @@ -- | Whenever we create a bounded size meta, add a constraint -- expressing the bound. -- In @boundedSizeMetaHook v tel a@, @tel@ includes the current context. -boundedSizeMetaHook :: Term -> Telescope -> Type -> TCM () +boundedSizeMetaHook + :: ( MonadConstraint m + , MonadTCEnv m + , ReadTCState m + , MonadAddContext m + , HasOptions m + , HasBuiltins m + ) + => Term -> Telescope -> Type -> m () boundedSizeMetaHook v tel0 a = do res <- isSizeType a case res of @@ -200,8 +209,7 @@ addContext tel $ do v <- sizeSuc 1 $ raise (size tel) v `apply` teleArgs tel -- compareSizes CmpLeq v u - size <- sizeType - addConstraint $ ValueCmp CmpLeq size v u + addConstraint $ ValueCmp CmpLeq AsSizes v u _ -> return () -- | @trySizeUniv cmp t m n x els1 y els2@ @@ -213,8 +221,10 @@ -- like @Size< i =< Size@. -- -- If it does not succeed it reports failure of conversion check. -trySizeUniv :: Comparison -> Type -> Term -> Term - -> QName -> Elims -> QName -> Elims -> TCM () +trySizeUniv + :: MonadConversion m + => Comparison -> CompareAs -> Term -> Term + -> QName -> Elims -> QName -> Elims -> m () trySizeUniv cmp t m n x els1 y els2 = do let failure = typeError $ UnequalTerms cmp m n t forceInfty u = compareSizes CmpEq (unArg u) =<< primSizeInf @@ -253,7 +263,7 @@ _ -> return $ DOtherSize v loop v -sizeMaxView :: Term -> TCM SizeMaxView +sizeMaxView :: (MonadReduce m, HasBuiltins m) => Term -> m SizeMaxView sizeMaxView v = do inf <- getBuiltinDefName builtinSizeInf suc <- getBuiltinDefName builtinSizeSuc @@ -274,7 +284,7 @@ ------------------------------------------------------------------------ -- | Compare two sizes. -compareSizes :: Comparison -> Term -> Term -> TCM () +compareSizes :: (MonadConversion m) => Comparison -> Term -> Term -> m () compareSizes cmp u v = verboseBracket "tc.conv.size" 10 "compareSizes" $ do reportSDoc "tc.conv.size" 10 $ vcat [ "Comparing sizes" @@ -294,18 +304,18 @@ compareMaxViews cmp us vs -- | Compare two sizes in max view. -compareMaxViews :: Comparison -> SizeMaxView -> SizeMaxView -> TCM () +compareMaxViews :: (MonadConversion m) => Comparison -> SizeMaxView -> SizeMaxView -> m () compareMaxViews cmp us vs = case (cmp, us, vs) of - (CmpLeq, _, (DSizeInf :! _)) -> return () - (cmp, u:![], v:![]) -> compareSizeViews cmp u v - (CmpLeq, us, v:![]) -> Fold.forM_ us $ \ u -> compareSizeViews cmp u v + (CmpLeq, _, (DSizeInf :| _)) -> return () + (cmp, u:|[], v:|[]) -> compareSizeViews cmp u v + (CmpLeq, us, v:|[]) -> Fold.forM_ us $ \ u -> compareSizeViews cmp u v (CmpLeq, us, vs) -> Fold.forM_ us $ \ u -> compareBelowMax u vs (CmpEq, us, vs) -> do compareMaxViews CmpLeq us vs compareMaxViews CmpLeq vs us -- | @compareBelowMax u vs@ checks @u <= max vs@. Precondition: @size vs >= 2@ -compareBelowMax :: DeepSizeView -> SizeMaxView -> TCM () +compareBelowMax :: (MonadConversion m) => DeepSizeView -> SizeMaxView -> m () compareBelowMax u vs = verboseBracket "tc.conv.size" 45 "compareBelowMax" $ do reportSDoc "tc.conv.size" 45 $ sep [ pretty u @@ -326,7 +336,7 @@ where alt c1 c2 = c1 `catchError` const c2 -compareSizeViews :: Comparison -> DeepSizeView -> DeepSizeView -> TCM () +compareSizeViews :: (MonadConversion m) => Comparison -> DeepSizeView -> DeepSizeView -> m () compareSizeViews cmp s1' s2' = do reportSDoc "tc.conv.size" 45 $ hsep [ "compareSizeViews" @@ -340,8 +350,8 @@ u <- unDeepSizeView s1 v <- unDeepSizeView s2 cont u v - failure = withUnView $ \ u v -> typeError $ UnequalTerms cmp u v size - continue cmp = withUnView $ compareAtom cmp size + failure = withUnView $ \ u v -> typeError $ UnequalTerms cmp u v AsSizes + continue cmp = withUnView $ compareAtom cmp AsSizes case (cmp, s1, s2) of (CmpLeq, _, DSizeInf) -> return () (CmpEq, DSizeInf, DSizeInf) -> return () @@ -367,14 +377,14 @@ -- | If 'envAssignMetas' then postpone as constraint, otherwise, fail hard. -- Failing is required if we speculatively test several alternatives. -giveUp :: Comparison -> Type -> Term -> Term -> TCM () +giveUp :: (MonadConversion m) => Comparison -> Type -> Term -> Term -> m () giveUp cmp size u v = ifM (asksTC envAssignMetas) - {-then-} (addConstraint $ ValueCmp CmpLeq size u v) - {-else-} (typeError $ UnequalTerms cmp u v size) + {-then-} (addConstraint $ ValueCmp CmpLeq AsSizes u v) + {-else-} (typeError $ UnequalTerms cmp u v AsSizes) -- | Checked whether a size constraint is trivial (like @X <= X+1@). -trivial :: Term -> Term -> TCM Bool +trivial :: (MonadConversion m) => Term -> Term -> m Bool trivial u v = do a@(e , n ) <- oldSizeExpr u b@(e', n') <- oldSizeExpr v @@ -394,35 +404,38 @@ ------------------------------------------------------------------------ -- | Test whether a problem consists only of size constraints. -isSizeProblem :: ProblemId -> TCM Bool -isSizeProblem pid = andM . map (isSizeConstraint . theConstraint) =<< getConstraintsForProblem pid +isSizeProblem :: (ReadTCState m, HasOptions m, HasBuiltins m) => ProblemId -> m Bool +isSizeProblem pid = do + test <- isSizeTypeTest + all (mkIsSizeConstraint test (const True) . theConstraint) <$> getConstraintsForProblem pid --- | Test is a constraint speaks about sizes. -isSizeConstraint :: Closure Constraint -> TCM Bool -isSizeConstraint Closure{ clValue = ValueCmp _ s _ _ } = isJust <$> isSizeType s -isSizeConstraint _ = return False +-- | Test whether a constraint speaks about sizes. +isSizeConstraint :: (HasOptions m, HasBuiltins m) => (Comparison -> Bool) -> Closure Constraint -> m Bool +isSizeConstraint p c = isSizeTypeTest <&> \ test -> mkIsSizeConstraint test p c --- | Take out all size constraints (DANGER!). -takeSizeConstraints :: TCM [Closure Constraint] -takeSizeConstraints = do +mkIsSizeConstraint :: (Term -> Maybe BoundedSize) -> (Comparison -> Bool) -> Closure Constraint -> Bool +mkIsSizeConstraint test = isSizeConstraint_ $ isJust . test . unEl + +isSizeConstraint_ + :: (Type -> Bool) -- ^ Test for being a sized type + -> (Comparison -> Bool) -- ^ Restriction to these directions. + -> Closure Constraint + -> Bool +isSizeConstraint_ _isSizeType p Closure{ clValue = ValueCmp cmp AsSizes _ _ } = p cmp +isSizeConstraint_ isSizeType p Closure{ clValue = ValueCmp cmp (AsTermsOf s) _ _ } = p cmp && isSizeType s +isSizeConstraint_ _isSizeType _ _ = False + +-- | Take out all size constraints of the given direction (DANGER!). +takeSizeConstraints :: (Comparison -> Bool) -> TCM [Closure Constraint] +takeSizeConstraints p = do test <- isSizeTypeTest - let sizeConstraint :: Closure Constraint -> Bool - sizeConstraint cl@Closure{ clValue = ValueCmp CmpLeq s _ _ } - | isJust (test $ unEl s) = True - sizeConstraint _ = False - cs <- filter sizeConstraint . map theConstraint <$> getAllConstraints - dropConstraints $ sizeConstraint . theConstraint - return cs + map theConstraint <$> takeConstraints (mkIsSizeConstraint test p . theConstraint) --- | Find the size constraints. -getSizeConstraints :: TCM [Closure Constraint] -getSizeConstraints = do +-- | Find the size constraints of the matching direction. +getSizeConstraints :: (Comparison -> Bool) -> TCM [Closure Constraint] +getSizeConstraints p = do test <- isSizeTypeTest - let sizeConstraint :: Closure Constraint -> Bool - sizeConstraint cl@Closure{ clValue = ValueCmp CmpLeq s _ _ } - | isJust (test $ unEl s) = True - sizeConstraint _ = False - filter sizeConstraint . map theConstraint <$> getAllConstraints + filter (mkIsSizeConstraint test p) . map theConstraint <$> getAllConstraints -- | Return a list of size metas and their context. getSizeMetas :: Bool -> TCM [(MetaId, Type, Telescope)] @@ -435,7 +448,7 @@ mi <- lookupMeta m case mvJudgement mi of _ | BlockedConst{} <- mvInstantiation mi -> no -- Blocked terms should not be touched (#2637, #2881) - HasType _ a -> do + HasType _ cmp a -> do TelV tel b <- telView a -- b is reduced caseMaybe (test $ unEl b) no $ \ _ -> do @@ -541,7 +554,8 @@ -- | Turn a term with de Bruijn indices into a size expression with offset. -- -- Throws a 'patternViolation' if the term isn't a proper size expression. -oldSizeExpr :: Term -> TCM (OldSizeExpr, Int) +oldSizeExpr :: (MonadReduce m, MonadDebug m, MonadError TCErr m, HasBuiltins m) + => Term -> m (OldSizeExpr, Int) oldSizeExpr u = do u <- reduce u -- Andreas, 2009-02-09. -- This is necessary to surface the solutions of metavariables. @@ -605,7 +619,7 @@ oldSolveSizeConstraints :: TCM () oldSolveSizeConstraints = whenM haveSizedTypes $ do reportSLn "tc.size.solve" 70 $ "Considering to solve size constraints" - cs0 <- getSizeConstraints + cs0 <- getSizeConstraints (== CmpLeq) cs <- oldComputeSizeConstraints cs0 ms <- getSizeMetas True -- get all size metas, also interaction metas @@ -621,7 +635,7 @@ -- Size metas in constraints. metas0 :: [(MetaId, Int)] -- meta id + arity - metas0 = List.nub $ map (mapSnd length) $ concatMap flexibleVariables cs + metas0 = List.nubOn id $ map (mapSnd length) $ concatMap flexibleVariables cs -- Unconstrained size metas that do not occur in constraints. metas1 :: [(MetaId, Int)] diff --git a/src/full/Agda/TypeChecking/SizedTypes/Solve.hs b/src/full/Agda/TypeChecking/SizedTypes/Solve.hs --- a/src/full/Agda/TypeChecking/SizedTypes/Solve.hs +++ b/src/full/Agda/TypeChecking/SizedTypes/Solve.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE NondecreasingIndentation #-} -- | Solving size constraints under hypotheses. @@ -53,23 +52,23 @@ import Control.Monad hiding (forM, forM_) import Control.Monad.Trans.Maybe -import Control.Monad.Reader (asks) -import Data.Foldable (Foldable, foldMap, forM_) +import Data.Either +import Data.Foldable (foldMap, forM_) import qualified Data.Foldable as Fold import Data.Function import qualified Data.List as List +import Data.List.NonEmpty (NonEmpty(..), nonEmpty) +import qualified Data.List.NonEmpty as NonEmpty import Data.Monoid import qualified Data.Map as Map import Data.Set (Set) import qualified Data.Set as Set -import qualified Data.Traversable as Trav -import Data.Traversable (Traversable, forM) - -import Agda.Interaction.Options +import Data.Traversable (forM) import Agda.Syntax.Common import Agda.Syntax.Internal +import Agda.Syntax.Internal.MetaVars import Agda.TypeChecking.Monad as TCM hiding (Offset) import Agda.TypeChecking.Monad.Builtin @@ -79,7 +78,6 @@ import Agda.TypeChecking.MetaVars import Agda.TypeChecking.Substitute import Agda.TypeChecking.Telescope -import Agda.TypeChecking.Conversion import Agda.TypeChecking.Constraints as C import qualified Agda.TypeChecking.SizedTypes as S @@ -88,12 +86,10 @@ import Agda.TypeChecking.SizedTypes.WarshallSolver as Size import Agda.Utils.Cluster -import Agda.Utils.Either import Agda.Utils.Except ( MonadError(catchError) ) import Agda.Utils.Function import Agda.Utils.Functor import Agda.Utils.Lens -import Agda.Utils.NonemptyList as NeList import qualified Agda.Utils.List as List @@ -104,10 +100,8 @@ import qualified Agda.Utils.Pretty as P import Agda.Utils.Singleton import Agda.Utils.Size -import Agda.Utils.Tuple import qualified Agda.Utils.VarSet as VarSet -#include "undefined.h" import Agda.Utils.Impossible type CC = Closure TCM.Constraint @@ -125,13 +119,14 @@ -- 1. Take out the size constraints normalised. - cs0 <- mapM (mapClosure normalise) =<< S.takeSizeConstraints + cs0 <- mapM (mapClosure normalise) =<< S.takeSizeConstraints (== CmpLeq) -- NOTE: this deletes the size constraints from the constraint set! unless (null cs0) $ reportSDoc "tc.size.solve" 40 $ vcat $ [ text $ "Solving constraints (" ++ show flag ++ ")" ] ++ map prettyTCM cs0 let -- Error for giving up + cannotSolve :: TCM a cannotSolve = typeError . GenericDocError =<< vcat ("Cannot solve size constraints" : map prettyTCM cs0) @@ -149,10 +144,10 @@ sizeMetaSet `Set.intersection` allMetas singleton c) -- Now, some constraints may have no metas (clcs), the others have at least one (othercs). - let classify :: (a, [b]) -> Either a (a, NonemptyList b) + let classify :: (a, [b]) -> Either a (a, NonEmpty b) classify (cl, []) = Left cl - classify (cl, (x:xs)) = Right (cl, x :! xs) - let (clcs, othercs) = List.mapEither classify cms + classify (cl, (x:xs)) = Right (cl, x :| xs) + let (clcs, othercs) = partitionEithers $ map classify cms -- We cluster the constraints by their metas. let ccs = cluster' othercs @@ -166,15 +161,20 @@ -- Solve the clusters. constrainedMetas <- Set.unions <$> do - forM (ccs) $ \ (cs :: NonemptyList CC) -> do + forM (ccs) $ \ (cs :: NonEmpty CC) -> do + reportSDoc "tc.size.solve" 60 $ vcat $ concat + [ [ "size constraint cluster:" ] + , map (text . show) $ NonEmpty.toList cs + ] + -- Convert each constraint in the cluster to the largest context. -- (Keep fingers crossed). enterClosure (Fold.maximumBy (compare `on` (length . envContext . clEnv)) cs) $ \ _ -> do -- Get all constraints that can be cast to the longest context. cs' :: [TCM.Constraint] <- catMaybes <$> do - mapM (runMaybeT . castConstraintToCurrentContext) $ toList cs + mapM (runMaybeT . castConstraintToCurrentContext) $ NonEmpty.toList cs reportSDoc "tc.size.solve" 20 $ vcat $ [ "converted size constraints to context: " <+> do @@ -266,7 +266,7 @@ let gamma2 = gamma - size gamma1 -- Γ ⊢ σ : Δ₁ - sigma <- liftTCM $ getModuleParameterSub modN + sigma <- liftTCM $ fromMaybe idS <$> getModuleParameterSub modN -- Debug printing. reportSDoc "tc.constr.cast" 40 $ "casting constraint" $$ do @@ -308,7 +308,7 @@ where raiseMaybe n c = do -- Fine if we have to weaken or strengthening is safe. - guard $ n >= 0 || List.all (>= -n) (VarSet.toList $ allVars $ freeVars c) + guard $ n >= 0 || List.all (>= -n) (VarSet.toList $ allFreeVars c) return $ raise n c @@ -371,13 +371,13 @@ -- Cluster constraints according to the meta variables they mention. -- @csNoM@ are the constraints that do not mention any meta. let (csNoM, csMs) = (`List.partitionMaybe` ccs') $ \ p@(c0, c) -> - fmap (p,) $ NeList.fromList $ map (metaId . sizeMetaId) $ Set.toList $ flexs c + fmap (p,) $ nonEmpty $ map (metaId . sizeMetaId) $ Set.toList $ flexs c -- @css@ are the clusters of constraints. - css :: [NonemptyList (CC,HypSizeConstraint)] + css :: [NonEmpty (CC,HypSizeConstraint)] css = cluster' csMs -- Check that the closed constraints are valid. - whenJust (NeList.fromList csNoM) $ solveCluster flag + whenJust (nonEmpty csNoM) $ solveCluster flag -- Now, process the clusters. forM_ css $ solveCluster flag @@ -386,10 +386,10 @@ -- | Solve a cluster of constraints sharing some metas. -- -solveCluster :: DefaultToInfty -> NonemptyList (CC,HypSizeConstraint) -> TCM () +solveCluster :: DefaultToInfty -> NonEmpty (CC,HypSizeConstraint) -> TCM () solveCluster flag ccs = do let cs = fmap snd ccs - let prettyCs = map prettyTCM $ NeList.toList cs + let prettyCs = map prettyTCM $ NonEmpty.toList cs let err reason = typeError . GenericDocError =<< do vcat $ [ text $ "Cannot solve size constraints" ] ++ prettyCs ++ @@ -427,7 +427,7 @@ -- Canonicalize the constraints. -- This is unsound in the presence of hypotheses. csC :: [SizeConstraint] - csC = applyWhen (null hs) (mapMaybe canonicalizeSizeConstraint) $ NeList.toList csL + csC = applyWhen (null hs) (mapMaybe canonicalizeSizeConstraint) $ NonEmpty.toList csL reportSDoc "tc.size.solve" 30 $ vcat $ [ "Size hypotheses" ] ++ map (prettyTCM . HypSizeConstraint gamma hids hs) hs ++ @@ -474,7 +474,7 @@ -- Construct the hypotheses graph. let hyps = map (fmap (metaId . sizeMetaId)) hs -- There cannot be negative cycles in hypotheses graph due to scoping. - let hg = fromRight __IMPOSSIBLE__ $ hypGraph (rigids csF) hyps + let hg = either __IMPOSSIBLE__ id $ hypGraph (rigids csF) hyps -- -- Construct the constraint graph. -- -- g :: Size.Graph NamedRigid Int Label @@ -507,7 +507,7 @@ -- unless ok $ err "ill-scoped solution for size meta variable" u <- if ok then return u else primSizeInf t <- getMetaType x - reportSDoc "tc.size.solve" 20 $ inTopContext $ modifyContext (const gamma) $ do + reportSDoc "tc.size.solve" 20 $ unsafeModifyContext (const gamma) $ do let args = map (Apply . defaultArg . var) xs "solution " <+> prettyTCM (MetaV x args) <+> " := " <+> prettyTCM u reportSDoc "tc.size.solve" 60 $ vcat @@ -555,7 +555,7 @@ reportSDoc "tc.size.solve" 20 $ "solution " <+> prettyTCM (MetaV m []) <+> " := " <+> prettyTCM inf - t <- jMetaType . mvJudgement <$> lookupMeta m + t <- metaType m TelV tel core <- telView t unlessM (isJust <$> isSizeType core) __IMPOSSIBLE__ assignMeta 0 m t (List.downFrom $ size tel) inf @@ -563,7 +563,7 @@ -- Double check. when solvedAll $ do - let cs0 = map fst $ toList ccs + let cs0 = map fst $ NonEmpty.toList ccs -- Error for giving up cannotSolve = typeError . GenericDocError =<< vcat ("Cannot solve size constraints" : map prettyTCM cs0) @@ -573,7 +573,7 @@ -- | Collect constraints from a typing context, looking for SIZELT hypotheses. getSizeHypotheses :: Context -> TCM [(Nat, SizeConstraint)] -getSizeHypotheses gamma = inTopContext $ modifyContext (const gamma) $ do +getSizeHypotheses gamma = unsafeModifyContext (const gamma) $ do (_, msizelt) <- getBuiltinSize caseMaybe msizelt (return []) $ \ sizelt -> do -- Traverse the context from newest to oldest de Bruijn Index @@ -735,7 +735,7 @@ instance PrettyTCM HypSizeConstraint where prettyTCM (HypSizeConstraint cxt _ hs c) = - inTopContext $ modifyContext (const cxt) $ do + unsafeModifyContext (const cxt) $ do let cxtNames = reverse $ map (fst . unDom) cxt -- text ("[#cxt=" ++ show (size cxt) ++ "]") <+> do prettyList (map prettyTCM cxtNames) <+> do @@ -747,7 +747,7 @@ computeSizeConstraint :: Closure TCM.Constraint -> TCM (Maybe HypSizeConstraint) computeSizeConstraint c = do let cxt = envContext $ clEnv c - inTopContext $ modifyContext (const cxt) $ do + unsafeModifyContext (const cxt) $ do case clValue c of ValueCmp CmpLeq _ u v -> do reportSDoc "tc.size.solve" 50 $ sep $ @@ -790,10 +790,10 @@ _ -> Nothing -- | Turn a de size expression into a term. -unSizeExpr :: DBSizeExpr -> TCM Term +unSizeExpr :: HasBuiltins m => DBSizeExpr -> m Term unSizeExpr a = case a of - Infty -> primSizeInf + Infty -> fromMaybe __IMPOSSIBLE__ <$> getBuiltin' builtinSizeInf Rigid r (O n) -> do unless (n >= 0) __IMPOSSIBLE__ sizeSuc n $ var $ rigidIndex r diff --git a/src/full/Agda/TypeChecking/SizedTypes/Syntax.hs b/src/full/Agda/TypeChecking/SizedTypes/Syntax.hs --- a/src/full/Agda/TypeChecking/SizedTypes/Syntax.hs +++ b/src/full/Agda/TypeChecking/SizedTypes/Syntax.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} {-# LANGUAGE NoMonomorphismRestriction #-} {-# LANGUAGE UndecidableInstances #-} @@ -7,13 +6,9 @@ module Agda.TypeChecking.SizedTypes.Syntax where -#if MIN_VERSION_base(4,11,0) -import Prelude hiding ( (<>), null ) -#else import Prelude hiding ( null ) -#endif -import Data.Maybe + import Data.Foldable (Foldable) import Data.Map (Map) import qualified Data.Map as Map diff --git a/src/full/Agda/TypeChecking/SizedTypes/WarshallSolver.hs b/src/full/Agda/TypeChecking/SizedTypes/WarshallSolver.hs --- a/src/full/Agda/TypeChecking/SizedTypes/WarshallSolver.hs +++ b/src/full/Agda/TypeChecking/SizedTypes/WarshallSolver.hs @@ -1,15 +1,10 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE NoMonomorphismRestriction #-} module Agda.TypeChecking.SizedTypes.WarshallSolver where -#if MIN_VERSION_base(4,11,0) -import Prelude hiding ( (<>), null, truncate ) -#else import Prelude hiding ( null, truncate ) -#endif -import Control.Applicative hiding (Const, empty) + import Control.Monad import Data.Function (on) @@ -32,7 +27,6 @@ import Agda.Utils.Null import Agda.Utils.Pretty -#include "undefined.h" import Agda.Utils.Impossible type Graph r f a = Graph.Graph (Node r f) a diff --git a/src/full/Agda/TypeChecking/Sort.hs b/src/full/Agda/TypeChecking/Sort.hs --- a/src/full/Agda/TypeChecking/Sort.hs +++ b/src/full/Agda/TypeChecking/Sort.hs @@ -1,4 +1,4 @@ -{-# LANGUAGE CPP #-} +{-# LANGUAGE ScopedTypeVariables #-} -- | This module contains the rules for Agda's sort system viewed as a pure -- type system (pts). The specification of a pts consists of a set @@ -23,29 +23,43 @@ import Control.Monad +import Data.Functor +import Data.Maybe + +import Agda.Interaction.Options (optCumulativity) + import Agda.Syntax.Common import Agda.Syntax.Internal -import {-# SOURCE #-} Agda.TypeChecking.Constraints (addConstraint) +import {-# SOURCE #-} Agda.TypeChecking.Constraints () -- instance only import {-# SOURCE #-} Agda.TypeChecking.Conversion -import {-# SOURCE #-} Agda.TypeChecking.MetaVars +import {-# SOURCE #-} Agda.TypeChecking.MetaVars () -- instance only -import Agda.TypeChecking.Free -import Agda.TypeChecking.Irrelevance import Agda.TypeChecking.Monad.Base +import Agda.TypeChecking.Monad.Builtin (HasBuiltins) +import Agda.TypeChecking.Monad.Constraints (addConstraint, MonadConstraint) import Agda.TypeChecking.Monad.Context import Agda.TypeChecking.Monad.Debug +import Agda.TypeChecking.Monad.MetaVars (metaType) +import Agda.TypeChecking.Monad.Signature (HasConstInfo(..), applyDef) import Agda.TypeChecking.Pretty +import Agda.TypeChecking.ProjectionLike (elimView) +import Agda.TypeChecking.Records (getDefType) import Agda.TypeChecking.Reduce import Agda.TypeChecking.Substitute +import Agda.TypeChecking.Telescope -#include "undefined.h" +import Agda.Utils.Except import Agda.Utils.Impossible +import Agda.Utils.Lens +import Agda.Utils.Monad -- | Infer the sort of another sort. If we can compute the bigger sort -- straight away, return that. Otherwise, return @UnivSort s@ and add a -- constraint to ensure we can compute the sort eventually. -inferUnivSort :: Sort -> TCM Sort +inferUnivSort + :: (MonadReduce m, MonadConstraint m, HasOptions m) + => Sort -> m Sort inferUnivSort s = do s <- reduce s ui <- univInf @@ -55,23 +69,29 @@ addConstraint $ HasBiggerSort s return $ UnivSort s -sortFitsIn :: Sort -> Sort -> TCM () +sortFitsIn :: MonadConversion m => Sort -> Sort -> m () sortFitsIn a b = do b' <- inferUnivSort a - equalSort b' b -- CUMULATIVITY: leqSort b' b + ifM (optCumulativity <$> pragmaOptions) + (leqSort b' b) + (equalSort b' b) hasBiggerSort :: Sort -> TCM () hasBiggerSort = void . inferUnivSort -- | Infer the sort of a pi type. If we can compute the sort straight away, --- return that. Otherwise, return @PiSort s1 s2@ and add a constraint to +-- return that. Otherwise, return @PiSort a s2@ and add a constraint to -- ensure we can compute the sort eventually. -inferPiSort :: Sort -> Abs Sort -> TCM Sort -inferPiSort s1 s2 = do - (s1,s2) <- reduce (s1,s2) +inferPiSort + :: (MonadReduce m, MonadAddContext m, MonadDebug m) + => Dom Type -> Abs Sort -> m Sort +inferPiSort a s2 = do + s1' <- reduce $ getSort a + let a' = set lensSort s1' a + s2' <- mapAbstraction a' reduce s2 -- we do instantiateFull here to perhaps remove some (flexible) -- dependencies of s2 on var 0, thus allowing piSort' to reduce - s2 <- instantiateFull s2 + s2' <- instantiateFull s2' --Jesper, 2018-04-23: disabled PTS constraints for now, --this assumes that piSort can only be blocked by unsolved metas. @@ -82,33 +102,102 @@ -- addConstraint $ HasPTSRule s1 s2 -- return $ PiSort s1 s2 - return $ piSort s1 s2 + return $ piSort a' s2' -- | As @inferPiSort@, but for a nondependent function type. inferFunSort :: Sort -> Sort -> TCM Sort -inferFunSort s1 s2 = inferPiSort s1 $ NoAbs underscore s2 +inferFunSort s1 s2 = funSort <$> reduce s1 <*> reduce s2 -ptsRule :: Sort -> Abs Sort -> Sort -> TCM () +ptsRule :: Dom Type -> Abs Sort -> Sort -> TCM () ptsRule a b c = do c' <- inferPiSort a b - equalSort c' c -- CUMULATIVITY: leqSort c' c + ifM (optCumulativity <$> pragmaOptions) + (leqSort c' c) + (equalSort c' c) -- | Non-dependent version of ptsRule ptsRule' :: Sort -> Sort -> Sort -> TCM () ptsRule' a b c = do c' <- inferFunSort a b - equalSort c' c -- CUMULATIVITY: leqSort c' c + ifM (optCumulativity <$> pragmaOptions) + (leqSort c' c) + (equalSort c' c) -hasPTSRule :: Sort -> Abs Sort -> TCM () +hasPTSRule :: Dom Type -> Abs Sort -> TCM () hasPTSRule a b = void $ inferPiSort a b -- | Recursively check that an iterated function type constructed by @telePi@ -- is well-sorted. checkTelePiSort :: Type -> TCM () -checkTelePiSort (El s (Pi a b)) = do - -- Since the function type is assumed to be constructed by @telePi@, - -- we already know that @s == piSort (getSort a) (getSort <$> b)@, - -- so we just check that this sort is well-formed. - hasPTSRule (getSort a) (getSort <$> b) - underAbstraction a b checkTelePiSort +-- Jesper, 2019-07-27: This is currently doing nothing (see comment in inferPiSort) +--checkTelePiSort (El s (Pi a b)) = do +-- -- Since the function type is assumed to be constructed by @telePi@, +-- -- we already know that @s == piSort (getSort a) (getSort <$> b)@, +-- -- so we just check that this sort is well-formed. +-- hasPTSRule a (getSort <$> b) +-- underAbstraction a b checkTelePiSort checkTelePiSort _ = return () + +ifIsSort :: (MonadReduce m) => Type -> (Sort -> m a) -> m a -> m a +ifIsSort t yes no = do + t <- reduce t + case unEl t of + Sort s -> yes s + _ -> no + +-- | Result is in reduced form. +shouldBeSort + :: (MonadReduce m, MonadTCEnv m, ReadTCState m, MonadError TCErr m) + => Type -> m Sort +shouldBeSort t = ifIsSort t return (typeError $ ShouldBeASort t) + +-- | Reconstruct the sort of a type. +-- +-- Precondition: given term is a well-sorted type. +sortOf + :: forall m. (MonadReduce m, MonadTCEnv m, MonadAddContext m, HasBuiltins m, HasConstInfo m) + => Term -> m Sort +sortOf t = do + reportSDoc "tc.sort" 40 $ "sortOf" <+> prettyTCM t + sortOfT =<< elimView True t + + where + sortOfT :: Term -> m Sort + sortOfT = \case + Pi adom b -> do + let a = unEl $ unDom adom + sa <- sortOf a + sb <- mapAbstraction adom (sortOf . unEl) b + return $ piSort (adom $> El sa a) sb + Sort s -> do + ui <- univInf + return $ univSort ui s + Var i es -> do + a <- typeOfBV i + sortOfE a (Var i) es + Def f es -> do + a <- defType <$> getConstInfo f + sortOfE a (Def f) es + MetaV x es -> do + a <- metaType x + sortOfE a (MetaV x) es + Lam{} -> __IMPOSSIBLE__ + Con{} -> __IMPOSSIBLE__ + Lit{} -> __IMPOSSIBLE__ + Level{} -> __IMPOSSIBLE__ + DontCare{} -> __IMPOSSIBLE__ + Dummy s _ -> __IMPOSSIBLE_VERBOSE__ s + + sortOfE :: Type -> (Elims -> Term) -> Elims -> m Sort + sortOfE a hd [] = ifIsSort a return __IMPOSSIBLE__ + sortOfE a hd (e:es) = case e of + Apply (Arg ai v) -> ifNotPiType a __IMPOSSIBLE__ $ \b c -> do + sortOfE (c `absApp` v) (hd . (e:)) es + Proj o f -> do + a <- reduce a + ~(El _ (Pi b c)) <- fromMaybe __IMPOSSIBLE__ <$> getDefType f a + hd' <- applyE <$> applyDef o f (argFromDom b $> hd []) + sortOfE (c `absApp` (hd [])) hd' es + IApply x y r -> do + (b , c) <- fromMaybe __IMPOSSIBLE__ <$> isPath a + sortOfE (c `absApp` r) (hd . (e:)) es diff --git a/src/full/Agda/TypeChecking/Substitute.hs b/src/full/Agda/TypeChecking/Substitute.hs --- a/src/full/Agda/TypeChecking/Substitute.hs +++ b/src/full/Agda/TypeChecking/Substitute.hs @@ -1,7 +1,7 @@ {-# LANGUAGE BangPatterns #-} -{-# LANGUAGE CPP #-} -{-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE UndecidableInstances #-} +{-# LANGUAGE AllowAmbiguousTypes #-} +{-# LANGUAGE TypeApplications #-} {-# OPTIONS_GHC -fno-warn-orphans #-} @@ -19,13 +19,14 @@ , Substitution'(..), Substitution ) where -import Control.Arrow (first, second) +import Control.Arrow (second) +import Control.Monad (guard) +import Data.Coerce import Data.Function -import Data.Functor import qualified Data.List as List import Data.Map (Map) import Data.Maybe -import Data.Monoid +import Data.HashMap.Strict (HashMap) import Debug.Trace (trace) import Language.Haskell.TH.Syntax (thenCmp) -- lexicographic combination of Ordering @@ -37,7 +38,6 @@ import Agda.Syntax.Internal import Agda.Syntax.Internal.Pattern import qualified Agda.Syntax.Abstract as A -import Agda.Syntax.Position (Range) import Agda.TypeChecking.Monad.Base import Agda.TypeChecking.Monad.Options (typeInType) @@ -51,37 +51,54 @@ import Agda.Utils.Empty import Agda.Utils.Functor import Agda.Utils.List +import qualified Agda.Utils.Maybe.Strict as Strict import Agda.Utils.Monad import Agda.Utils.Permutation import Agda.Utils.Pretty import Agda.Utils.Size import Agda.Utils.Tuple -import Agda.Utils.HashMap (HashMap) -#include "undefined.h" import Agda.Utils.Impossible -instance Apply Term where - applyE m [] = m - applyE m es = - case m of + +-- | Apply @Elims@ while using the given function to report ill-typed +-- redexes. +-- Recursive calls for @applyE@ and @applySubst@ happen at type @t@ to +-- propagate the same strategy to subtrees. +{-# SPECIALIZE applyTermE :: (Empty -> Term -> Elims -> Term) -> Term -> Elims -> Term #-} +{-# SPECIALIZE applyTermE :: (Empty -> Term -> Elims -> Term) -> BraveTerm -> Elims -> BraveTerm #-} +applyTermE :: forall t. (Coercible Term t, Apply t, Subst t t) + => (Empty -> Term -> Elims -> Term) -> t -> Elims -> t +applyTermE err' m [] = m +applyTermE err' m es = coerce $ + case coerce m of Var i es' -> Var i (es' ++ es) Def f es' -> defApp f es' es -- remove projection redexes - Con c ci args -> conApp c ci args es + Con c ci args -> conApp @t err' c ci args es Lam _ b -> case es of - Apply a : es0 -> lazyAbsApp b (unArg a) `applyE` es0 - IApply _ _ a : es0 -> lazyAbsApp b a `applyE` es0 - _ -> __IMPOSSIBLE__ + Apply a : es0 -> lazyAbsApp (coerce b :: Abs t) (coerce $ unArg a) `app` es0 + IApply _ _ a : es0 -> lazyAbsApp (coerce b :: Abs t) (coerce a) `app` es0 + _ -> err __IMPOSSIBLE__ MetaV x es' -> MetaV x (es' ++ es) - Lit{} -> __IMPOSSIBLE__ - Level{} -> __IMPOSSIBLE__ - Pi _ _ -> __IMPOSSIBLE__ + Lit{} -> err __IMPOSSIBLE__ + Level{} -> err __IMPOSSIBLE__ + Pi _ _ -> err __IMPOSSIBLE__ Sort s -> Sort $ s `applyE` es - Dummy{} -> __IMPOSSIBLE__ - DontCare mv -> dontCare $ mv `applyE` es -- Andreas, 2011-10-02 + Dummy s es' -> Dummy s (es' ++ es) + DontCare mv -> dontCare $ mv `app` es -- Andreas, 2011-10-02 -- need to go under DontCare, since "with" might resurrect irrelevant term + where + app :: Coercible t x => x -> Elims -> Term + app t es = coerce $ (coerce t :: t) `applyE` es + err e = err' e (coerce m) es +instance Apply Term where + applyE = applyTermE absurd + +instance Apply BraveTerm where + applyE = applyTermE (\ _ t es -> Dummy "applyE" (Apply (defaultArg t) : es)) + -- | If $v$ is a record value, @canProject f v@ -- returns its field @f@. canProject :: QName -> Term -> Maybe (Arg Term) @@ -89,29 +106,38 @@ case v of (Con (ConHead _ _ fs) _ vs) -> do (fld, i) <- findWithIndex ((f==) . unArg) fs + -- Jesper, 2019-10-17: dont unfold irrelevant projections + guard $ not $ isIrrelevant fld -- Andreas, 2018-06-12, issue #2170 -- The ArgInfo from the ConHead is more accurate (relevance subtyping!). - setArgInfo (getArgInfo fld) <.> isApplyElim =<< headMaybe (drop i vs) + setArgInfo (getArgInfo fld) <.> isApplyElim =<< listToMaybe (drop i vs) _ -> Nothing -- | Eliminate a constructed term. -conApp :: ConHead -> ConInfo -> Elims -> Elims -> Term -conApp ch ci args [] = Con ch ci args -conApp ch ci args (a@Apply{} : es) = conApp ch ci (args ++ [a]) es -conApp ch ci args (a@IApply{} : es) = conApp ch ci (args ++ [a]) es -conApp ch@(ConHead c _ fs) ci args (Proj o f : es) = +conApp :: forall t. (Coercible t Term, Apply t) => (Empty -> Term -> Elims -> Term) -> ConHead -> ConInfo -> Elims -> Elims -> Term +conApp fk ch ci args [] = Con ch ci args +conApp fk ch ci args (a@Apply{} : es) = conApp @t fk ch ci (args ++ [a]) es +conApp fk ch ci args (a@IApply{} : es) = conApp @t fk ch ci (args ++ [a]) es +conApp fk ch@(ConHead c _ fs) ci args ees@(Proj o f : es) = let failure err = flip trace err $ "conApp: constructor " ++ show c ++ " with fields\n" ++ unlines (map ((" " ++) . show) fs) ++ " and args\n" ++ unlines (map ((" " ++) . prettyShow) args) ++ " projected by " ++ show f isApply e = fromMaybe (failure __IMPOSSIBLE__) $ isApplyElim e - (fld, i) = fromMaybe (failure __IMPOSSIBLE__) $ findWithIndex ((f==) . unArg) fs + stuck err = fk err (Con ch ci args) [Proj o f] + -- Recurse using the instance for 't', see @applyTermE@ + app :: Term -> Elims -> Term + app v es = coerce $ applyE (coerce v :: t) es + in + case findWithIndex ((f==) . unArg) fs of + Nothing -> failure $ stuck __IMPOSSIBLE__ `app` es + Just (fld, i) -> let -- Andreas, 2018-06-12, issue #2170 -- We safe-guard the projected value by DontCare using the ArgInfo stored at the record constructor, -- since the ArgInfo in the constructor application might be inaccurate because of subtyping. - v = maybe (failure __IMPOSSIBLE__) (relToDontCare fld . argToDontCare . isApply) $ headMaybe $ drop i args - in applyE v es + v = maybe (failure $ stuck __IMPOSSIBLE__) (relToDontCare fld . argToDontCare . isApply) $ listToMaybe $ drop i args + in v `app` es -- -- Andreas, 2016-07-20 futile attempt to magically fix ProjOrigin -- fallback = v @@ -132,10 +158,10 @@ {- i = maybe failure id $ elemIndex f $ map unArg fs - v = maybe failure unArg $ headMaybe $ drop i args + v = maybe failure unArg $ listToMaybe $ drop i args -- Andreas, 2013-10-20 see Issue543a: -- protect result of irrelevant projection. - r = maybe __IMPOSSIBLE__ getRelevance $ headMaybe $ drop i fs + r = maybe __IMPOSSIBLE__ getRelevance $ listToMaybe $ drop i fs u | Irrelevant <- r = DontCare v | otherwise = v in applyE v es @@ -201,8 +227,8 @@ applyE t es = apply t $ fromMaybe __IMPOSSIBLE__ $ allApplyElims es instance Apply Definition where - apply (Defn info x t pol occ gens gpars df m c inst copy ma nc inj d) args = - Defn info x (piApply t args) (apply pol args) (apply occ args) (apply gens args) (drop (length args) gpars) df m c inst copy ma nc inj (apply d args) + apply (Defn info x t pol occ gens gpars df m c inst copy ma nc inj copat blk d) args = + Defn info x (piApply t args) (apply pol args) (apply occ args) (apply gens args) (drop (length args) gpars) df m c inst copy ma nc inj copat blk (apply d args) applyE t es = apply t $ fromMaybe __IMPOSSIBLE__ $ allApplyElims es @@ -272,16 +298,17 @@ DataOrRecSig n -> DataOrRecSig (n - length args) GeneralizableVar{} -> d AbstractDefn d -> AbstractDefn $ apply d args - Function{ funClauses = cs, funCompiled = cc, funInv = inv + Function{ funClauses = cs, funCompiled = cc, funCovering = cov, funInv = inv , funExtLam = extLam , funProjection = Nothing } -> d { funClauses = apply cs args , funCompiled = apply cc args + , funCovering = apply cov args , funInv = apply inv args , funExtLam = modifySystem (`apply` args) <$> extLam } - Function{ funClauses = cs, funCompiled = cc, funInv = inv + Function{ funClauses = cs, funCompiled = cc, funCovering = cov, funInv = inv , funExtLam = extLam , funProjection = Just p0} -> case p0 `apply` args of @@ -293,6 +320,7 @@ | otherwise -> d { funClauses = apply cs args' , funCompiled = apply cc args' + , funCovering = apply cov args' , funInv = apply inv args' , funProjection = if isVar0 then Just p{ projIndex = 0 } else Nothing , funExtLam = modifySystem (\ _ -> __IMPOSSIBLE__) <$> extLam @@ -341,7 +369,7 @@ -- It is assumed that we only apply a clause to "parameters", i.e. -- arguments introduced by lambda lifting. The problem is that these aren't -- necessarily the first elements of the clause telescope. - apply cls@(Clause rl rf tel ps b t catchall unreachable) args + apply cls@(Clause rl rf tel ps b t catchall recursive unreachable ell) args | length args > length ps = __IMPOSSIBLE__ | otherwise = Clause rl rf @@ -350,7 +378,9 @@ (applySubst rho b) (applySubst rho t) catchall + recursive unreachable + ell where -- We have -- Γ ⊢ args, for some outer context Γ @@ -508,6 +538,10 @@ apply x args = fmap (`apply` args) x applyE x es = fmap (`applyE` es) x +instance Apply t => Apply (Strict.Maybe t) where + apply x args = fmap (`apply` args) x + applyE x es = fmap (`applyE` es) x + instance Apply v => Apply (Map k v) where apply x args = fmap (`apply` args) x applyE x es = fmap (`applyE` es) x @@ -576,9 +610,9 @@ ExtendTel arg xtel `abstract` tel = ExtendTel arg $ xtel <&> (`abstract` tel) instance Abstract Definition where - abstract tel (Defn info x t pol occ gens gpars df m c inst copy ma nc inj d) = + abstract tel (Defn info x t pol occ gens gpars df m c inst copy ma nc inj copat blk d) = Defn info x (abstract tel t) (abstract tel pol) (abstract tel occ) (abstract tel gens) - (replicate (size tel) Nothing ++ gpars) df m c inst copy ma nc inj (abstract tel d) + (replicate (size tel) Nothing ++ gpars) df m c inst copy ma nc inj copat blk (abstract tel d) -- | @tel ⊢ (Γ ⊢ lhs ↦ rhs : t)@ becomes @tel, Γ ⊢ lhs ↦ rhs : t)@ -- we do not need to change lhs, rhs, and t since they live in Γ. @@ -618,15 +652,16 @@ DataOrRecSig n -> DataOrRecSig (size tel + n) GeneralizableVar{} -> d AbstractDefn d -> AbstractDefn $ abstract tel d - Function{ funClauses = cs, funCompiled = cc, funInv = inv + Function{ funClauses = cs, funCompiled = cc, funCovering = cov, funInv = inv , funExtLam = extLam , funProjection = Nothing } -> d { funClauses = abstract tel cs , funCompiled = abstract tel cc + , funCovering = abstract tel cov , funInv = abstract tel inv , funExtLam = modifySystem (abstract tel) <$> extLam } - Function{ funClauses = cs, funCompiled = cc, funInv = inv + Function{ funClauses = cs, funCompiled = cc, funCovering = cov, funInv = inv , funExtLam = extLam , funProjection = Just p } -> -- Andreas, 2015-05-11 if projection was applied to Var 0 @@ -634,6 +669,7 @@ if projIndex p > 0 then d' else d' { funClauses = abstract tel1 cs , funCompiled = abstract tel1 cc + , funCovering = abstract tel1 cov , funInv = abstract tel1 inv , funExtLam = modifySystem (\ _ -> __IMPOSSIBLE__) <$> extLam } @@ -660,13 +696,15 @@ where n = size tel instance Abstract Clause where - abstract tel (Clause rl rf tel' ps b t catchall unreachable) = + abstract tel (Clause rl rf tel' ps b t catchall recursive unreachable ell) = Clause rl rf (abstract tel tel') (namedTelVars m tel ++ ps) b t -- nothing to do for t, since it lives under the telescope catchall + recursive unreachable + ell where m = size tel + size tel' instance Abstract CompiledClauses where @@ -717,7 +755,7 @@ names = cycle $ map (stringToArgName . (:[])) ['a'..'z'] --------------------------------------------------------------------------- --- * Substitution and raising/shifting/weakening +-- * Substitution and shifting\/weakening\/strengthening --------------------------------------------------------------------------- -- | If @permute π : [a]Γ -> [a]Δ@, then @applySubst (renaming _ π) : Term Γ -> Term Δ@ @@ -739,45 +777,60 @@ instance Subst a a => Subst a (Substitution' a) where applySubst rho sgm = composeS rho sgm -instance Subst Term Term where - applySubst IdS t = t - applySubst rho t = case t of - Var i es -> lookupS rho i `applyE` applySubst rho es - Lam h m -> Lam h $ applySubst rho m - Def f es -> defApp f [] $ applySubst rho es - Con c ci vs -> Con c ci $ applySubst rho vs - MetaV x es -> MetaV x $ applySubst rho es +{-# SPECIALIZE applySubstTerm :: Substitution -> Term -> Term #-} +{-# SPECIALIZE applySubstTerm :: Substitution' BraveTerm -> BraveTerm -> BraveTerm #-} +applySubstTerm :: forall t. (Coercible t Term, Subst t t, Apply t) => Substitution' t -> t -> t +applySubstTerm IdS t = t +applySubstTerm rho t = coerce $ case coerce t of + Var i es -> coerce $ lookupS rho i `applyE` subE es + Lam h m -> Lam h $ sub @(Abs t) m + Def f es -> defApp f [] $ subE es + Con c ci vs -> Con c ci $ subE vs + MetaV x es -> MetaV x $ subE es Lit l -> Lit l - Level l -> levelTm $ applySubst rho l - Pi a b -> uncurry Pi $ applySubst rho (a,b) - Sort s -> Sort $ applySubst rho s - DontCare mv -> dontCare $ applySubst rho mv - Dummy{} -> t + Level l -> levelTm $ sub @(Level' t) l + Pi a b -> uncurry Pi $ subPi (a,b) + Sort s -> Sort $ sub @(Sort' t) s + DontCare mv -> dontCare $ sub @t mv + Dummy s es -> Dummy s $ subE es + where + sub :: forall a b. (Coercible b a, Subst t a) => b -> b + sub t = coerce $ applySubst rho (coerce t :: a) + subE :: Elims -> Elims + subE = sub @[Elim' t] + subPi :: (Dom Type, Abs Type) -> (Dom Type, Abs Type) + subPi = sub @(Dom' t (Type'' t t), Abs (Type'' t t)) -instance Subst Term a => Subst Term (Type' a) where +instance Subst Term Term where + applySubst = applySubstTerm + +instance Subst BraveTerm BraveTerm where + applySubst = applySubstTerm + +instance (Coercible a Term, Subst t a, Subst t b) => Subst t (Type'' a b) where applySubst rho (El s t) = applySubst rho s `El` applySubst rho t -instance Subst Term Sort where +instance (Coercible a Term, Subst t a) => Subst t (Sort' a) where applySubst rho s = case s of Type n -> Type $ sub n Prop n -> Prop $ sub n Inf -> Inf SizeUniv -> SizeUniv - PiSort s1 s2 -> piSort (sub s1) (sub s2) - UnivSort s -> univSort Nothing $ sub s + PiSort a s2 -> coerce $ piSort (coerce $ sub a) (coerce $ sub s2) + FunSort s1 s2 -> coerce $ funSort (coerce $ sub s1) (coerce $ sub s2) + UnivSort s -> coerce $ univSort Nothing $ coerce $ sub s MetaS x es -> MetaS x $ sub es DefS d es -> DefS d $ sub es DummyS{} -> s where sub x = applySubst rho x -instance Subst Term Level where - applySubst rho (Max as) = Max $ applySubst rho as +instance Subst t a => Subst t (Level' a) where + applySubst rho (Max n as) = Max n $ applySubst rho as -instance Subst Term PlusLevel where - applySubst rho l@ClosedLevel{} = l +instance Subst t a => Subst t (PlusLevel' a) where applySubst rho (Plus n l) = Plus n $ applySubst rho l -instance Subst Term LevelAtom where +instance Subst t a => Subst t (LevelAtom' a) where applySubst rho (MetaLevel m vs) = MetaLevel m $ applySubst rho vs applySubst rho (BlockedLevel m v) = BlockedLevel m $ applySubst rho v applySubst rho (NeutralLevel _ v) = UnreducedLevel $ applySubst rho v @@ -798,7 +851,7 @@ DefP o q ps -> DefP o q $ applySubst rho ps DotP o t -> DotP o $ applySubst rho t VarP o s -> p - LitP l -> p + LitP o l -> p ProjP{} -> p IApplyP o t u x -> IApplyP o (applySubst rho t) (applySubst rho u) x @@ -806,16 +859,19 @@ applySubst rho (A.ProblemEq p v a) = uncurry (A.ProblemEq p) $ applySubst rho (v,a) +instance DeBruijn BraveTerm where + deBruijnVar = BraveTerm . deBruijnVar + deBruijnView = deBruijnView . unBrave instance DeBruijn NLPat where deBruijnVar i = PVar i [] deBruijnView p = case p of PVar i [] -> Just i PVar{} -> Nothing - PWild{} -> Nothing PDef{} -> Nothing PLam{} -> Nothing PPi{} -> Nothing + PSort{} -> Nothing PBoundVar{} -> Nothing -- or... ? PTerm{} -> Nothing -- or... ? @@ -826,19 +882,22 @@ nlPatToTerm p = case p of PVar i xs -> Var i $ map (Apply . fmap var) xs PTerm u -> u - PWild -> __IMPOSSIBLE__ PDef f es -> __IMPOSSIBLE__ PLam i u -> __IMPOSSIBLE__ PPi a b -> __IMPOSSIBLE__ + PSort s -> __IMPOSSIBLE__ PBoundVar i es -> __IMPOSSIBLE__ +applyNLSubstToDom :: Subst NLPat a => Substitution' NLPat -> Dom a -> Dom a +applyNLSubstToDom rho dom = applySubst rho <$> dom{ domTactic = applyNLPatSubst rho $ domTactic dom } + instance Subst NLPat NLPat where applySubst rho p = case p of PVar i bvs -> lookupS rho i `applyBV` bvs - PWild -> p PDef f es -> PDef f $ applySubst rho es PLam i u -> PLam i $ applySubst rho u - PPi a b -> PPi (applySubst rho a) (applySubst rho b) + PPi a b -> PPi (applyNLSubstToDom rho a) (applySubst rho b) + PSort s -> PSort $ applySubst rho s PBoundVar i es -> PBoundVar i $ applySubst rho es PTerm u -> PTerm $ applyNLPatSubst rho u @@ -847,15 +906,22 @@ applyBV p ys = case p of PVar i xs -> PVar i (xs ++ ys) PTerm u -> PTerm $ u `apply` map (fmap var) ys - PWild -> __IMPOSSIBLE__ PDef f es -> __IMPOSSIBLE__ PLam i u -> __IMPOSSIBLE__ PPi a b -> __IMPOSSIBLE__ + PSort s -> __IMPOSSIBLE__ PBoundVar i es -> __IMPOSSIBLE__ instance Subst NLPat NLPType where applySubst rho (NLPType s a) = NLPType (applySubst rho s) (applySubst rho a) +instance Subst NLPat NLPSort where + applySubst rho = \case + PType l -> PType $ applySubst rho l + PProp l -> PProp $ applySubst rho l + PInf -> PInf + PSizeUniv -> PSizeUniv + instance Subst NLPat RewriteRule where applySubst rho (RewriteRule q gamma f ps rhs t) = RewriteRule q (applyNLPatSubst rho gamma) @@ -888,7 +954,6 @@ ValueCmp cmp a u v -> ValueCmp cmp (rf a) (rf u) (rf v) ValueCmpOnFace cmp p t u v -> ValueCmpOnFace cmp (rf p) (rf t) (rf u) (rf v) ElimCmp ps fs a v e1 e2 -> ElimCmp ps fs (rf a) (rf v) (rf e1) (rf e2) - TypeCmp cmp a b -> TypeCmp cmp (rf a) (rf b) TelCmp a b cmp tel1 tel2 -> TelCmp (rf a) (rf b) cmp (rf tel1) (rf tel2) SortCmp cmp s1 s2 -> SortCmp cmp (rf s1) (rf s2) LevelCmp cmp l1 l2 -> LevelCmp cmp (rf l1) (rf l2) @@ -899,11 +964,17 @@ UnBlock{} -> c CheckFunDef{} -> c HasBiggerSort s -> HasBiggerSort (rf s) - HasPTSRule s1 s2 -> HasPTSRule (rf s1) (rf s2) + HasPTSRule a s -> HasPTSRule (rf a) (rf s) UnquoteTactic m t h g -> UnquoteTactic m (rf t) (rf h) (rf g) + CheckMetaInst m -> CheckMetaInst m where rf x = applySubst rho x +instance Subst Term CompareAs where + applySubst rho (AsTermsOf a) = AsTermsOf $ applySubst rho a + applySubst rho AsSizes = AsSizes + applySubst rho AsTypes = AsTypes + instance Subst t a => Subst t (Elim' a) where applySubst rho e = case e of Apply v -> Apply $ applySubst rho v @@ -921,18 +992,15 @@ instance Subst t a => Subst t (Named name a) where applySubst rho = fmap (applySubst rho) -instance Subst t a => Subst t (Dom a) where +instance (Subst t a, Subst t b) => Subst t (Dom' a b) where applySubst IdS dom = dom - applySubst rho dom = setFreeVariables unknownFreeVariables $ fmap (applySubst rho) dom - -instance Subst t a => Subst t (Maybe a) where - applySubst rho = fmap (applySubst rho) - -instance Subst t a => Subst t [a] where - applySubst rho = map (applySubst rho) + applySubst rho dom = setFreeVariables unknownFreeVariables $ + fmap (applySubst rho) dom{ domTactic = applySubst rho (domTactic dom) } -instance (Ord k, Subst t a) => Subst t (Map k a) where - applySubst rho = fmap (applySubst rho) +instance Subst t a => Subst t (Maybe a) where +instance Subst t a => Subst t [a] where +instance (Ord k, Subst t a) => Subst t (Map k a) where +instance Subst t a => Subst t (WithHiding a) where instance Subst Term () where applySubst _ _ = () @@ -960,8 +1028,8 @@ (applySubst rho a) (applySubst rho b) -instance DeBruijn DeBruijnPattern where - debruijnNamedVar n i = varP $ DBPatVar n i +instance DeBruijn a => DeBruijn (Pattern' a) where + debruijnNamedVar n i = varP $ debruijnNamedVar n i -- deBruijnView returns Nothing, to prevent consS and the like -- from dropping the names and origins when building a substitution. deBruijnView _ = Nothing @@ -974,36 +1042,40 @@ usePatOrigin :: PatOrigin -> Pattern' a -> Pattern' a -usePatOrigin o p = case patternOrigin p of +usePatOrigin o p = case patternInfo p of + Nothing -> p + Just i -> usePatternInfo (i { patOrigin = o }) p + +usePatternInfo :: PatternInfo -> Pattern' a -> Pattern' a +usePatternInfo i p = case patternOrigin p of Nothing -> p Just PatOSplit -> p Just PatOAbsurd -> p Just _ -> case p of - (VarP _ x) -> VarP o x - (DotP _ u) -> DotP o u - (ConP c (ConPatternInfo (Just _) ft b l) ps) - -> ConP c (ConPatternInfo (Just o) ft b l) ps - DefP _ q ps -> DefP o q ps - ConP{} -> __IMPOSSIBLE__ - LitP{} -> __IMPOSSIBLE__ + (VarP _ x) -> VarP i x + (DotP _ u) -> DotP i u + (ConP c (ConPatternInfo _ r ft b l) ps) + -> ConP c (ConPatternInfo i r ft b l) ps + DefP _ q ps -> DefP i q ps + (LitP _ l) -> LitP i l ProjP{} -> __IMPOSSIBLE__ - (IApplyP _ t u x) -> IApplyP o t u x + (IApplyP _ t u x) -> IApplyP i t u x instance Subst DeBruijnPattern DeBruijnPattern where applySubst IdS p = p applySubst rho p = case p of - VarP o x -> - usePatOrigin o $ + VarP i x -> + usePatternInfo i $ useName (dbPatVarName x) $ lookupS rho $ dbPatVarIndex x - DotP o u -> DotP o $ applyPatSubst rho u + DotP i u -> DotP i $ applyPatSubst rho u ConP c ci ps -> ConP c ci $ applySubst rho ps - DefP o q ps -> DefP o q $ applySubst rho ps - LitP x -> p + DefP i q ps -> DefP i q $ applySubst rho ps + LitP i x -> p ProjP{} -> p - IApplyP o t u x -> case useName (dbPatVarName x) $ lookupS rho $ dbPatVarIndex x of - IApplyP _ _ _ y -> IApplyP o (applyPatSubst rho t) (applyPatSubst rho u) y - VarP _ y -> IApplyP o (applyPatSubst rho t) (applyPatSubst rho u) y + IApplyP i t u x -> case useName (dbPatVarName x) $ lookupS rho $ dbPatVarIndex x of + IApplyP _ _ _ y -> IApplyP i (applyPatSubst rho t) (applyPatSubst rho u) y + VarP _ y -> IApplyP i (applyPatSubst rho t) (applyPatSubst rho u) y _ -> __IMPOSSIBLE__ where useName :: PatVarName -> DeBruijnPattern -> DeBruijnPattern @@ -1023,15 +1095,18 @@ -- -- This function is an optimization, saving us from construction lambdas we -- immediately remove through application. -projDropParsApply :: Projection -> ProjOrigin -> Args -> Term -projDropParsApply (Projection prop d r _ lams) o args = +projDropParsApply :: Projection -> ProjOrigin -> Relevance -> Args -> Term +projDropParsApply (Projection prop d r _ lams) o rel args = case initLast $ getProjLams lams of -- If we have no more abstractions, we must be a record field -- (projection applied already to record value). Nothing -> if proper then Def d $ map Apply args else __IMPOSSIBLE__ Just (pars, Arg i y) -> - let core = if proper then Lam i $ Abs y $ Var 0 [Proj o d] - else Lam i $ Abs y $ Def d [Apply $ Var 0 [] <$ r] -- Issue2226: get ArgInfo for principal argument from projFromType + let irr = isIrrelevant rel + core + | proper && not irr = Lam i $ Abs y $ Var 0 [Proj o d] + | otherwise = Lam i $ Abs y $ Def d [Apply $ Var 0 [] <$ r] + -- Issue2226: get ArgInfo for principal argument from projFromType -- Now drop pars many args (pars', args') = dropCommon pars args -- We only have to abstract over the parameters that exceed the arguments. @@ -1049,8 +1124,8 @@ data TelV a = TelV { theTel :: Tele (Dom a), theCore :: a } deriving (Show, Functor) -deriving instance (Subst t a, Eq a) => Eq (TelV a) -deriving instance (Subst t a, Ord a) => Ord (TelV a) +deriving instance (Subst Term a, Eq a) => Eq (TelV a) +deriving instance (Subst Term a, Ord a) => Ord (TelV a) -- | Takes off all exposed function domains from the given type. -- This means that it does not reduce to expose @Pi@-types. @@ -1088,7 +1163,7 @@ domFromNamedArgName x = () <$ domFromNamedArg (fmap forceName x) where -- If no explicit name is given we use the bound name for the label. - forceName (Named Nothing x) = Named (Just $ Ranged (getRange x) $ nameToArgName x) x + forceName (Named Nothing x) = Named (Just $ WithOrigin Inserted $ Ranged (getRange x) $ nameToArgName x) x forceName x = x -- ** Abstracting in terms and types @@ -1099,7 +1174,7 @@ where x = fst $ unDom dom a = snd <$> dom - el = El $ piSort (getSort a) (Abs x (getSort b)) -- piSort checks x freeIn + el = El $ piSort a (Abs x (getSort b)) -- piSort checks x freeIn mkLam :: Arg ArgName -> Term -> Term mkLam a v = Lam (argInfo a) (Abs (unArg a) v) @@ -1110,7 +1185,7 @@ telePi (ExtendTel u tel) t = el $ Pi u $ reAbs b where b = (`telePi` t) <$> tel - el = El $ piSort (getSort u) (getSort <$> b) + el = El $ piSort u (getSort <$> b) -- | Uses free variable analysis to introduce 'NoAbs' bindings. telePi :: Telescope -> Type -> Type @@ -1120,6 +1195,21 @@ telePi_ :: Telescope -> Type -> Type telePi_ = telePi' id +-- | Only abstract the visible components of the telescope, +-- and all that bind variables. Everything will be an 'Abs'! +-- Caution: quadratic time! + +telePiVisible :: Telescope -> Type -> Type +telePiVisible EmptyTel t = t +telePiVisible (ExtendTel u tel) t + -- If u is not declared visible and b can be strengthened, skip quantification of u. + | notVisible u, NoAbs x t' <- b' = t' + -- Otherwise, include quantification over u. + | otherwise = El (piSort u $ getSort <$> b) $ Pi u b + where + b = tel <&> (`telePiVisible` t) + b' = reAbs b + -- | Abstract over a telescope in a term, producing lambdas. -- Dumb abstraction: Always produces 'Abs', never 'NoAbs'. -- @@ -1133,7 +1223,7 @@ teleNoAbs :: a -> Term -> Term instance TeleNoAbs ListTel where - teleNoAbs tel t = foldr (\ (Dom{domInfo = ai, unDom = (x, _)}) -> Lam ai . NoAbs x) t tel + teleNoAbs tel t = foldr (\ Dom{domInfo = ai, unDom = (x, _)} -> Lam ai . NoAbs x) t tel instance TeleNoAbs Telescope where teleNoAbs tel = teleNoAbs $ telToList tel @@ -1180,15 +1270,26 @@ deriving instance (Subst t a, Eq a) => Eq (Tele a) deriving instance (Subst t a, Ord a) => Ord (Tele a) -deriving instance Eq Constraint +-- Andreas, 2019-11-16, issue #4201: to avoid potential unintended +-- performance loss, the Eq instance for Constraint is disabled: +-- +-- -- deriving instance Eq Constraint +-- +-- I am tempted to write +-- +-- instance Eq Constraint where (==) = undefined +-- +-- but this does not give a compilation error anymore when trying +-- to use equality on constraints. +-- Therefore, I hope this comment is sufficient to prevent a resurrection +-- of the Eq instance for Constraint. + +deriving instance Eq CompareAs deriving instance Eq Section instance Ord PlusLevel where - compare ClosedLevel{} Plus{} = LT - compare Plus{} ClosedLevel{} = GT - compare (ClosedLevel n) (ClosedLevel m) = compare n m -- Compare on the atom first. Makes most sense for levelMax. - compare (Plus n a) (Plus m b) = compare (a,n) (b,m) + compare (Plus n a) (Plus m b) = compare (a,n) (b,m) instance Eq LevelAtom where (==) = (==) `on` unLevelAtom @@ -1222,7 +1323,7 @@ VarP _ x == VarP _ y = x == y DotP _ u == DotP _ v = u == v ConP c _ ps == ConP c' _ qs = c == c && ps == qs - LitP l == LitP l' = l == l' + LitP _ l == LitP _ l' = l == l' ProjP _ f == ProjP _ g = f == g IApplyP _ u v x == IApplyP _ u' v' y = u == u' && v == v' && x == y DefP _ f ps == DefP _ g qs = f == g && ps == qs @@ -1285,15 +1386,15 @@ -- which is a special case of renaming -- which is a special case of substitution. instance (Subst t a, Eq a) => Eq (Abs a) where - NoAbs _ a == NoAbs _ b = a == b - Abs _ a == Abs _ b = a == b + NoAbs _ a == NoAbs _ b = a == b -- no need to raise if both are NoAbs a == b = absBody a == absBody b instance (Subst t a, Ord a) => Ord (Abs a) where - NoAbs _ a `compare` NoAbs _ b = a `compare` b - Abs _ a `compare` Abs _ b = a `compare` b + NoAbs _ a `compare` NoAbs _ b = a `compare` b -- no need to raise if both are NoAbs a `compare` b = absBody a `compare` absBody b +deriving instance Ord a => Ord (Dom a) + instance (Subst t a, Eq a) => Eq (Elim' a) where Apply a == Apply b = a == b Proj _ x == Proj _ y = x == y @@ -1314,7 +1415,11 @@ -- * Sort stuff --------------------------------------------------------------------------- --- | Get the next higher sort. +-- | @univSort' univInf s@ gets the next higher sort of @s@, if it is +-- known (i.e. it is not just @UnivSort s@). @univInf@ is returned +-- as the sort of @Inf@. +-- +-- Precondition: @s@ is reduced univSort' :: Maybe Sort -> Sort -> Maybe Sort univSort' univInf (Type l) = Just $ Type $ levelSuc l univSort' univInf (Prop l) = Just $ Type $ levelSuc l @@ -1336,115 +1441,123 @@ funSort' a b = case (a, b) of (Inf , _ ) -> Just Inf (_ , Inf ) -> Just Inf - (Type (Max as) , Type (Max bs)) -> Just $ Type $ levelMax $ as ++ bs + (Type a , Type b) -> Just $ Type $ levelLub a b (SizeUniv , b ) -> Just b (_ , SizeUniv ) -> Just SizeUniv - (Prop (Max as) , Type (Max bs)) -> Just $ Type $ levelMax $ as ++ bs - (Type (Max as) , Prop (Max bs)) -> Just $ Prop $ levelMax $ as ++ bs - (Prop (Max as) , Prop (Max bs)) -> Just $ Prop $ levelMax $ as ++ bs + (Prop a , Type b) -> Just $ Type $ levelLub a b + (Type a , Prop b) -> Just $ Prop $ levelLub a b + (Prop a , Prop b) -> Just $ Prop $ levelLub a b (a , b ) -> Nothing funSort :: Sort -> Sort -> Sort -funSort a b = fromMaybe (PiSort a (NoAbs underscore b)) $ funSort' a b +funSort a b = fromMaybe (FunSort a b) $ funSort' a b -- | Compute the sort of a pi type from the sorts of its domain -- and codomain. -piSort' :: Sort -> Abs Sort -> Maybe Sort -piSort' a (NoAbs _ b) = funSort' a b -piSort' a bAbs@(Abs _ b) = case occurrence 0 b of - -- Andreas, Jesper, AIM XXIX, 2019-03-18, issue #3631 - -- Remember the NoAbs here! - NoOccurrence -> Just $ funSort a $ noabsApp __IMPOSSIBLE__ bAbs - -- Andreas, 2017-01-18, issue #2408: - -- The sort of @.(a : A) → Set (f a)@ in context @f : .A → Level@ - -- is @dLub Set λ a → Set (lsuc (f a))@, but @DLub@s are not serialized. - -- Alternatives: - -- 1. -- Irrelevantly -> sLub s1 (absApp b $ DontCare $ Sort Prop) - -- We cheat here by simplifying the sort to @Set (lsuc (f *))@ - -- where * is a dummy value. The rationale is that @f * = f a@ (irrelevance!) - -- and that if we already have a neutral level @f a@ - -- it should not hurt to have @f *@ even if type @A@ is empty. - -- However: sorts are printed in error messages when sorts do not match. - -- Also, sorts with a dummy like Prop would be ill-typed. - -- 2. We keep the DLub, and serialize it. - -- That's clean and principled, even though DLubs make level solving harder. - -- Jesper, 2018-04-20: another alternative: - -- 3. Return @Inf@ as in the relevant case. This is conservative and might result - -- in more occurrences of @Setω@ than desired, but at least it doesn't pollute - -- the sort system with new 'exotic' sorts. - Irrelevantly -> Just Inf +piSort' :: Dom Type -> Abs Sort -> Maybe Sort +piSort' a (NoAbs _ b) = funSort' (getSort a) b +piSort' a bAbs@(Abs _ b) = case flexRigOccurrenceIn 0 b of + Nothing -> Just $ funSort (getSort a) $ noabsApp __IMPOSSIBLE__ bAbs + Just o -> case o of StronglyRigid -> Just Inf Unguarded -> Just Inf WeaklyRigid -> Just Inf Flexible _ -> Nothing +-- Andreas, 2019-06-20 +-- KEEP the following commented out code for the sake of the discussion on irrelevance. +-- piSort' a bAbs@(Abs _ b) = case occurrence 0 b of +-- -- Andreas, Jesper, AIM XXIX, 2019-03-18, issue #3631 +-- -- Remember the NoAbs here! +-- NoOccurrence -> Just $ funSort a $ noabsApp __IMPOSSIBLE__ bAbs +-- -- Andreas, 2017-01-18, issue #2408: +-- -- The sort of @.(a : A) → Set (f a)@ in context @f : .A → Level@ +-- -- is @dLub Set λ a → Set (lsuc (f a))@, but @DLub@s are not serialized. +-- -- Alternatives: +-- -- 1. -- Irrelevantly -> sLub s1 (absApp b $ DontCare $ Sort Prop) +-- -- We cheat here by simplifying the sort to @Set (lsuc (f *))@ +-- -- where * is a dummy value. The rationale is that @f * = f a@ (irrelevance!) +-- -- and that if we already have a neutral level @f a@ +-- -- it should not hurt to have @f *@ even if type @A@ is empty. +-- -- However: sorts are printed in error messages when sorts do not match. +-- -- Also, sorts with a dummy like Prop would be ill-typed. +-- -- 2. We keep the DLub, and serialize it. +-- -- That's clean and principled, even though DLubs make level solving harder. +-- -- Jesper, 2018-04-20: another alternative: +-- -- 3. Return @Inf@ as in the relevant case. This is conservative and might result +-- -- in more occurrences of @Setω@ than desired, but at least it doesn't pollute +-- -- the sort system with new 'exotic' sorts. +-- Irrelevantly -> Just Inf +-- StronglyRigid -> Just Inf +-- Unguarded -> Just Inf +-- WeaklyRigid -> Just Inf +-- Flexible _ -> Nothing -piSort :: Sort -> Abs Sort -> Sort -piSort a b = fromMaybe (PiSort a b) $ piSort' a b +piSort :: Dom Type -> Abs Sort -> Sort +piSort a b = case piSort' a b of + Just s -> s + Nothing | NoAbs _ b' <- b -> FunSort (getSort a) b' + | otherwise -> PiSort a b --------------------------------------------------------------------------- -- * Level stuff --------------------------------------------------------------------------- -levelMax :: [PlusLevel] -> Level -levelMax as0 = Max $ ns ++ List.sort bs +-- ^ Computes @n0 ⊔ a₁ ⊔ a₂ ⊔ ... ⊔ aₙ@ and return its canonical form. +levelMax :: Integer -> [PlusLevel] -> Level +levelMax n0 as0 = Max n as where - as = Prelude.concatMap expand as0 - -- ns is empty or a singleton - ns = case [ n | ClosedLevel n <- as, n > 0 ] of - [] -> [] - ns -> [ ClosedLevel n | let n = Prelude.maximum ns, n > greatestB ] - bs = subsume [ b | b@Plus{} <- as ] - greatestB | null bs = 0 - | otherwise = Prelude.maximum [ n | Plus n _ <- bs ] + -- step 1: flatten nested @Level@ expressions in @LevelAtom@s + Max n1 as1 = expandLevel $ Max n0 as0 + -- step 2: remove subsumed @PlusLevel@s + as2 = removeSubsumed as1 + -- step 3: sort remaining @PlusLevel@s + as = List.sort as2 + -- step 4: set constant to 0 if it is subsumed by one of the @PlusLevel@s + greatestB = Prelude.maximum $ 0 : [ n | Plus n _ <- as ] + n | n1 > greatestB = n1 + | otherwise = 0 - expand l@ClosedLevel{} = [l] - expand (Plus n l) = map (plus n) $ expand0 $ expandAtom l + lmax :: Integer -> [PlusLevel] -> [Level] -> Level + lmax m as [] = Max m as + lmax m as (Max n bs : ls) = lmax (max m n) (bs ++ as) ls - expand0 [] = [ClosedLevel 0] - expand0 as = as + expandLevel :: Level -> Level + expandLevel (Max m as) = lmax m [] $ map expandPlus as + expandPlus :: PlusLevel -> Level + expandPlus (Plus m l) = levelPlus m $ expandAtom l + + expandAtom :: LevelAtom -> Level expandAtom l = case l of BlockedLevel _ v -> expandTm v NeutralLevel _ v -> expandTm v UnreducedLevel v -> expandTm v - MetaLevel{} -> [Plus 0 l] + MetaLevel{} -> Max 0 [Plus 0 l] where - expandTm v = case v of - Level (Max as) -> as - Sort (Type (Max as)) -> as - _ -> [Plus 0 l] - - plus n (ClosedLevel m) = ClosedLevel (n + m) - plus n (Plus m l) = Plus (n + m) l + expandTm (Level l) = expandLevel l + expandTm (Sort (Type l)) = expandLevel l -- TODO: get rid of this horrible hack! + expandTm v = Max 0 [Plus 0 l] - subsume (ClosedLevel{} : _) = __IMPOSSIBLE__ - subsume [] = [] - subsume (Plus n a : bs) - | not $ null ns = subsume bs - | otherwise = Plus n a : subsume [ b | b@(Plus _ a') <- bs, a /= a' ] + removeSubsumed [] = [] + removeSubsumed (Plus n a : bs) + | not $ null ns = removeSubsumed bs + | otherwise = Plus n a : removeSubsumed [ b | b@(Plus _ a') <- bs, a /= a' ] where - ns = [ m | Plus m a' <- bs, a == a', m > n ] + ns = [ m | Plus m a' <- bs, a == a', m > n ] +-- | Given two levels @a@ and @b@, compute @a ⊔ b@ and return its +-- canonical form. +levelLub :: Level -> Level -> Level +levelLub (Max m as) (Max n bs) = levelMax (max m n) $ as ++ bs + levelTm :: Level -> Term levelTm l = case l of - Max [Plus 0 l] -> unLevelAtom l - _ -> Level l + Max 0 [Plus 0 l] -> unLevelAtom l + _ -> Level l unLevelAtom :: LevelAtom -> Term unLevelAtom (MetaLevel x es) = MetaV x es unLevelAtom (NeutralLevel _ v) = v unLevelAtom (UnreducedLevel v) = v unLevelAtom (BlockedLevel _ v) = v - -levelSucView :: Level -> Maybe Level -levelSucView (Max []) = Nothing -levelSucView (Max as) = Max <$> traverse atomPred as - where - atomPred :: PlusLevel -> Maybe PlusLevel - atomPred (ClosedLevel n) - | n > 0 = Just $ ClosedLevel (n-1) - | otherwise = Nothing - atomPred (Plus n l) - | n > 0 = Just $ Plus (n-1) l - | otherwise = Nothing diff --git a/src/full/Agda/TypeChecking/Substitute/Class.hs b/src/full/Agda/TypeChecking/Substitute/Class.hs --- a/src/full/Agda/TypeChecking/Substitute/Class.hs +++ b/src/full/Agda/TypeChecking/Substitute/Class.hs @@ -1,10 +1,10 @@ -{-# LANGUAGE CPP #-} +{-# LANGUAGE TypeFamilies #-} module Agda.TypeChecking.Substitute.Class where import Control.Arrow ((***), second) -import Data.Maybe + import Agda.Syntax.Common import Agda.Syntax.Internal @@ -14,7 +14,6 @@ import Agda.Utils.Empty import Agda.Utils.List -#include "undefined.h" import Agda.Utils.Impossible --------------------------------------------------------------------------- @@ -51,7 +50,7 @@ abstract :: Telescope -> t -> t --------------------------------------------------------------------------- --- * Substitution and raising/shifting/weakening +-- * Substitution and shifting\/weakening\/strengthening --------------------------------------------------------------------------- -- | Apply a substitution. @@ -66,6 +65,11 @@ class DeBruijn t => Subst t a | a -> t where applySubst :: Substitution' t -> a -> a + default applySubst :: (a ~ f b, Functor f, Subst t b) => Substitution' t -> a -> a + applySubst rho = fmap (applySubst rho) + + +-- | Raise de Bruijn index, i.e. weakening raise :: Subst t a => Nat -> a -> a raise = raiseFrom 0 @@ -222,6 +226,14 @@ | otherwise -> raise n $ lookupS rho (i - n) EmptyS err -> absurd err + +-- | lookupS (listS [(x0,t0)..(xn,tn)]) xi = ti, assuming x0 < .. < xn. + +listS :: Subst a a => [(Int,a)] -> Substitution' a +listS ((i,t):ts) = singletonS i t `composeS` listS ts +listS [] = IdS + + --------------------------------------------------------------------------- -- * Functions on abstractions -- and things we couldn't do before we could define 'absBody' @@ -272,7 +284,7 @@ -- and puts the 'Lam's back. @a@ is raised correctly -- according to the number of abstractions. underLambdas :: Subst Term a => Int -> (a -> Term -> Term) -> a -> Term -> Term -underLambdas n cont a v = loop n a v where +underLambdas n cont a = loop n a where loop 0 a v = cont a v loop n a v = case v of Lam h b -> Lam h $ underAbs (loop $ n-1) a b diff --git a/src/full/Agda/TypeChecking/Substitute/DeBruijn.hs b/src/full/Agda/TypeChecking/Substitute/DeBruijn.hs --- a/src/full/Agda/TypeChecking/Substitute/DeBruijn.hs +++ b/src/full/Agda/TypeChecking/Substitute/DeBruijn.hs @@ -46,10 +46,10 @@ _ -> Nothing instance DeBruijn Level where - deBruijnVar i = Max [deBruijnVar i] + deBruijnVar i = Max 0 [deBruijnVar i] deBruijnView l = case l of - Max [p] -> deBruijnView p + Max 0 [p] -> deBruijnView p _ -> Nothing instance DeBruijn DBPatVar where diff --git a/src/full/Agda/TypeChecking/SyntacticEquality.hs b/src/full/Agda/TypeChecking/SyntacticEquality.hs --- a/src/full/Agda/TypeChecking/SyntacticEquality.hs +++ b/src/full/Agda/TypeChecking/SyntacticEquality.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE UndecidableInstances #-} -- | A syntactic equality check that takes meta instantiations into account, @@ -14,7 +13,6 @@ import Prelude hiding (mapM) -import Control.Applicative hiding ((<**>)) import Control.Arrow ((***)) import Control.Monad.State hiding (mapM) @@ -23,32 +21,33 @@ import Agda.Syntax.Common import Agda.Syntax.Internal -import Agda.TypeChecking.Monad (ReduceM, MonadReduce(..), pragmaOptions) +import Agda.TypeChecking.Monad (ReduceM, MonadReduce(..), pragmaOptions, isInstantiatedMeta) import Agda.TypeChecking.Reduce import Agda.TypeChecking.Reduce.Monad import Agda.TypeChecking.Substitute import Agda.Utils.Monad (ifM) -#include "undefined.h" -import Agda.Utils.Impossible -- | Syntactic equality check for terms. -- @ -- checkSyntacticEquality v v' = do --- (v,v') <- instantiateFull (v,v') --- return ((v,v'), v==v') +-- (v, v') <- instantiateFull (v, v') +-- return ((v, v'), v==v') -- @ --- only that @v,v'@ are only fully instantiated to the depth +-- only that @v, v'@ are only fully instantiated to the depth -- where they are equal. +-- +-- This means in particular that the returned @v,v'@ cannot be @MetaV@s +-- that are instantiated. {-# SPECIALIZE checkSyntacticEquality :: Term -> Term -> ReduceM ((Term, Term), Bool) #-} {-# SPECIALIZE checkSyntacticEquality :: Type -> Type -> ReduceM ((Type, Type), Bool) #-} -checkSyntacticEquality :: (SynEq a, MonadReduce m) => a -> a -> m ((a, a), Bool) +checkSyntacticEquality :: (Instantiate a, SynEq a, MonadReduce m) => a -> a -> m ((a, a), Bool) checkSyntacticEquality v v' = liftReduce $ do ifM (optSyntacticEquality <$> pragmaOptions) {-then-} (synEq v v' `runStateT` True) - {-else-} (return ((v,v'), False)) + {-else-} ((,False) <$> instantiate (v,v')) -- | Monad for checking syntactic equality type SynEqM = StateT Bool ReduceM @@ -64,24 +63,24 @@ -- Since List2 is only Applicative, not a monad, I cannot -- define a List2T monad transformer, so we do it manually: -(<$$>) :: Functor f => (a -> b) -> f (a,a) -> f (b,b) +(<$$>) :: Functor f => (a -> b) -> f (a, a) -> f (b, b) f <$$> xx = (f *** f) <$> xx -pure2 :: Applicative f => a -> f (a,a) -pure2 a = pure (a,a) +pure2 :: Applicative f => a -> f (a, a) +pure2 a = pure (a, a) -(<**>) :: Applicative f => f (a -> b, a -> b) -> f (a,a) -> f (b,b) +(<**>) :: Applicative f => f (a -> b, a -> b) -> f (a, a) -> f (b, b) ff <**> xx = pure (uncurry (***)) <*> ff <*> xx -- | Instantiate full as long as things are equal class SynEq a where - synEq :: a -> a -> SynEqM (a,a) - synEq' :: a -> a -> SynEqM (a,a) + synEq :: a -> a -> SynEqM (a, a) + synEq' :: a -> a -> SynEqM (a, a) synEq' a a' = ifEqual (uncurry synEq) (a, a') instance SynEq Bool where - synEq x y | x == y = return (x,y) - synEq x y | otherwise = inequal (x,y) + synEq x y | x == y = return (x, y) + synEq x y | otherwise = inequal (x, y) -- | Syntactic term equality ignores 'DontCare' stuff. instance SynEq Term where @@ -89,7 +88,7 @@ (v, v') <- lift $ instantiate' (v, v') case (v, v') of (Var i vs, Var i' vs') | i == i' -> Var i <$$> synEq vs vs' - (Con c ci vs,Con c' ci' vs') | c == c' -> Con c (bestConInfo ci ci') <$$> synEq vs vs' + (Con c i vs, Con c' i' vs') | c == c' -> Con c (bestConInfo i i') <$$> synEq vs vs' (Def f vs, Def f' vs') | f == f' -> Def f <$$> synEq vs vs' (MetaV x vs, MetaV x' vs') | x == x' -> MetaV x <$$> synEq vs vs' (Lit l , Lit l' ) | l == l' -> pure2 $ v @@ -97,21 +96,24 @@ (Level l , Level l' ) -> levelTm <$$> synEq l l' (Sort s , Sort s' ) -> Sort <$$> synEq s s' (Pi a b , Pi a' b' ) -> Pi <$$> synEq a a' <**> synEq' b b' - (DontCare _, DontCare _ ) -> pure (v, v') - -- Irrelevant things are syntactically equal. ALT: - -- DontCare <$$> synEq v v' + (DontCare u, DontCare u' ) -> DontCare <$$> synEq u u' + -- Irrelevant things are not syntactically equal. ALT: + -- pure (u, u') + -- Jesper, 2019-10-21: considering irrelevant things to be + -- syntactically equal causes implicit arguments to go + -- unsolved, so it is better to go under the DontCare. (Dummy{} , Dummy{} ) -> pure (v, v') _ -> inequal (v, v') instance SynEq Level where - synEq (Max vs) (Max vs') = levelMax <$$> synEq vs vs' + synEq l@(Max n vs) l'@(Max n' vs') + | n == n' = levelMax n <$$> synEq vs vs' + | otherwise = inequal (l, l') instance SynEq PlusLevel where - synEq l l' = do - case (l, l') of - (ClosedLevel v, ClosedLevel v') | v == v' -> pure2 l - (Plus n v, Plus n' v') | n == n' -> Plus n <$$> synEq v v' - _ -> inequal (l, l') + synEq l@(Plus n v) l'@(Plus n' v') + | n == n' = Plus n <$$> synEq v v' + | otherwise = inequal (l, l') instance SynEq LevelAtom where synEq l l' = do @@ -138,6 +140,7 @@ case (s, s') of (Type l , Type l' ) -> Type <$$> synEq l l' (PiSort a b, PiSort a' b') -> piSort <$$> synEq a a' <**> synEq' b b' + (FunSort a b, FunSort a' b') -> funSort <$$> synEq a a' <**> synEq' b b' (UnivSort a, UnivSort a') -> UnivSort <$$> synEq a a' (SizeUniv, SizeUniv ) -> pure2 s (Prop l , Prop l' ) -> Prop <$$> synEq l l' @@ -173,22 +176,14 @@ (Abs x b, NoAbs x' b') -> Abs x <$$> synEq b (raise 1 b') -- TODO: mkAbs? (NoAbs x b, Abs x' b') -> Abs x' <$$> synEq (raise 1 b) b' -{- TRIGGERS test/fail/UnequalHiding --- | Ignores 'ArgInfo'. -instance SynEq a => SynEq (Arg c a) where - synEq (Arg ai a) (Arg ai' a') = (Arg ai *** Arg ai') <$> synEq a a' - --- | Ignores 'ArgInfo'. -instance SynEq a => SynEq (Dom c a) where - synEq (Dom ai a) (Dom ai' a') = (Dom ai *** Dom ai') <$> synEq a a' --} - +-- NOTE: Do not ignore 'ArgInfo', or test/fail/UnequalHiding will pass. instance SynEq a => SynEq (Arg a) where synEq (Arg ai a) (Arg ai' a') = Arg <$$> synEq ai ai' <**> synEq a a' +-- Ignore the tactic. instance SynEq a => SynEq (Dom a) where - synEq d@(Dom ai b x a) d'@(Dom ai' b' x' a') - | x == x' = Dom <$$> synEq ai ai' <**> synEq b b' <**> pure2 x <**> synEq a a' + synEq d@(Dom ai b x t a) d'@(Dom ai' b' x' _ a') + | x == x' = Dom <$$> synEq ai ai' <**> synEq b b' <**> pure2 x <**> pure2 t <**> synEq a a' | otherwise = inequal (d, d') instance SynEq ArgInfo where diff --git a/src/full/Agda/TypeChecking/Telescope.hs b/src/full/Agda/TypeChecking/Telescope.hs --- a/src/full/Agda/TypeChecking/Telescope.hs +++ b/src/full/Agda/TypeChecking/Telescope.hs @@ -1,10 +1,8 @@ -{-# LANGUAGE CPP #-} module Agda.TypeChecking.Telescope where import Prelude hiding (null) -import Control.Applicative hiding (empty) import Control.Monad import Data.Foldable (forM_, find) @@ -12,11 +10,11 @@ import qualified Data.IntSet as IntSet import qualified Data.List as List import Data.Maybe +import Data.Monoid import Agda.Syntax.Common import Agda.Syntax.Internal import Agda.Syntax.Internal.Pattern -import Agda.Syntax.Position import Agda.TypeChecking.Monad.Builtin import Agda.TypeChecking.Monad @@ -29,16 +27,16 @@ import Agda.Utils.List import Agda.Utils.Null import Agda.Utils.Permutation +import Agda.Utils.Singleton import Agda.Utils.Size import Agda.Utils.Tuple import Agda.Utils.VarSet (VarSet) import qualified Agda.Utils.VarSet as VarSet -#include "undefined.h" import Agda.Utils.Impossible -- | Flatten telescope: (Γ : Tel) -> [Type Γ] -flattenTel :: Subst t a => Tele (Dom a) -> [Dom a] +flattenTel :: Subst Term a => Tele (Dom a) -> [Dom a] flattenTel EmptyTel = [] flattenTel (ExtendTel a tel) = raise (size tel + 1) a : flattenTel (absBody tel) @@ -68,10 +66,19 @@ where tel' = unflattenTel xs tel a' = applySubst rho a - rho = parallelS (replicate (size tel + 1) __IMPOSSIBLE_TERM__) + rho = parallelS (replicate (size tel + 1) (withFileAndLine impossibleTerm)) unflattenTel [] (_ : _) = __IMPOSSIBLE__ unflattenTel (_ : _) [] = __IMPOSSIBLE__ +-- | Rename the variables in the telescope to the given names +-- Precondition: @size xs == size tel@. +renameTel :: [Maybe ArgName] -> Telescope -> Telescope +renameTel [] EmptyTel = EmptyTel +renameTel (Nothing:xs) (ExtendTel a tel') = ExtendTel a $ renameTel xs <$> tel' +renameTel (Just x :xs) (ExtendTel a tel') = ExtendTel a $ renameTel xs <$> (tel' { absName = x }) +renameTel [] (ExtendTel _ _ ) = __IMPOSSIBLE__ +renameTel (_ :_ ) EmptyTel = __IMPOSSIBLE__ + -- | Get the suggested names from a telescope teleNames :: Telescope -> [ArgName] teleNames = map (fst . unDom) . telToList @@ -80,22 +87,21 @@ teleArgNames = map (argFromDom . fmap fst) . telToList teleArgs :: (DeBruijn a) => Tele (Dom t) -> [Arg a] -teleArgs tel = - [ Arg info (deBruijnVar i) - | (i, Dom {domInfo = info, unDom = (n,_)}) <- zip (downFrom $ size l) l ] - where l = telToList tel +teleArgs = map argFromDom . teleDoms -withNamedArgsFromTel :: [a] -> Telescope -> [NamedArg a] -xs `withNamedArgsFromTel` tel = - [ Arg info (Named (Just $ Ranged noRange $ argNameToString name) x) - | (x, Dom {domInfo = info, unDom = (name,_)}) <- zip xs l ] +teleDoms :: (DeBruijn a) => Tele (Dom t) -> [Dom a] +teleDoms tel = zipWith (\ i dom -> deBruijnVar i <$ dom) (downFrom $ size l) l where l = telToList tel +-- UNUSED +-- withNamedArgsFromTel :: [a] -> Telescope -> [NamedArg a] +-- xs `withNamedArgsFromTel` tel = +-- [ Arg info (Named (Just $ Ranged empty $ argNameToString name) x) +-- | (x, Dom {domInfo = info, unDom = (name,_)}) <- zip xs l ] +-- where l = telToList tel + teleNamedArgs :: (DeBruijn a) => Telescope -> [NamedArg a] -teleNamedArgs tel = - [ fmap (deBruijnVar i <$) $ namedArgFromDom dom - | (i, dom) <- zip (downFrom $ size l) l ] - where l = telToList tel +teleNamedArgs = map namedArgFromDom . teleDoms -- | A variant of `teleNamedArgs` which takes the argument names (and the argument info) -- from the first telescope and the variable names from the second telescope. @@ -103,7 +109,7 @@ -- Precondition: the two telescopes have the same length. tele2NamedArgs :: (DeBruijn a) => Telescope -> Telescope -> [NamedArg a] tele2NamedArgs tel0 tel = - [ Arg info (Named (Just $ Ranged noRange $ argNameToString argName) (debruijnNamedVar varName i)) + [ Arg info (Named (Just $ WithOrigin Inserted $ unranged $ argNameToString argName) (debruijnNamedVar varName i)) | (i, Dom{domInfo = info, unDom = (argName,_)}, Dom{unDom = (varName,_)}) <- zip3 (downFrom $ size l) l0 l ] where l = telToList tel @@ -162,6 +168,29 @@ then soFar else IntSet.insert j $ allDependencies soFar $ directDependencies j +-- | Computes the set of variables in a telescope whose type depend on +-- one of the variables in the given set (including recursive +-- dependencies). Any dependencies outside of the telescope are +-- ignored. +varDependents :: Telescope -> IntSet -> IntSet +varDependents tel = allDependents + where + n = size tel + ts = flattenTel tel + + directDependents :: IntSet -> IntSet + directDependents is = IntSet.fromList + [ j | j <- downFrom n + , let tj = indexWithDefault __IMPOSSIBLE__ ts (n-1-j) + , getAny $ runFree (Any . (`IntSet.member` is)) IgnoreNot tj + ] + + allDependents :: IntSet -> IntSet + allDependents is + | null new = empty + | otherwise = new `IntSet.union` allDependents new + where new = directDependents is + -- | A telescope split in two. data SplitTel = SplitTel { firstPart :: Telescope @@ -214,8 +243,7 @@ checkDependencies soFar [] = True checkDependencies soFar (j:js) = ok && checkDependencies (IntSet.insert j soFar) js where - fv' = allFreeVars $ -- newline because of CPP - indexWithDefault __IMPOSSIBLE__ ts0 (n-1-j) + fv' = allFreeVars $ indexWithDefault __IMPOSSIBLE__ ts0 (n-1-j) fv = fv' `IntSet.intersection` IntSet.fromAscList [ 0 .. n-1 ] ok = fv `IntSet.isSubsetOf` soFar @@ -232,42 +260,48 @@ m = size is (tel1, tel2) = telFromList -*- telFromList $ splitAt m $ telToList tel' -instantiateTelescopeN - :: Telescope -- ^ ⊢ Γ - -> [(Int,Term)] -- ^ Γ ⊢ var k_i : A_i ascending order, Γ ⊢ u_i : A_i - -> Maybe (Telescope, -- ⊢ Γ' - Substitution) -- Γ' ⊢ σ : Γ -instantiateTelescopeN tel [] = return (tel, IdS) -instantiateTelescopeN tel ((k,t):xs) = do - (tel', sigma, _) <- instantiateTelescope tel k t - (tel'', sigma') <- instantiateTelescopeN tel' (map (subtract 1 -*- applyPatSubst sigma) xs) - return (tel'', applyPatSubst sigma sigma') - -- | Try to instantiate one variable in the telescope (given by its de Bruijn -- level) with the given value, returning the new telescope and a -- substitution to the old one. Returns Nothing if the given value depends -- (directly or indirectly) on the variable. instantiateTelescope :: Telescope -- ^ ⊢ Γ - -> Int -- ^ Γ ⊢ var k : A - -> Term -- ^ Γ ⊢ u : A + -> Int -- ^ Γ ⊢ var k : A de Bruijn _level_ + -> DeBruijnPattern -- ^ Γ ⊢ u : A -> Maybe (Telescope, -- ⊢ Γ' PatternSubstitution, -- Γ' ⊢ σ : Γ Permutation) -- Γ ⊢ flipP ρ : Γ' -instantiateTelescope tel k u = guard ok $> (tel', sigma, rho) +instantiateTelescope tel k p = guard ok $> (tel', sigma, rho) where names = teleNames tel ts0 = flattenTel tel n = size tel j = n-1-k + u = patternToTerm p + -- Jesper, 2019-12-31: Previous implementation that does some + -- unneccessary reordering but is otherwise correct (keep!) + -- -- is0 is the part of Γ that is needed to type u + -- is0 = varDependencies tel $ allFreeVars u + -- -- is1 is the rest of Γ (minus the variable we are instantiating) + -- is1 = IntSet.delete j $ + -- IntSet.fromAscList [ 0 .. n-1 ] `IntSet.difference` is0 + -- -- we work on de Bruijn indices, so later parts come first + -- is = IntSet.toAscList is1 ++ IntSet.toAscList is0 + + -- -- if u depends on var j, we cannot instantiate + -- ok = not $ j `IntSet.member` is0 + -- is0 is the part of Γ that is needed to type u is0 = varDependencies tel $ allFreeVars u - -- is1 is the rest of Γ (minus the variable we are instantiating) - is1 = IntSet.delete j $ - IntSet.fromAscList [ 0 .. n-1 ] `IntSet.difference` is0 - -- we work on de Bruijn indices, so later parts come first - is = IntSet.toAscList is1 ++ IntSet.toAscList is0 + -- is1 is the part of Γ that depends on variable j + is1 = varDependents tel $ singleton j + -- lasti is the last (rightmost) variable of is0 + lasti = if null is0 then n else IntSet.findMin is0 + -- we move each variable in is1 to the right until it comes after + -- all variables in is0 (i.e. after lasti) + (as,bs) = List.partition (`IntSet.member` is1) [ n-1 , n-2 .. lasti ] + is = reverse $ List.delete j $ bs ++ as ++ downFrom lasti -- if u depends on var j, we cannot instantiate ok = not $ j `IntSet.member` is0 @@ -275,8 +309,8 @@ perm = Perm n $ is -- works on de Bruijn indices rho = reverseP perm -- works on de Bruijn levels - u1 = renameP __IMPOSSIBLE__ perm u -- Γ' ⊢ u1 : A' - us = map (\i -> fromMaybe (dotP u1) (deBruijnVar <$> List.findIndex (i ==) is)) [ 0 .. n-1 ] + p1 = renameP __IMPOSSIBLE__ perm p -- Γ' ⊢ p1 : A' + us = map (\i -> fromMaybe p1 (deBruijnVar <$> List.findIndex (i ==) is)) [ 0 .. n-1 ] sigma = us ++# raiseS (n-1) ts1 = permute rho $ applyPatSubst sigma ts0 @@ -297,7 +331,8 @@ splitExactlyAt k $ telToList gamma cpi = noConPatternInfo - { conPRecord = Just PatOSystem + { conPInfo = defaultPatternInfo + , conPRecord = True , conPType = Just $ snd <$> argFromDom a , conPLazy = True } @@ -312,23 +347,24 @@ tel' = gamma1 `abstract` (delta `abstract` gamma2') -- | Gather leading Πs of a type in a telescope. -telView :: Type -> TCM TelView +telView :: (MonadReduce m, MonadAddContext m) => Type -> m TelView telView = telViewUpTo (-1) -- | @telViewUpTo n t@ takes off the first @n@ function types of @t@. -- Takes off all if @n < 0@. -telViewUpTo :: Int -> Type -> TCM TelView +telViewUpTo :: (MonadReduce m, MonadAddContext m) => Int -> Type -> m TelView telViewUpTo n t = telViewUpTo' n (const True) t -- | @telViewUpTo' n p t@ takes off $t$ -- the first @n@ (or arbitrary many if @n < 0@) function domains -- as long as they satify @p@. -telViewUpTo' :: Int -> (Dom Type -> Bool) -> Type -> TCM TelView +telViewUpTo' :: (MonadReduce m, MonadAddContext m) => Int -> (Dom Type -> Bool) -> Type -> m TelView telViewUpTo' 0 p t = return $ TelV EmptyTel t telViewUpTo' n p t = do t <- reduce t case unEl t of - Pi a b | p a -> absV a (absName b) <$> telViewUpTo' (n - 1) p (absBody b) + Pi a b | p a -> absV a (absName b) <$> do + underAbstractionAbs a b $ \b -> telViewUpTo' (n - 1) p b _ -> return $ TelV EmptyTel t where absV a x (TelV tel t) = TelV (ExtendTel a (Abs x tel)) t @@ -358,7 +394,7 @@ -- by the Path types encountered. The boundary terms live in the -- telescope given by the @TelView@. -- Each point of the boundary has the type of the codomain of the Path type it got taken from, see @fullBoundary@. -telViewUpToPathBoundary' :: Int -> Type -> TCM (TelView,Boundary) +telViewUpToPathBoundary' :: (MonadReduce m, HasBuiltins m) => Int -> Type -> m (TelView,Boundary) telViewUpToPathBoundary' 0 t = return $ (TelV EmptyTel t,[]) telViewUpToPathBoundary' n t = do vt <- pathViewAsPi' $ t @@ -392,7 +428,7 @@ -- Output: ΔΓ ⊢ b -- ΔΓ ⊢ i : I -- ΔΓ ⊢ [ (i=0) -> t_i; (i=1) -> u_i ] : b -telViewUpToPathBoundary :: Int -> Type -> TCM (TelView,Boundary) +telViewUpToPathBoundary :: (MonadReduce m, HasBuiltins m) => Int -> Type -> m (TelView,Boundary) telViewUpToPathBoundary i a = do (telv@(TelV tel b), bs) <- telViewUpToPathBoundary' i a return $ (telv, fullBoundary tel bs) @@ -404,10 +440,10 @@ -- Δ.Γ ⊢ i : I -- Δ.Γ ⊢ [ (i=0) -> t_i; (i=1) -> u_i ] : T -- Useful to reconstruct IApplyP patterns after teleNamedArgs Γ. -telViewUpToPathBoundaryP :: Int -> Type -> TCM (TelView,Boundary) +telViewUpToPathBoundaryP :: (MonadReduce m, HasBuiltins m) => Int -> Type -> m (TelView,Boundary) telViewUpToPathBoundaryP = telViewUpToPathBoundary' -telViewPathBoundaryP :: Type -> TCM (TelView,Boundary) +telViewPathBoundaryP :: (MonadReduce m, HasBuiltins m) => Type -> m (TelView,Boundary) telViewPathBoundaryP = telViewUpToPathBoundaryP (-1) @@ -431,14 +467,20 @@ Just i | Just (t,u) <- matchVar i -> IApply t u p _ -> Apply a -pathViewAsPi :: Type -> TCM (Either (Dom Type, Abs Type) Type) +pathViewAsPi + :: (MonadReduce m, HasBuiltins m) + =>Type -> m (Either (Dom Type, Abs Type) Type) pathViewAsPi t = either (Left . fst) Right <$> pathViewAsPi' t -pathViewAsPi' :: Type -> TCM (Either ((Dom Type, Abs Type), (Term,Term)) Type) +pathViewAsPi' + :: (MonadReduce m, HasBuiltins m) + => Type -> m (Either ((Dom Type, Abs Type), (Term,Term)) Type) pathViewAsPi' t = do pathViewAsPi'whnf <*> reduce t -pathViewAsPi'whnf :: TCM (Type -> Either ((Dom Type, Abs Type), (Term,Term)) Type) +pathViewAsPi'whnf + :: (HasBuiltins m) + => m (Type -> Either ((Dom Type, Abs Type), (Term,Term)) Type) pathViewAsPi'whnf = do view <- pathView' minterval <- getBuiltin' builtinInterval @@ -477,14 +519,15 @@ telView'Path :: Type -> TCM TelView telView'Path = telView'UpToPath (-1) -isPath :: Type -> TCM (Maybe (Dom Type, Abs Type)) +isPath + :: (MonadReduce m, HasBuiltins m) + => Type -> m (Maybe (Dom Type, Abs Type)) isPath t = either Just (const Nothing) <$> pathViewAsPi t -telePatterns :: (DeBruijn a, DeBruijn (Pattern' a)) => - Telescope -> Boundary -> [NamedArg (Pattern' a)] +telePatterns :: DeBruijn a => Telescope -> Boundary -> [NamedArg (Pattern' a)] telePatterns = telePatterns' teleNamedArgs -telePatterns' :: (DeBruijn a, DeBruijn (Pattern' a)) => +telePatterns' :: DeBruijn a => (forall a. (DeBruijn a) => Telescope -> [NamedArg a]) -> Telescope -> Boundary -> [NamedArg (Pattern' a)] telePatterns' f tel [] = f tel telePatterns' f tel boundary = recurse $ f tel @@ -494,11 +537,10 @@ snd <$> flip find boundary (\case (Var i [],_) -> i == x _ -> __IMPOSSIBLE__) - o = PatOSystem updateVar x = case deBruijnView x of - Just i | Just (t,u) <- matchVar i -> IApplyP o t u x - _ -> VarP o x + Just i | Just (t,u) <- matchVar i -> IApplyP defaultPatternInfo t u x + _ -> VarP defaultPatternInfo x -- | Decomposing a function type. @@ -589,7 +631,7 @@ Level{} -> __IMPOSSIBLE__ MetaV{} -> __IMPOSSIBLE__ DontCare{} -> __IMPOSSIBLE__ - Dummy s -> __IMPOSSIBLE_VERBOSE__ s + Dummy s _ -> __IMPOSSIBLE_VERBOSE__ s -- | Register the definition with the given type as an instance addTypedInstance :: QName -> Type -> TCM () diff --git a/src/full/Agda/TypeChecking/Telescope.hs-boot b/src/full/Agda/TypeChecking/Telescope.hs-boot --- a/src/full/Agda/TypeChecking/Telescope.hs-boot +++ b/src/full/Agda/TypeChecking/Telescope.hs-boot @@ -4,6 +4,7 @@ import Agda.Syntax.Common import Agda.Syntax.Internal import Agda.TypeChecking.Monad.Base +import Agda.TypeChecking.Monad.Context (MonadAddContext) import Agda.TypeChecking.Substitute class PiApplyM a where @@ -13,4 +14,4 @@ instance PiApplyM a => PiApplyM (Arg a) where instance PiApplyM a => PiApplyM [a] where -telView :: Type -> TCM TelView +telView :: (MonadReduce m, MonadAddContext m) => Type -> m TelView diff --git a/src/full/Agda/TypeChecking/Telescope/Path.hs b/src/full/Agda/TypeChecking/Telescope/Path.hs --- a/src/full/Agda/TypeChecking/Telescope/Path.hs +++ b/src/full/Agda/TypeChecking/Telescope/Path.hs @@ -1,20 +1,13 @@ -{-# LANGUAGE CPP #-} module Agda.TypeChecking.Telescope.Path where import Prelude hiding (null) -import Control.Applicative hiding (empty) -import Control.Monad (unless, guard) - -import Data.Foldable (forM_, find) import qualified Data.List as List import Data.Maybe import Agda.Syntax.Common import Agda.Syntax.Internal -import Agda.Syntax.Internal.Pattern -import Agda.Syntax.Position import Agda.TypeChecking.Free import Agda.TypeChecking.Monad.Builtin @@ -24,11 +17,9 @@ import Agda.TypeChecking.Substitute import Agda.TypeChecking.Telescope -import Agda.Utils.Functor import Agda.Utils.List import Agda.Utils.Size -#include "undefined.h" import Agda.Utils.Impossible @@ -51,7 +42,7 @@ s <- reduce $ getSort <$> b case s of NoAbs _ (Type l) -> return l - Abs n (Type l) | NoOccurrence <- occurrence 0 s -> return $ noabsApp __IMPOSSIBLE__ (Abs n l) + Abs n (Type l) | not (freeIn 0 s) -> return $ noabsApp __IMPOSSIBLE__ (Abs n l) _ -> typeError . GenericError . show =<< (text "The type is non-fibrant or its sort depends on an interval variable" <+> prettyTCM (unAbs b)) -- TODO better Type Error @@ -71,7 +62,7 @@ ] Nothing -> do b <- b - return $ El (piSort (getSort a) (getSort <$> b)) (Pi a (reAbs b)) + return $ El (piSort a (getSort <$> b)) (Pi a (reAbs b)) where b = traverse (telePiPath xs) tel telePiPath _ EmptyTel = __IMPOSSIBLE__ diff --git a/src/full/Agda/TypeChecking/Unquote.hs b/src/full/Agda/TypeChecking/Unquote.hs --- a/src/full/Agda/TypeChecking/Unquote.hs +++ b/src/full/Agda/TypeChecking/Unquote.hs @@ -1,18 +1,13 @@ -{-# LANGUAGE CPP #-} module Agda.TypeChecking.Unquote where -#if MIN_VERSION_base(4,11,0) -import Prelude hiding ((<>)) -#endif - import Control.Arrow (first, second) import Control.Monad.State import Control.Monad.Reader import Control.Monad.Writer hiding ((<>)) -import Control.Monad.Trans (lift) import Data.Char +import qualified Data.HashSet as HashSet import Data.Maybe (fromMaybe) import Data.Traversable (traverse) import Data.Word @@ -20,6 +15,7 @@ import Agda.Syntax.Common import Agda.Syntax.Internal as I import qualified Agda.Syntax.Reflected as R +import qualified Agda.Syntax.Abstract as A import Agda.Syntax.Literal import Agda.Syntax.Position import Agda.Syntax.Fixity @@ -27,9 +23,9 @@ import Agda.Syntax.Translation.ReflectedToAbstract import Agda.TypeChecking.Constraints +import Agda.TypeChecking.MetaVars.Mention import Agda.TypeChecking.Monad import Agda.TypeChecking.Monad.Builtin -import Agda.TypeChecking.Monad.Env import Agda.TypeChecking.Pretty import Agda.TypeChecking.Reduce import Agda.TypeChecking.Substitute @@ -49,14 +45,12 @@ , runExceptT ) import Agda.Utils.Either -import Agda.Utils.FileName import Agda.Utils.Lens import Agda.Utils.Monad import Agda.Utils.Pretty (prettyShow) import Agda.Utils.String ( Str(Str), unStr ) import qualified Agda.Interaction.Options.Lenses as Lens -#include "undefined.h" import Agda.Utils.Impossible agdaTermType :: TCM Type @@ -109,7 +103,7 @@ inOriginalContext :: UnquoteM a -> UnquoteM a inOriginalContext m = packUnquoteM $ \ cxt s -> - modifyContext (const cxt) $ unpackUnquoteM m cxt s + unsafeModifyContext (const cxt) $ unpackUnquoteM m cxt s isCon :: ConHead -> TCM Term -> UnquoteM Bool isCon con tm = do t <- liftTCM tm @@ -173,15 +167,15 @@ isAlpha c -> [toLower c] _ -> "_" --- TODO: reflect Quantity +-- TODO: reflect Quantity, Cohesion instance Unquote Modality where - unquote t = (`Modality` defaultQuantity) <$> unquote t + unquote t = (\ r -> Modality r defaultQuantity defaultCohesion) <$> unquote t instance Unquote ArgInfo where unquote t = do t <- reduceQuotedTerm t case t of - Con c _ es | Just [h,r] <- allApplyElims es -> do + Con c _ es | Just [h,r] <- allApplyElims es -> choice [(c `isCon` primArgArgInfo, ArgInfo <$> unquoteN h <*> unquoteN r <*> pure Reflected <*> pure unknownFreeVariables)] @@ -193,7 +187,7 @@ unquote t = do t <- reduceQuotedTerm t case t of - Con c _ es | Just [info,x] <- allApplyElims es -> do + Con c _ es | Just [info,x] <- allApplyElims es -> choice [(c `isCon` primArgArg, Arg <$> unquoteN info <*> unquoteN x)] __IMPOSSIBLE__ @@ -256,7 +250,7 @@ unquoteNString :: Arg Term -> UnquoteM String unquoteNString x = unStr <$> unquoteN x -data ErrorPart = StrPart String | TermPart R.Term | NamePart QName +data ErrorPart = StrPart String | TermPart A.Expr | NamePart QName instance PrettyTCM ErrorPart where prettyTCM (StrPart s) = text s @@ -269,7 +263,7 @@ case t of Con c _ es | Just [x] <- allApplyElims es -> choice [ (c `isCon` primAgdaErrorPartString, StrPart <$> unquoteNString x) - , (c `isCon` primAgdaErrorPartTerm, TermPart <$> unquoteN x) + , (c `isCon` primAgdaErrorPartTerm, TermPart <$> ((liftTCM . toAbstractWithoutImplicit) =<< (unquoteN x :: UnquoteM R.Term))) , (c `isCon` primAgdaErrorPartName, NamePart <$> unquoteN x) ] __IMPOSSIBLE__ _ -> throwError $ NonCanonical "error part" t @@ -278,11 +272,11 @@ unquote t = do t <- reduceQuotedTerm t case t of - Con c _ es | Just [x,xs] <- allApplyElims es -> do + Con c _ es | Just [x,xs] <- allApplyElims es -> choice [(c `isCon` primCons, (:) <$> unquoteN x <*> unquoteN xs)] __IMPOSSIBLE__ - Con c _ [] -> do + Con c _ [] -> choice [(c `isCon` primNil, return [])] __IMPOSSIBLE__ @@ -293,7 +287,7 @@ unquote t = do t <- reduceQuotedTerm t case t of - Con c _ [] -> do + Con c _ [] -> choice [(c `isCon` primHidden, return Hidden) ,(c `isCon` primInstance, return (Instance NoOverlap)) @@ -306,7 +300,7 @@ unquote t = do t <- reduceQuotedTerm t case t of - Con c _ [] -> do + Con c _ [] -> choice [(c `isCon` primRelevant, return Relevant) ,(c `isCon` primIrrelevant, return Irrelevant)] @@ -325,7 +319,7 @@ unquote t = do t <- reduceQuotedTerm t case t of - Con c _ es | Just [x,y] <- allApplyElims es -> do + Con c _ es | Just [x,y] <- allApplyElims es -> choice [(c `isCon` primAbsAbs, R.Abs <$> (hint <$> unquoteNString x) <*> unquoteN y)] __IMPOSSIBLE__ @@ -356,11 +350,11 @@ unquote t = do t <- reduceQuotedTerm t case t of - Con c _ [] -> do + Con c _ [] -> choice [(c `isCon` primAgdaSortUnsupported, return R.UnknownS)] __IMPOSSIBLE__ - Con c _ es | Just [u] <- allApplyElims es -> do + Con c _ es | Just [u] <- allApplyElims es -> choice [(c `isCon` primAgdaSortSet, R.SetS <$> unquoteN u) ,(c `isCon` primAgdaSortLit, R.LitS <$> unquoteN u)] @@ -396,7 +390,7 @@ [ (c `isCon` primAgdaTermUnsupported, return R.Unknown) ] __IMPOSSIBLE__ - Con c _ es | Just [x] <- allApplyElims es -> do + Con c _ es | Just [x] <- allApplyElims es -> choice [ (c `isCon` primAgdaTermSort, R.Sort <$> unquoteN x) , (c `isCon` primAgdaTermLit, R.Lit <$> unquoteN x) ] @@ -429,18 +423,18 @@ unquote t = do t <- reduceQuotedTerm t case t of - Con c _ [] -> do + Con c _ [] -> choice [ (c `isCon` primAgdaPatAbsurd, return R.AbsurdP) , (c `isCon` primAgdaPatDot, return R.DotP) ] __IMPOSSIBLE__ - Con c _ es | Just [x] <- allApplyElims es -> do + Con c _ es | Just [x] <- allApplyElims es -> choice [ (c `isCon` primAgdaPatVar, R.VarP <$> unquoteNString x) , (c `isCon` primAgdaPatProj, R.ProjP <$> unquoteN x) , (c `isCon` primAgdaPatLit, R.LitP <$> unquoteN x) ] __IMPOSSIBLE__ - Con c _ es | Just [x, y] <- allApplyElims es -> do + Con c _ es | Just [x, y] <- allApplyElims es -> choice [ (c `isCon` primAgdaPatCon, R.ConP <$> unquoteN x <*> unquoteN y) ] __IMPOSSIBLE__ @@ -451,11 +445,11 @@ unquote t = do t <- reduceQuotedTerm t case t of - Con c _ es | Just [x] <- allApplyElims es -> do + Con c _ es | Just [x] <- allApplyElims es -> choice [ (c `isCon` primAgdaClauseAbsurd, R.AbsurdClause <$> unquoteN x) ] __IMPOSSIBLE__ - Con c _ es | Just [x, y] <- allApplyElims es -> do + Con c _ es | Just [x, y] <- allApplyElims es -> choice [ (c `isCon` primAgdaClauseClause, R.Clause <$> unquoteN x <*> unquoteN y) ] __IMPOSSIBLE__ @@ -481,17 +475,19 @@ case v of I.Def f [] -> - choice [ (f `isDef` primAgdaTCMGetContext, tcGetContext) - , (f `isDef` primAgdaTCMCommit, tcCommit) ] + choice [ (f `isDef` primAgdaTCMGetContext, tcGetContext) + , (f `isDef` primAgdaTCMCommit, tcCommit) + ] failEval I.Def f [u] -> - choice [ (f `isDef` primAgdaTCMInferType, tcFun1 tcInferType u) - , (f `isDef` primAgdaTCMNormalise, tcFun1 tcNormalise u) - , (f `isDef` primAgdaTCMReduce, tcFun1 tcReduce u) - , (f `isDef` primAgdaTCMGetType, tcFun1 tcGetType u) - , (f `isDef` primAgdaTCMGetDefinition, tcFun1 tcGetDefinition u) - , (f `isDef` primAgdaTCMIsMacro, tcFun1 tcIsMacro u) - , (f `isDef` primAgdaTCMFreshName, tcFun1 tcFreshName u) ] + choice [ (f `isDef` primAgdaTCMInferType, tcFun1 tcInferType u) + , (f `isDef` primAgdaTCMNormalise, tcFun1 tcNormalise u) + , (f `isDef` primAgdaTCMReduce, tcFun1 tcReduce u) + , (f `isDef` primAgdaTCMGetType, tcFun1 tcGetType u) + , (f `isDef` primAgdaTCMGetDefinition, tcFun1 tcGetDefinition u) + , (f `isDef` primAgdaTCMIsMacro, tcFun1 tcIsMacro u) + , (f `isDef` primAgdaTCMFreshName, tcFun1 tcFreshName u) + ] failEval I.Def f [u, v] -> choice [ (f `isDef` primAgdaTCMUnify, tcFun2 tcUnify u v) @@ -532,7 +528,7 @@ if norm then normalise v else instantiateFull v mkT l a = El s a - where s = Type $ Max [Plus 0 $ UnreducedLevel l] + where s = Type $ Max 0 [Plus 0 $ UnreducedLevel l] -- Don't catch Unquote errors! tcCatchError :: Term -> Term -> UnquoteM Term @@ -592,7 +588,7 @@ tcCommit = do dirty <- gets fst when (dirty == Dirty) $ - typeError $ GenericError "Cannot use commitTC after declaring new definitions." + liftTCM $ typeError $ GenericError "Cannot use commitTC after declaring new definitions." s <- getTC modify (second $ const s) liftTCM primUnitUnit @@ -626,8 +622,7 @@ tcUnquoteTerm :: Type -> R.Term -> TCM Term tcUnquoteTerm a v = do e <- toAbstract_ v - v <- checkExpr e a - return v + checkExpr e a tcNormalise :: R.Term -> TCM Term tcNormalise v = do @@ -653,12 +648,12 @@ tcExtendContext :: Term -> Term -> UnquoteM Term tcExtendContext a m = do a <- unquote a - extendCxt a (evalTCM m) + strengthen __UNREACHABLE__ <$> extendCxt a (evalTCM $ raise 1 m) tcInContext :: Term -> Term -> UnquoteM Term tcInContext c m = do c <- unquote c - liftU1 inTopContext $ go c (evalTCM m) + liftU1 unsafeInTopContext $ go c (evalTCM m) where go :: [Arg R.Type] -> UnquoteM Term -> UnquoteM Term go [] m = m @@ -695,7 +690,7 @@ liftTCM $ do reportSDoc "tc.unquote.decl" 10 $ sep [ "declare" <+> prettyTCM x <+> ":" - , nest 2 $ prettyTCM a + , nest 2 $ prettyR a ] a <- isType_ =<< toAbstract_ a alreadyDefined <- isRight <$> getConstInfo' x @@ -708,7 +703,7 @@ tcDeclarePostulate (Arg i x) a = inOriginalContext $ do clo <- commandLineOptions when (Lens.getSafeMode clo) $ liftTCM $ typeError . GenericDocError =<< - "Cannot postulate '" <+> prettyTCM x <+> ":" <+> prettyTCM a <+> "' with safe flag" + "Cannot postulate '" <+> prettyTCM x <+> ":" <+> prettyR a <+> "' with safe flag" setDirty let r = getRelevance i when (hidden i) $ liftTCM $ typeError . GenericDocError =<< @@ -717,7 +712,7 @@ liftTCM $ do reportSDoc "tc.unquote.decl" 10 $ sep [ "declare Postulate" <+> prettyTCM x <+> ":" - , nest 2 $ prettyTCM a + , nest 2 $ prettyR a ] a <- isType_ =<< toAbstract_ a alreadyDefined <- isRight <$> getConstInfo' x @@ -732,7 +727,9 @@ genericError $ "Missing declaration for " ++ prettyShow x cs <- mapM (toAbstract_ . QNamed x) cs reportSDoc "tc.unquote.def" 10 $ vcat $ map prettyA cs - let i = mkDefInfo (nameConcrete $ qnameName x) noFixity' PublicAccess ConcreteDef noRange + let accessDontCare = __IMPOSSIBLE__ -- or ConcreteDef, value not looked at + ac <- asksTC (^. lensIsAbstract) -- Issue #4012, respect AbstractMode + let i = mkDefInfo (nameConcrete $ qnameName x) noFixity' accessDontCare ac noRange checkFunDef NotDelayed i x cs primUnitUnit diff --git a/src/full/Agda/TypeChecking/Warnings.hs b/src/full/Agda/TypeChecking/Warnings.hs --- a/src/full/Agda/TypeChecking/Warnings.hs +++ b/src/full/Agda/TypeChecking/Warnings.hs @@ -1,67 +1,114 @@ -{-# LANGUAGE CPP #-} - -module Agda.TypeChecking.Warnings where +module Agda.TypeChecking.Warnings + ( MonadWarning(..) + , genericWarning + , genericNonFatalError + , warning_, warning, warnings + , isUnsolvedWarning + , isMetaWarning + , isMetaTCWarning + , onlyShowIfUnsolved + , WhichWarnings(..), classifyWarning + -- not exporting constructor of WarningsAndNonFatalErrors + , WarningsAndNonFatalErrors, tcWarnings, nonFatalErrors + , emptyWarningsAndNonFatalErrors, classifyWarnings + , runPM + ) where import qualified Data.Set as Set import qualified Data.List as List import Data.Maybe ( catMaybes ) -import Control.Monad ( guard, forM, unless ) +import Data.Semigroup ( Semigroup, (<>) ) +import Control.Monad ( forM, unless ) +import Control.Monad.Reader ( ReaderT ) +import Control.Monad.State ( StateT ) +import Control.Monad.Trans ( lift ) + import Agda.TypeChecking.Monad.Base import Agda.TypeChecking.Monad.Caching -import {-# SOURCE #-} Agda.TypeChecking.Errors -import {-# SOURCE #-} Agda.TypeChecking.Pretty +import {-# SOURCE #-} Agda.TypeChecking.Pretty (MonadPretty, prettyTCM) +import {-# SOURCE #-} Agda.TypeChecking.Pretty.Call +import {-# SOURCE #-} Agda.TypeChecking.Pretty.Warning () import Agda.Syntax.Position import Agda.Syntax.Parser -import Agda.Syntax.Concrete.Definitions (DeclarationWarning(..)) import Agda.Interaction.Options import Agda.Interaction.Options.Warnings +import {-# SOURCE #-} Agda.Interaction.Highlighting.Generate (highlightWarning) import Agda.Utils.Lens import qualified Agda.Utils.Pretty as P import Agda.Utils.Except +class (MonadPretty m, MonadError TCErr m) => MonadWarning m where + -- | Render the warning + addWarning :: TCWarning -> m () + +instance Applicative m => Semigroup (ReaderT s m P.Doc) where + d1 <> d2 = (<>) <$> d1 <*> d2 + +instance MonadWarning m => MonadWarning (ReaderT r m) where + addWarning = lift . addWarning + +instance Monad m => Semigroup (StateT s m P.Doc) where + d1 <> d2 = (<>) <$> d1 <*> d2 + +instance MonadWarning m => MonadWarning (StateT s m) where + addWarning = lift . addWarning + +-- This instance is more specific than a generic instance +-- @Semigroup a => Semigroup (TCM a)@ +instance {-# OVERLAPPING #-} Semigroup (TCM P.Doc) where + d1 <> d2 = (<>) <$> d1 <*> d2 + +instance MonadWarning TCM where + addWarning tcwarn = do + stTCWarnings `modifyTCLens` add w' tcwarn + highlightWarning tcwarn + where + w' = tcWarning tcwarn + + add w tcwarn tcwarns + | onlyOnce w && elem tcwarn tcwarns = tcwarns -- Eq on TCWarning only checks head constructor + | otherwise = tcwarn : tcwarns + {-# SPECIALIZE genericWarning :: P.Doc -> TCM () #-} -genericWarning :: MonadTCM tcm => P.Doc -> tcm () +genericWarning :: MonadWarning m => P.Doc -> m () genericWarning = warning . GenericWarning {-# SPECIALIZE genericNonFatalError :: P.Doc -> TCM () #-} -genericNonFatalError :: MonadTCM tcm => P.Doc -> tcm () +genericNonFatalError :: MonadWarning m => P.Doc -> m () genericNonFatalError = warning . GenericNonFatalError {-# SPECIALIZE warning_ :: Warning -> TCM TCWarning #-} -warning_ :: MonadTCM tcm => Warning -> tcm TCWarning +warning_ :: MonadWarning m => Warning -> m TCWarning warning_ w = do r <- viewTC eRange c <- viewTC eCall - b <- liftTCM areWeCaching + b <- areWeCaching -- NicifierIssues print their own error locations in their list of -- issues (but we might need to keep the overall range `r` for -- comparing ranges) let r' = case w of { NicifierIssue{} -> NoRange ; _ -> r } - p <- liftTCM $ sayWhen r' c $ prettyWarning w - liftTCM $ return $ TCWarning r w p b - --- | @applyWarningMode@ filters out the warnings the user has not requested --- Users are not allowed to ignore non-fatal errors. + p <- sayWhen r' c $ prettyTCM w + return $ TCWarning r w p b -applyWarningMode :: WarningMode -> Warning -> Maybe Warning -applyWarningMode wm w = case classifyWarning w of - ErrorWarnings -> Just w - AllWarnings -> w <$ guard (Set.member (warningName w) $ wm ^. warningSet) +-- UNUSED Liang-Ting Chen 2019-07-16 +---- | @applyWarningMode@ filters out the warnings the user has not requested +---- Users are not allowed to ignore non-fatal errors. +-- +--applyWarningMode :: WarningMode -> Warning -> Maybe Warning +--applyWarningMode wm w = case classifyWarning w of +-- ErrorWarnings -> Just w +-- AllWarnings -> w <$ guard (Set.member (warningName w) $ wm ^. warningSet) {-# SPECIALIZE warnings :: [Warning] -> TCM () #-} -warnings :: MonadTCM tcm => [Warning] -> tcm () +warnings :: MonadWarning m => [Warning] -> m () warnings ws = do wmode <- optWarningMode <$> pragmaOptions - let add w tcwarn tcwarns - | onlyOnce w && elem tcwarn tcwarns = tcwarns -- Eq on TCWarning only checks head constructor - | otherwise = tcwarn : tcwarns - -- We collect *all* of the warnings no matter whether they are in the @warningSet@ -- or not. If we find one which should be turned into an error, we keep processing -- the rest of the warnings and *then* report all of the errors at once. @@ -69,16 +116,36 @@ tcwarn <- warning_ w' if wmode ^. warn2Error && warningName w' `elem` wmode ^. warningSet then pure (Just tcwarn) - else Nothing <$ (stTCWarnings `modifyTCLens` add w' tcwarn) + else Nothing <$ addWarning tcwarn let errs = catMaybes merrs unless (null errs) $ typeError $ NonFatalErrors errs {-# SPECIALIZE warning :: Warning -> TCM () #-} -warning :: MonadTCM tcm => Warning -> tcm () +warning :: MonadWarning m => Warning -> m () warning = warnings . pure +isUnsolvedWarning :: Warning -> Bool +isUnsolvedWarning w = warningName w `Set.member` unsolvedWarnings +isMetaWarning :: Warning -> Bool +isMetaWarning w = case w of + UnsolvedInteractionMetas{} -> True + UnsolvedMetaVariables{} -> True + _ -> False + +isMetaTCWarning :: TCWarning -> Bool +isMetaTCWarning = isMetaWarning . tcWarning + +-- | Should we only emit a single warning with this constructor. +onlyOnce :: Warning -> Bool +onlyOnce InversionDepthReached{} = True +onlyOnce _ = False + +onlyShowIfUnsolved :: Warning -> Bool +onlyShowIfUnsolved InversionDepthReached{} = True +onlyShowIfUnsolved _ = False + -- | Classifying warnings: some are benign, others are (non-fatal) errors data WhichWarnings = @@ -87,26 +154,29 @@ -- Note: order of constructors is important for the derived Ord instance deriving (Eq, Ord) -isUnsolvedWarning :: Warning -> Bool -isUnsolvedWarning w = warningName w `elem` unsolvedWarnings - classifyWarning :: Warning -> WhichWarnings classifyWarning w = - if warningName w `elem` errorWarnings + if warningName w `Set.member` errorWarnings then ErrorWarnings else AllWarnings --- | Should we only emit a single warning with this constructor. -onlyOnce :: Warning -> Bool -onlyOnce InversionDepthReached{} = True -onlyOnce _ = False +-- | Assorted warnings and errors to be displayed to the user +data WarningsAndNonFatalErrors = WarningsAndNonFatalErrors + { tcWarnings :: [TCWarning] + , nonFatalErrors :: [TCWarning] + } -onlyShowIfUnsolved :: Warning -> Bool -onlyShowIfUnsolved InversionDepthReached{} = True -onlyShowIfUnsolved _ = False +-- | The only way to construct a empty WarningsAndNonFatalErrors -classifyWarnings :: [TCWarning] -> ([TCWarning], [TCWarning]) -classifyWarnings = List.partition $ (< AllWarnings) . classifyWarning . tcWarning +emptyWarningsAndNonFatalErrors :: WarningsAndNonFatalErrors +emptyWarningsAndNonFatalErrors = WarningsAndNonFatalErrors [] [] + +classifyWarnings :: [TCWarning] -> WarningsAndNonFatalErrors +classifyWarnings ws = WarningsAndNonFatalErrors warnings errors + where + partite = (< AllWarnings) . classifyWarning . tcWarning + (errors, warnings) = List.partition partite ws + -- | running the Parse monad diff --git a/src/full/Agda/TypeChecking/Warnings.hs-boot b/src/full/Agda/TypeChecking/Warnings.hs-boot new file mode 100644 --- /dev/null +++ b/src/full/Agda/TypeChecking/Warnings.hs-boot @@ -0,0 +1,13 @@ + +module Agda.TypeChecking.Warnings where + +import Agda.TypeChecking.Monad.Base + +import Agda.Utils.Except + +class (MonadPretty m, MonadError TCErr m) => MonadWarning m where + addWarning :: TCWarning -> m () + +warnings :: MonadWarning m => [Warning] -> m () + +warning :: MonadWarning m => Warning -> m () diff --git a/src/full/Agda/TypeChecking/With.hs b/src/full/Agda/TypeChecking/With.hs --- a/src/full/Agda/TypeChecking/With.hs +++ b/src/full/Agda/TypeChecking/With.hs @@ -1,21 +1,19 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE NondecreasingIndentation #-} module Agda.TypeChecking.With where -import Control.Arrow ((&&&), (***), first, second) -import Control.Applicative hiding (empty) import Control.Monad import Control.Monad.Writer (WriterT, runWriterT, tell) import Data.Either import qualified Data.List as List +import Data.List.NonEmpty (NonEmpty(..)) +import qualified Data.List.NonEmpty as NonEmpty import Data.Maybe -import Data.Monoid -import Data.Traversable (traverse) +import Data.Foldable ( foldrM ) +import Data.Traversable ( traverse ) import Agda.Syntax.Common -import Agda.Syntax.Concrete.Pattern (IsWithP(..)) import Agda.Syntax.Internal as I import Agda.Syntax.Internal.Pattern import qualified Agda.Syntax.Abstract as A @@ -25,7 +23,6 @@ import Agda.Syntax.Position import Agda.TypeChecking.Monad -import Agda.TypeChecking.Monad.Builtin import Agda.TypeChecking.Reduce import Agda.TypeChecking.Datatypes import Agda.TypeChecking.EtaContract @@ -35,8 +32,6 @@ import Agda.TypeChecking.Records import Agda.TypeChecking.Substitute import Agda.TypeChecking.Telescope -import Agda.TypeChecking.ReconstructParameters -import Agda.TypeChecking.Rules.Term import Agda.TypeChecking.Abstract import Agda.TypeChecking.Rules.LHS.Implicit @@ -46,17 +41,14 @@ import Agda.Utils.List import Agda.Utils.Maybe import Agda.Utils.Monad -import Agda.Utils.NonemptyList import Agda.Utils.Null (empty) import Agda.Utils.Permutation import Agda.Utils.Pretty (prettyShow) import qualified Agda.Utils.Pretty as P import Agda.Utils.Size -#include "undefined.h" import Agda.Utils.Impossible - -- | Split pattern variables according to with-expressions. -- Input: @@ -65,39 +57,32 @@ -- -- [@Δ ⊢ t@] type of rhs. -- --- [@Δ ⊢ as@] types of with arguments. --- --- [@Δ ⊢ vs@] with arguments. --- +-- [@Δ ⊢ vs : as@] with arguments and their types -- -- Output: -- --- [@Δ₁@] part of context needed for with arguments and their types. --- --- [@Δ₂@] part of context not needed for with arguments and their types. +-- [@Δ₁@] part of context needed for with arguments and their types. -- --- [@π@] permutation from Δ to Δ₁Δ₂ as returned by 'splitTelescope'. +-- [@Δ₂@] part of context not needed for with arguments and their types. -- --- [@Δ₁Δ₂ ⊢ t'@] type of rhs under @π@ +-- [@π@] permutation from Δ to Δ₁Δ₂ as returned by 'splitTelescope'. -- --- [@Δ₁ ⊢ as'@] types of with-arguments depending only on @Δ₁@. +-- [@Δ₁Δ₂ ⊢ t'@] type of rhs under @π@ -- --- [@Δ₁ ⊢ vs'@] with-arguments under @π@. +-- [@Δ₁ ⊢ vs' : as'@] with-arguments and their types depending only on @Δ₁@. splitTelForWith -- Input: - :: Telescope -- ^ __@Δ@__ context of types and with-arguments. - -> Type -- ^ __@Δ ⊢ t@__ type of rhs. - -> [EqualityView] -- ^ __@Δ ⊢ as@__ types of with arguments. - -> [Term] -- ^ __@Δ ⊢ vs@__ with arguments. + :: Telescope -- ^ __@Δ@__ context of types and with-arguments. + -> Type -- ^ __@Δ ⊢ t@__ type of rhs. + -> [WithHiding (Term, EqualityView)] -- ^ __@Δ ⊢ vs : as@__ with arguments and their types. -- Output: - -> ( Telescope -- @Δ₁@ part of context needed for with arguments and their types. - , Telescope -- @Δ₂@ part of context not needed for with arguments and their types. - , Permutation -- @π@ permutation from Δ to Δ₁Δ₂ as returned by 'splitTelescope'. - , Type -- @Δ₁Δ₂ ⊢ t'@ type of rhs under @π@ - , [EqualityView] -- @Δ₁ ⊢ as'@ types of with- and rewrite-arguments depending only on @Δ₁@. - , [Term] -- @Δ₁ ⊢ vs'@ with- and rewrite-arguments under @π@. - ) -- ^ (__@Δ₁@__,__@Δ₂@__,__@π@__,__@t'@__,__@as'@__,__@vs'@__) where + -> ( Telescope -- @Δ₁@ part of context needed for with arguments and their types. + , Telescope -- @Δ₂@ part of context not needed for with arguments and their types. + , Permutation -- @π@ permutation from Δ to Δ₁Δ₂ as returned by 'splitTelescope'. + , Type -- @Δ₁Δ₂ ⊢ t'@ type of rhs under @π@ + , [WithHiding (Term, EqualityView)] -- @Δ₁ ⊢ vs' : as'@ with- and rewrite-arguments and types under @π@. + ) -- ^ (__@Δ₁@__,__@Δ₂@__,__@π@__,__@t'@__,__@vtys'@__) where -- -- [@Δ₁@] part of context needed for with arguments and their types. -- @@ -107,22 +92,12 @@ -- -- [@Δ₁Δ₂ ⊢ t'@] type of rhs under @π@ -- --- [@Δ₁ ⊢ as'@] types with with-arguments depending only on @Δ₁@. --- --- [@Δ₁ ⊢ vs'@] with-arguments under @π@. - -splitTelForWith delta t as vs = let - -- Andreas, 2016-01-27, unfixing issue 1692 - -- Due to public protests, we do not rewrite in the types of rewrite - -- expressions. - -- Otherwise, we cannot rewrite twice after another with the same equation - -- as it turns into a reflexive equation in the first rewrite. - -- Thus we include the fvs of the rewrite terms in Δ₁. - rewriteTerms = map snd $ filter (isEqualityType . fst) $ zip as vs +-- [@Δ₁ ⊢ vtys'@] with-arguments and their types under @π@. +splitTelForWith delta t vtys = let -- Split the telescope into the part needed to type the with arguments -- and all the other stuff. - fv = allFreeVars (as, vs) + fv = allFreeVars vtys SplitTel delta1 delta2 perm = splitTelescope fv delta -- Δ₁Δ₂ ⊢ π : Δ @@ -134,12 +109,10 @@ -- We need Δ₁Δ₂ ⊢ t' t' = applySubst pi t - -- and Δ₁ ⊢ as' - as' = applySubst rhopi as - -- and Δ₁ ⊢ vs' : as' - vs' = applySubst rhopi vs + -- and Δ₁ ⊢ vtys' + vtys' = applySubst rhopi vtys - in (delta1, delta2, perm, t', as', vs') + in (delta1, delta2, perm, t', vtys') -- | Abstract with-expressions @vs@ to generate type for with-helper function. @@ -147,18 +120,17 @@ -- Each @EqualityType@, coming from a @rewrite@, will turn into 2 abstractions. withFunctionType - :: Telescope -- ^ @Δ₁@ context for types of with types. - -> [Term] -- ^ @Δ₁,Δ₂ ⊢ vs : raise Δ₂ as@ with and rewrite-expressions. - -> [EqualityView] -- ^ @Δ₁ ⊢ as@ types of with and rewrite-expressions. - -> Telescope -- ^ @Δ₁ ⊢ Δ₂@ context extension to type with-expressions. - -> Type -- ^ @Δ₁,Δ₂ ⊢ b@ type of rhs. + :: Telescope -- ^ @Δ₁@ context for types of with types. + -> [WithHiding (Term, EqualityView)] -- ^ @Δ₁,Δ₂ ⊢ vs : raise Δ₂ as@ with and rewrite-expressions and their type. + -> Telescope -- ^ @Δ₁ ⊢ Δ₂@ context extension to type with-expressions. + -> Type -- ^ @Δ₁,Δ₂ ⊢ b@ type of rhs. -> TCM (Type, Nat) -- ^ @Δ₁ → wtel → Δ₂′ → b′@ such that -- @[vs/wtel]wtel = as@ and -- @[vs/wtel]Δ₂′ = Δ₂@ and -- @[vs/wtel]b′ = b@. -- Plus the final number of with-arguments. -withFunctionType delta1 vs as delta2 b = addContext delta1 $ do +withFunctionType delta1 vtys delta2 b = addContext delta1 $ do reportSLn "tc.with.abstract" 20 $ "preparing for with-abstraction" @@ -173,16 +145,13 @@ d2b <- etaContract d2b dbg 30 "eta-contracted Δ₂ → B" d2b - vs <- etaContract =<< normalise vs - as <- etaContract =<< normalise as -- do we need this? + vtys <- etaContract =<< normalise vtys - let piAbstractVs [] b = return b - piAbstractVs (va : vas) b = piAbstract va =<< piAbstractVs vas b -- wd2db = wtel → [vs : as] (Δ₂ → B) - wd2b <- piAbstractVs (zip vs as) d2b + wd2b <- foldrM piAbstract d2b vtys dbg 30 "wΓ → Δ₂ → B" wd2b - return (telePi_ delta1 wd2b, countWithArgs as) + return (telePi_ delta1 wd2b, countWithArgs (map (snd . whThing) vtys)) countWithArgs :: [EqualityView] -> Nat countWithArgs = sum . map countArgs @@ -192,8 +161,8 @@ -- | From a list of @with@ and @rewrite@ expressions and their types, -- compute the list of final @with@ expressions (after expanding the @rewrite@s). -withArguments :: [Term] -> [EqualityView] -> [Term] -withArguments vs as = concat $ for (zip vs as) $ \case +withArguments :: [WithHiding (Term, EqualityView)] -> [WithHiding Term] +withArguments vtys = flip concatMap vtys $ traverse $ \case (v, OtherType a) -> [v] (prf, eqt@(EqualityType s _eq _pars _t v _v')) -> [unArg v, prf] @@ -339,7 +308,7 @@ -- instantiations from qs, so we make sure -- that t is the top-level type of the parent function and add patterns for -- the module parameters to ps before stripping. - let paramPat i _ = A.VarP $ A.BindName $ indexWithDefault __IMPOSSIBLE__ cxtNames i + let paramPat i _ = A.VarP $ A.mkBindName $ indexWithDefault __IMPOSSIBLE__ cxtNames i ps' = zipWith (fmap . fmap . paramPat) [0..] (take npars qs) ++ ps psi <- insertImplicitPatternsT ExpandLast ps' t reportSDoc "tc.with.strip" 10 $ vcat @@ -364,6 +333,15 @@ return (strippedPats, psp) where + -- We need to get the correct hiding from the lhs context. The unifier may have moved bindings + -- sites around so we can't trust the hiding of the parent pattern variables. We should preserve + -- the origin though. + varArgInfo = \ x -> let n = dbPatVarIndex x in + if n < length infos then infos !! n else __IMPOSSIBLE__ + where infos = reverse $ map getArgInfo $ telToList delta + + setVarArgInfo x p = setOrigin (getOrigin p) $ setArgInfo (varArgInfo x) p + strip :: Term -- ^ Self. -> Type -- ^ The type to be eliminated. @@ -395,7 +373,7 @@ -- are implicit patterns (we inserted too many). strip _ _ ps [] = do let implicit (A.WildP{}) = True - implicit (A.ConP ci _ _) = patOrigin ci == ConOSystem + implicit (A.ConP ci _ _) = conPatOrigin ci == ConOSystem implicit _ = False unless (all (implicit . namedArg) ps) $ typeError $ GenericError $ "Too many arguments given in with-clause" @@ -422,13 +400,13 @@ case namedArg q of ProjP o d -> case A.isProjP p of Just (o', AmbQ ds) -> do + -- We assume here that neither @o@ nor @o'@ can be @ProjSystem@. + if o /= o' then liftTCM $ mismatchOrigin o o' else do -- Andreas, 2016-12-28, issue #2360: -- We disambiguate the projection in the with clause -- to the projection in the parent clause. d <- liftTCM $ getOriginalProjection d - found <- anyM ds ((d ==) <.> (liftTCM . getOriginalProjection)) - -- We assume here that neither @o@ nor @o'@ can be @ProjSystem@. - if o /= o' then liftTCM $ mismatchOrigin o o' else do + found <- anyM ds $ \ d' -> liftTCM $ (Just d ==) . fmap projOrig <$> isProjection d' if not found then mismatch else do (self1, t1, ps) <- liftTCM $ do t <- reduce t @@ -441,15 +419,14 @@ strip self1 t1 ps qs Nothing -> mismatch - -- If a variable pattern in the parent clause was written as a dot - -- pattern by the user both in the parent clause and the with clause, - -- we can strip the dot from the with clause. - VarP PatODot x | A.DotP _ u <- namedArg p - , A.Var y <- unScope u -> - (setNamedArg p (A.VarP $ A.BindName y) :) <$> + -- We can safely strip dots from variables. The unifier will put them back when required. + VarP _ x | A.DotP _ u <- namedArg p + , A.Var y <- unScope u -> do + (setVarArgInfo x (setNamedArg p $ A.VarP $ A.mkBindName y) :) <$> recurse (var (dbPatVarIndex x)) - VarP _ x -> (p :) <$> recurse (var (dbPatVarIndex x)) + VarP _ x -> + (setVarArgInfo x p :) <$> recurse (var (dbPatVarIndex x)) IApplyP{} -> typeError $ GenericError $ "with clauses not supported in the presence of Path patterns" -- TODO maybe we can support them now? DefP{} -> typeError $ GenericError $ "with clauses not supported in the presence of hcomp patterns" -- TODO this should actually be impossible @@ -477,7 +454,15 @@ -- Jesper, 2017-11-16. This is now also allowed for data constructors. A.DotP r e -> do tell [ProblemEq (A.DotP r e) (patternToTerm q') a] - let ps' = map (unnamed (A.WildP empty) <$) qs' + ps' <- + case appView e of + -- If dot-pattern is an application of the constructor, try to preserve the + -- arguments. + Application (A.Con (A.AmbQ cs')) es -> do + cs' <- liftTCM $ snd . partitionEithers <$> mapM getConForm (NonEmpty.toList cs') + unless (elem c cs') mismatch + return $ (map . fmap . fmap) (A.DotP r) es + _ -> return $ map (unnamed (A.WildP empty) <$) qs' stripConP d us b c ConOCon qs' ps' -- Andreas, 2016-12-29, issue #2363. @@ -502,13 +487,14 @@ -- Check whether the with-clause constructor can be (possibly trivially) -- disambiguated to be equal to the parent-clause constructor. -- Andreas, 2017-08-13, herein, ignore abstract constructors. - cs' <- liftTCM $ do snd . partitionEithers <$> mapM getConForm (toList cs') + cs' <- liftTCM $ snd . partitionEithers <$> mapM getConForm (NonEmpty.toList cs') unless (elem c cs') mismatch -- Strip the subpatterns ps' and then continue. stripConP d us b c ConOCon qs' ps' A.RecP _ fs -> caseMaybeM (liftTCM $ isRecord d) mismatch $ \ def -> do - ps' <- liftTCM $ insertMissingFields d (const $ A.WildP empty) fs (recordFieldNames def) + ps' <- liftTCM $ insertMissingFields d (const $ A.WildP empty) fs + (map argFromDom $ recordFieldNames def) stripConP d us b c ConORec qs' ps' p@(A.PatternSynP pi' c' ps') -> do @@ -521,7 +507,7 @@ text $ "with clause pattern is " ++ show p mismatch - LitP lit -> case namedArg p of + LitP _ lit -> case namedArg p of A.LitP lit' | lit == lit' -> recurse $ Lit lit A.WildP{} -> recurse $ Lit lit @@ -728,12 +714,14 @@ toTerm :: DeBruijnPattern -> DisplayTerm toTerm p = case p of - IApplyP o _ _ x -> DTerm $ var $ dbPatVarIndex x -- TODO, should be an Elim' DisplayTerm ? + IApplyP _ _ _ x -> DTerm $ var $ dbPatVarIndex x -- TODO, should be an Elim' DisplayTerm ? ProjP _ d -> DDef d [] -- WRONG. TODO: convert spine to non-spine ... DDef d . defaultArg - VarP PatODot x -> DDot $ var $ dbPatVarIndex x - VarP o x -> DTerm $ var $ dbPatVarIndex x - DotP PatOVar{} t@(Var i []) -> DTerm t - DotP o t -> DDot $ t + VarP i x -> case patOrigin i of + PatODot -> DDot $ var $ dbPatVarIndex x + _ -> DTerm $ var $ dbPatVarIndex x + DotP i t -> case patOrigin i of + PatOVar{} | Var i [] <- t -> DTerm t + _ -> DDot $ t ConP c cpi ps -> DCon c (fromConPatternInfo cpi) $ toTerms ps - LitP l -> DTerm $ Lit l - DefP o q ps -> DDef q $ map Apply $ toTerms ps + LitP _ l -> DTerm $ Lit l + DefP _ q ps -> DDef q $ map Apply $ toTerms ps diff --git a/src/full/Agda/Utils/AffineHole.hs b/src/full/Agda/Utils/AffineHole.hs --- a/src/full/Agda/Utils/AffineHole.hs +++ b/src/full/Agda/Utils/AffineHole.hs @@ -1,16 +1,15 @@ -{-# LANGUAGE DeriveFunctor #-} -- | Contexts with at most one hole. module Agda.Utils.AffineHole where -import Control.Applicative + data AffineHole r a = ZeroHoles a -- ^ A constant term. - | OneHole (r -> a) - -- ^ A term with one hole. + | OneHole (r -> a) r + -- ^ A term with one hole and the (old) contents. | ManyHoles -- ^ A term with many holes (error value). deriving (Functor) @@ -19,8 +18,8 @@ pure = ZeroHoles ZeroHoles f <*> ZeroHoles a = ZeroHoles $ f a - ZeroHoles f <*> OneHole g = OneHole $ f . g - OneHole h <*> ZeroHoles a = OneHole (`h` a) + ZeroHoles f <*> OneHole g y = OneHole (f . g) y + OneHole h x <*> ZeroHoles a = OneHole (`h` a) x _ <*> _ = ManyHoles -- NB: @AffineHole r@ is not a monad. diff --git a/src/full/Agda/Utils/Applicative.hs b/src/full/Agda/Utils/Applicative.hs new file mode 100644 --- /dev/null +++ b/src/full/Agda/Utils/Applicative.hs @@ -0,0 +1,15 @@ +module Agda.Utils.Applicative + ( (?*>) + , (?$>) + ) + where + +import Control.Applicative + +-- | Guard: return the action @f@ only if the boolean is @True@ +(?*>) :: Alternative f => Bool -> f a -> f a +b ?*> f = if b then f else empty + +-- | Guard: return the value @a@ only if the boolean is @True@ +(?$>) :: Alternative f => Bool -> a -> f a +b ?$> a = b ?*> pure a diff --git a/src/full/Agda/Utils/AssocList.hs b/src/full/Agda/Utils/AssocList.hs --- a/src/full/Agda/Utils/AssocList.hs +++ b/src/full/Agda/Utils/AssocList.hs @@ -1,17 +1,20 @@ -{-# LANGUAGE CPP #-} -- | Additional functions for association lists. -module Agda.Utils.AssocList where +module Agda.Utils.AssocList + ( module Agda.Utils.AssocList + , lookup + ) where import Prelude hiding (lookup) -import qualified Data.List as List import Data.Function +import Data.List (lookup) +import qualified Data.List as List +import qualified Data.Map as Map import Agda.Utils.Tuple -#include "undefined.h" import Agda.Utils.Impossible -- | A finite map, represented as a set of pairs. @@ -19,10 +22,20 @@ -- Invariant: at most one value per key. type AssocList k v = [(k,v)] --- | O(n). --- Reexport 'List.lookup'. -lookup :: Eq k => k -> AssocList k v -> Maybe v -lookup = List.lookup +-- Lookup, reexported from Data.List. +-- O(n). +-- lookup :: Eq k => k -> AssocList k v -> Maybe v + +-- | Lookup keys in the same association list often. +-- Use partially applied to create partial function +-- @apply m :: k -> Maybe v@. +-- +-- * First time: @O(n log n)@ in the worst case. +-- * Subsequently: @O(log n)@. +-- +-- Specification: @apply m == (`lookup` m)@. +apply :: Ord k => AssocList k v -> k -> Maybe v +apply m = (`Map.lookup` Map.fromListWith (\ _new old -> old) m) -- | O(n). -- Get the domain (list of keys) of the finite map. diff --git a/src/full/Agda/Utils/Bag.hs b/src/full/Agda/Utils/Bag.hs --- a/src/full/Agda/Utils/Bag.hs +++ b/src/full/Agda/Utils/Bag.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} -- | A simple overlay over Data.Map to manage unordered sets with duplicates. @@ -6,21 +5,16 @@ import Prelude hiding (null, map) -import Control.Applicative hiding (empty) -import Text.Show.Functions () +import Text.Show.Functions () -- instance only import Data.Foldable (Foldable(foldMap)) -import Data.Functor.Identity import qualified Data.List as List import Data.Map (Map) import qualified Data.Map as Map import Data.Semigroup -import qualified Data.Set as Set -import Data.Traversable import Agda.Utils.Functor -#include "undefined.h" import Agda.Utils.Impossible -- | A set with duplicates. @@ -114,7 +108,7 @@ keys :: Bag a -> [a] keys = Map.keys . bag -- Works because of the invariant! --- keys = catMaybes . map headMaybe . Map.elems . bag +-- keys = catMaybes . map listToMaybe . Map.elems . bag -- -- Map.keys does not work, as zero copies @(a,[])@ -- -- should count as not present in the bag. @@ -148,7 +142,7 @@ ------------------------------------------------------------------------ instance Show a => Show (Bag a) where - showsPrec _ (Bag b) = ("Agda.Utils.Bag.Bag (" ++) . showsPrec 0 b . (')':) + showsPrec _ (Bag b) = ("Agda.Utils.Bag.Bag (" ++) . shows b . (')':) instance Ord a => Semigroup (Bag a) where (<>) = union diff --git a/src/full/Agda/Utils/Benchmark.hs b/src/full/Agda/Utils/Benchmark.hs --- a/src/full/Agda/Utils/Benchmark.hs +++ b/src/full/Agda/Utils/Benchmark.hs @@ -13,7 +13,7 @@ import Control.Monad.State import Data.Foldable (foldMap) -import Data.Functor + import Data.Function import qualified Data.List as List import Data.Monoid diff --git a/src/full/Agda/Utils/BiMap.hs b/src/full/Agda/Utils/BiMap.hs --- a/src/full/Agda/Utils/BiMap.hs +++ b/src/full/Agda/Utils/BiMap.hs @@ -1,5 +1,3 @@ -{-# LANGUAGE DeriveDataTypeable #-} -{-# LANGUAGE GeneralizedNewtypeDeriving #-} -- | Finite bijections (implemented as a pair of tree maps). @@ -7,14 +5,14 @@ import Prelude hiding (lookup, unzip) -import Control.Applicative ((<*>)) + import Data.Function -import Data.Functor + import qualified Data.List as List import Data.Map (Map) import qualified Data.Map as Map -import Data.Tuple + -- | Finite bijective map from @a@ to @b@. There, and back again. data BiMap a b = BiMap diff --git a/src/full/Agda/Utils/Char.hs b/src/full/Agda/Utils/Char.hs deleted file mode 100644 --- a/src/full/Agda/Utils/Char.hs +++ /dev/null @@ -1,53 +0,0 @@ -module Agda.Utils.Char where - -import Data.Char - --- | Convert a character in @'0'..'9'@ into the corresponding digit @0..9@. - -decDigit :: Char -> Int -decDigit c = ord c - ord '0' - --- | Convert a character in @'0'..'9','A'..'F','a'..'f'@ --- into the corresponding digit @0..15@. - -hexDigit :: Char -> Int -hexDigit c | isDigit c = decDigit c - | otherwise = ord (toLower c) - ord 'a' + 10 - --- | Convert a character in @'0'..'7'@ into the corresponding digit @0..7@. - -octDigit :: Char -> Int -octDigit = decDigit - ------------------------------------------------------------------------- --- * Unicode exploration ------------------------------------------------------------------------- - --- | Unicode characters are divided into letters, numbers, marks, --- punctuation, symbols, separators (including spaces) and others --- (including control characters). --- --- These are the tests that 'Data.Char' offers: -data UnicodeTest - = IsControl | IsSpace - | IsLower | IsUpper | IsAlpha | IsAlphaNum | IsPrint - | IsDigit | IsOctDigit | IsHexDigit - | IsLetter | IsMark | IsNumber | IsPunctuation | IsSymbol | IsSeparator - deriving (Eq, Ord, Show) - --- | Test names paired with their implementation. -unicodeTests :: [(UnicodeTest, Char -> Bool)] -unicodeTests = - [ (IsControl, isControl), (IsSpace, isSpace) - , (IsLower, isLower), (IsUpper, isUpper), (IsAlpha, isAlpha) - , (IsAlphaNum, isAlphaNum) - , (IsPrint, isPrint) - , (IsDigit, isDigit), (IsOctDigit, isOctDigit), (IsHexDigit, isHexDigit) - , (IsLetter, isLetter), (IsMark, isMark) - , (IsNumber, isNumber), (IsPunctuation, isPunctuation), (IsSymbol, isSymbol) - , (IsSeparator, isSeparator) - ] - --- | Find out which tests a character satisfies. -testChar :: Char -> [UnicodeTest] -testChar c = map fst $ filter (($ c) . snd) unicodeTests diff --git a/src/full/Agda/Utils/Cluster.hs b/src/full/Agda/Utils/Cluster.hs --- a/src/full/Agda/Utils/Cluster.hs +++ b/src/full/Agda/Utils/Cluster.hs @@ -1,3 +1,4 @@ +{-# LANGUAGE CPP #-} -- | Create clusters of non-overlapping things. @@ -10,37 +11,39 @@ import Control.Monad -- An imperative union-find library: -import Data.Equivalence.Monad (runEquivM, equateAll, classDesc) +import Data.Equivalence.Monad (runEquivT, equateAll, classDesc) +import Data.List.NonEmpty (NonEmpty(..)) +import qualified Data.List.NonEmpty as NonEmpty -import Data.Char -import Data.Functor import qualified Data.IntMap as IntMap +#if __GLASGOW_HASKELL__ < 804 import Data.Semigroup +#endif import Agda.Utils.Functor -import Agda.Utils.NonemptyList import Agda.Utils.Singleton +import Agda.Utils.Fail -- | Characteristic identifiers. type C = Int --- | Given a function @f :: a -> NonemptyList C@ which returns a non-empty list of +-- | Given a function @f :: a -> NonEmpty C@ which returns a non-empty list of -- characteristics @C@ of @a@, partition a list of @a@s into groups -- such that each element in a group shares at least one characteristic -- with at least one other element of the group. -cluster :: (a -> NonemptyList C) -> [a] -> [NonemptyList a] +cluster :: (a -> NonEmpty C) -> [a] -> [NonEmpty a] cluster f as = cluster' $ map (\ a -> (a, f a)) as -- | Partition a list of @a@s paired with a non-empty list of -- characteristics @C@ into groups -- such that each element in a group shares at least one characteristic -- with at least one other element of the group. -cluster' :: [(a, NonemptyList C)] -> [NonemptyList a] -cluster' acs = runEquivM id const $ do +cluster' :: [(a, NonEmpty C)] -> [NonEmpty a] +cluster' acs = runFail_ $ runEquivT id const $ do -- Construct the equivalence classes of characteristics. - forM_ acs $ \ (_, c :! cs) -> equateAll $ c:cs + forM_ acs $ \ (_, c :| cs) -> equateAll $ c:cs -- Pair each element with its class. - cas <- forM acs $ \ (a, c :! _) -> classDesc c <&> \ k -> IntMap.singleton k (singleton a) + cas <- forM acs $ \ (a, c :| _) -> classDesc c <&> \ k -> IntMap.singleton k (singleton a) -- Create a map from class to elements. let m = IntMap.unionsWith (<>) cas -- Return the values of the map diff --git a/src/full/Agda/Utils/Either.hs b/src/full/Agda/Utils/Either.hs --- a/src/full/Agda/Utils/Either.hs +++ b/src/full/Agda/Utils/Either.hs @@ -2,8 +2,31 @@ -- | Utilities for the 'Either' type. ------------------------------------------------------------------------ -module Agda.Utils.Either where +module Agda.Utils.Either + ( whileLeft + , caseEitherM + , mapLeft + , mapRight + , traverseEither + , isLeft + , isRight + , fromLeft + , fromRight + , fromLeftM + , fromRightM + , maybeLeft + , maybeRight + , allLeft + , allRight + , groupByEither + , maybeToEither + ) where +import Data.Bifunctor +import Data.Either (isLeft, isRight) + +import Agda.Utils.List ( listCase ) + -- | Loop while we have an exception. whileLeft :: Monad m => (a -> Either b c) -> (a -> b -> m a) -> (a -> c -> m d) -> a -> m d @@ -18,40 +41,21 @@ caseEitherM :: Monad m => m (Either a b) -> (a -> m c) -> (b -> m c) -> m c caseEitherM mm f g = either f g =<< mm --- | 'Either' is a bifunctor. - -mapEither :: (a -> c) -> (b -> d) -> Either a b -> Either c d -mapEither f g = either (Left . f) (Right . g) - -- | 'Either _ b' is a functor. mapLeft :: (a -> c) -> Either a b -> Either c b -mapLeft f = mapEither f id +mapLeft = first -- | 'Either a' is a functor. mapRight :: (b -> d) -> Either a b -> Either a d -mapRight = mapEither id +mapRight = second -- | 'Either' is bitraversable. - +-- Note: From @base >= 4.10.0.0@ already present in `Data.Bitraversable`. traverseEither :: Functor f => (a -> f c) -> (b -> f d) -> Either a b -> f (Either c d) traverseEither f g = either (fmap Left . f) (fmap Right . g) --- | Returns 'True' iff the argument is @'Right' x@ for some @x@. --- --- Note: from @base >= 4.7.0.0@ already present in @Data.Either@. -isRight :: Either a b -> Bool -isRight (Right _) = True -isRight (Left _) = False - --- | Returns 'True' iff the argument is @'Left' x@ for some @x@. --- --- Note: from @base >= 4.7.0.0@ already present in @Data.Either@. -isLeft :: Either a b -> Bool -isLeft (Right _) = False -isLeft (Left _) = True - -- | Analogue of 'Data.Maybe.fromMaybe'. fromLeft :: (b -> a) -> Either a b -> a fromLeft = either id @@ -102,6 +106,21 @@ allRight :: [Either a b] -> Maybe [b] allRight = mapM maybeRight + +-- | Groups a list into alternating chunks of 'Left' and 'Right' values +groupByEither :: forall a b. [Either a b] -> [Either [a] [b]] +groupByEither = listCase [] (go . init) where + + go :: Either [a] [b] -> [Either a b] -> [Either [a] [b]] + go acc [] = adjust acc : [] + -- match: next value can be tacked onto the accumulator + go (Left acc) (Left a : abs) = go (Left $ a : acc) abs + go (Right acc) (Right b : abs) = go (Right $ b : acc) abs + -- mismatch: switch the accumulator to the other mode + go acc (ab : abs) = adjust acc : go (init ab) abs + + adjust = bimap reverse reverse + init = bimap pure pure -- | Convert 'Maybe' to @'Either' ()@. maybeToEither :: Maybe a -> Either () a diff --git a/src/full/Agda/Utils/Empty.hs b/src/full/Agda/Utils/Empty.hs --- a/src/full/Agda/Utils/Empty.hs +++ b/src/full/Agda/Utils/Empty.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE DeriveDataTypeable #-} -- | An empty type with some useful instances. @@ -11,7 +10,6 @@ import Agda.Utils.Impossible -#include "undefined.h" data Empty deriving instance Data Empty diff --git a/src/full/Agda/Utils/Fail.hs b/src/full/Agda/Utils/Fail.hs new file mode 100644 --- /dev/null +++ b/src/full/Agda/Utils/Fail.hs @@ -0,0 +1,15 @@ +-- | A pure MonadFail. +{-# LANGUAGE GeneralizedNewtypeDeriving #-} +module Agda.Utils.Fail where + +import Control.Monad.Fail + +newtype Fail a = Fail { runFail :: Either String a } + deriving (Functor, Applicative, Monad) + +instance MonadFail Fail where + fail = Fail . Left + +runFail_ :: Fail a -> a +runFail_ = either error id . runFail + diff --git a/src/full/Agda/Utils/Favorites.hs b/src/full/Agda/Utils/Favorites.hs --- a/src/full/Agda/Utils/Favorites.hs +++ b/src/full/Agda/Utils/Favorites.hs @@ -1,3 +1,4 @@ +{-# LANGUAGE CPP #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} -- | Maintaining a list of favorites of some partially ordered type. @@ -14,8 +15,9 @@ import Prelude hiding ( null ) import Data.Foldable (Foldable) -import Data.Functor +#if __GLASGOW_HASKELL__ < 804 import Data.Semigroup +#endif import qualified Data.List as List import qualified Data.Set as Set diff --git a/src/full/Agda/Utils/FileName.hs b/src/full/Agda/Utils/FileName.hs --- a/src/full/Agda/Utils/FileName.hs +++ b/src/full/Agda/Utils/FileName.hs @@ -19,6 +19,7 @@ #ifdef mingw32_HOST_OS import Control.Exception (bracket) import System.Win32 (findFirstFile, findClose, getFindDataFileName) +import Agda.Utils.Monad #endif import Data.Text (Text) @@ -27,10 +28,8 @@ import Data.Hashable (Hashable) import Data.Data (Data) -import Agda.Utils.Monad import Agda.Utils.Pretty -#include "undefined.h" import Agda.Utils.Impossible -- | Paths which are known to be absolute. @@ -72,9 +71,10 @@ rootPath = [pathSeparator] #endif --- | maps @/bla/bla/bla/foo.bar.xxx@ to @foo.bar@. -rootName :: AbsolutePath -> String -rootName = dropExtension . snd . splitFileName . filePath +-- UNUSED Linag-Ting Chen 2019-07-16 +---- | maps @/bla/bla/bla/foo.bar.xxx@ to @foo.bar@. +--rootName :: AbsolutePath -> String +--rootName = dropExtension . snd . splitFileName . filePath -- | Makes the path absolute. -- @@ -118,5 +118,5 @@ bracket (findFirstFile f) (findClose . fst) $ fmap (takeFileName f ==) . getFindDataFileName . snd #else -doesFileExistCaseSensitive f = doesFileExist f +doesFileExistCaseSensitive = doesFileExist #endif diff --git a/src/full/Agda/Utils/Float.hs b/src/full/Agda/Utils/Float.hs --- a/src/full/Agda/Utils/Float.hs +++ b/src/full/Agda/Utils/Float.hs @@ -1,10 +1,43 @@ +{-# LANGUAGE CPP #-} + -- | Logically consistent comparison of floating point numbers. -module Agda.Utils.Float where +module Agda.Utils.Float + ( normaliseNaN + , doubleToWord64 + , floatEq + , floatLt + , toStringWithoutDotZero + ) where -import Numeric.IEEE ( IEEE(identicalIEEE) ) +import Data.Maybe ( fromMaybe ) +import Data.Word +import Numeric.IEEE ( IEEE(identicalIEEE, nan) ) +#if __GLASGOW_HASKELL__ >= 804 +import GHC.Float ( castDoubleToWord64 ) +#else +import System.IO.Unsafe ( unsafePerformIO ) +import qualified Foreign as F +#endif +import Agda.Utils.List ( stripSuffix ) + +#if __GLASGOW_HASKELL__ < 804 +castDoubleToWord64 :: Double -> Word64 +castDoubleToWord64 float = unsafePerformIO $ F.alloca $ \buf -> do + F.poke (F.castPtr buf) float + F.peek buf +#endif + +normaliseNaN :: Double -> Double +normaliseNaN x + | isNaN x = nan + | otherwise = x + +doubleToWord64 :: Double -> Word64 +doubleToWord64 = castDoubleToWord64 . normaliseNaN + floatEq :: Double -> Double -> Bool -floatEq x y = identicalIEEE x y || (isNaN x && isNaN y) +floatEq x y = identicalIEEE x y || (isNaN x && isNaN y) floatLt :: Double -> Double -> Bool floatLt x y = @@ -24,3 +57,8 @@ | otherwise = compare (x, isNegZero y) (y, isNegZero x) isNegInf z = z < 0 && isInfinite z isNegZero z = identicalIEEE z (-0.0) + +-- | Remove suffix @.0@ from printed floating point number. +toStringWithoutDotZero :: Double -> String +toStringWithoutDotZero d = fromMaybe s $ stripSuffix ".0" s + where s = show d diff --git a/src/full/Agda/Utils/Function.hs b/src/full/Agda/Utils/Function.hs --- a/src/full/Agda/Utils/Function.hs +++ b/src/full/Agda/Utils/Function.hs @@ -96,7 +96,7 @@ -- The applications are calculated strictly. iterate' :: Integral i => i -> (a -> a) -> a -> a -iterate' 0 f x = x +iterate' 0 _ x = x iterate' n f x | n > 0 = iterate' (n - 1) f $! f x | otherwise = error "iterate': Negative input." diff --git a/src/full/Agda/Utils/Functor.hs b/src/full/Agda/Utils/Functor.hs --- a/src/full/Agda/Utils/Functor.hs +++ b/src/full/Agda/Utils/Functor.hs @@ -1,24 +1,29 @@ -{-# LANGUAGE CPP #-} - -- | Utilities for functors. module Agda.Utils.Functor - ( module Agda.Utils.Functor - , (<$>) -- from Data.Functor - , ($>) -- from Data.Functor -#if MIN_VERSION_base(4,11,0) - , (<&>) -- from Data.Functor -#endif + ( (<.>) + , for + , Decoration(traverseF, distributeF) + , dmap + , dget + -- From Data.Functor: + , (<$>) + , ($>) + -- Defined identically as in Data.Functor. + -- Should be simply re-exported (vs redefined) once + -- MIN_VERSION_base >= 4.11.0.0 + -- At time of this writing, we support 4.9.0.0. + , (<&>) ) where import Control.Applicative ( Const(Const), getConst ) -import Data.Functor +import Data.Functor ((<$>), ($>)) import Data.Functor.Identity import Data.Functor.Compose -import Data.Functor.Classes + infixr 9 <.> -- | Composition: pure function after functorial (monadic) function. @@ -28,15 +33,15 @@ -- | The true pure @for@ loop. -- 'Data.Traversable.for' is a misnomer, it should be @forA@. for :: Functor m => m a -> (a -> b) -> m b -for = flip fmap +for a b = fmap b a +{-# INLINE for #-} -#if !MIN_VERSION_base(4,11,0) infixl 1 <&> -- | Infix version of 'for'. (<&>) :: Functor m => m a -> (a -> b) -> m b -(<&>) = for -#endif +(<&>) a b = fmap b a +{-# INLINE (<&>) #-} -- | A decoration is a functor that is traversable into any functor. -- diff --git a/src/full/Agda/Utils/Graph/AdjacencyMap/Unidirectional.hs b/src/full/Agda/Utils/Graph/AdjacencyMap/Unidirectional.hs --- a/src/full/Agda/Utils/Graph/AdjacencyMap/Unidirectional.hs +++ b/src/full/Agda/Utils/Graph/AdjacencyMap/Unidirectional.hs @@ -1,6 +1,4 @@ {-# LANGUAGE BangPatterns #-} -{-# LANGUAGE CPP #-} -{-# LANGUAGE GeneralizedNewtypeDeriving #-} -- | Directed graphs (can of course simulate undirected graphs). -- @@ -64,22 +62,18 @@ -- * Transitive closure , gaussJordanFloydWarshallMcNaughtonYamada , gaussJordanFloydWarshallMcNaughtonYamadaReference + , transitiveClosure , complete, completeIter ) where -#if MIN_VERSION_base(4,11,0) -import Prelude hiding ( (<>), lookup, null, unzip ) -#else import Prelude hiding ( lookup, null, unzip ) -#endif -import Control.Applicative hiding (empty) -import Control.Monad + + import qualified Data.Array.IArray as Array -import qualified Data.Edison.Seq.BankersQueue as BQ -import qualified Data.Edison.Seq.SimpleQueue as SQ +import qualified Data.Sequence as Seq import Data.Function import qualified Data.Graph as Graph import Data.IntMap.Strict (IntMap) @@ -88,24 +82,21 @@ import qualified Data.List as List import qualified Data.Map.Strict as Map import Data.Map.Strict (Map) -import qualified Data.Maybe as Maybe +import Data.Foldable (toList) + import Data.Maybe (maybeToList, fromMaybe) import qualified Data.Set as Set import Data.Set (Set) import qualified Data.Tree as Tree import Agda.Utils.Function -import Agda.Utils.Functor -import Agda.Utils.List (headMaybe) + import Agda.Utils.Null (Null(null)) import qualified Agda.Utils.Null as Null import Agda.Utils.Pretty import Agda.Utils.SemiRing -import Agda.Utils.Singleton (Singleton) -import qualified Agda.Utils.Singleton as Singleton import Agda.Utils.Tuple -#include "undefined.h" import Agda.Utils.Impossible ------------------------------------------------------------------------ @@ -147,7 +138,7 @@ Set.isSubsetOf (targetNodes g) (nodes g) instance (Ord n, Pretty n, Pretty e) => Pretty (Graph n e) where - pretty g = vcat (concat $ map pretty' (Set.toAscList (nodes g))) + pretty g = vcat (concatMap pretty' (Set.toAscList (nodes g))) where pretty' n = case edgesFrom g [n] of [] -> [pretty n] @@ -171,7 +162,7 @@ instance (Pretty n, Pretty e) => Pretty (Edge n e) where pretty (Edge s t e) = - pretty s <+> "--(" <> pretty e <> ")-->" <+> pretty t + pretty s <+> ("--(" <> pretty e <> ")-->") <+> pretty t ------------------------------------------------------------------------ -- Queries @@ -556,7 +547,7 @@ && all isAcyclic (Graph.scc (dagGraph g)) where - isAcyclic (Tree.Node r []) = not (r `elem` (dagGraph g Array.! r)) + isAcyclic (Tree.Node r []) = r `notElem` (dagGraph g Array.! r) isAcyclic _ = False -- | The opposite DAG. @@ -572,13 +563,9 @@ Graph.CyclicSCC (n : _) -> reachable' n Graph.CyclicSCC [] -> __IMPOSSIBLE__ where - lookup' g k = case IntMap.lookup k g of - Nothing -> __IMPOSSIBLE__ - Just x -> x + lookup' g k = fromMaybe __IMPOSSIBLE__ (IntMap.lookup k g) - lookup'' g k = case Map.lookup k g of - Nothing -> __IMPOSSIBLE__ - Just x -> x + lookup'' g k = fromMaybe __IMPOSSIBLE__ (Map.lookup k g) reachable' n = concatMap (Graph.flattenSCC . lookup' (dagComponentMap g)) $ @@ -610,9 +597,7 @@ IntSet.toList $ IntSet.fromList [ j | e <- edgesFrom g ns - , let j = case Map.lookup (target e) firstNodeMap of - Nothing -> __IMPOSSIBLE__ - Just j -> j + , let j = fromMaybe __IMPOSSIBLE__ (Map.lookup (target e) firstNodeMap) , j /= i ] @@ -623,9 +608,7 @@ ] convertInt :: Int -> Graph.Vertex - convertInt i = case toVertex i of - Nothing -> __IMPOSSIBLE__ - Just i -> i + convertInt i = fromMaybe __IMPOSSIBLE__ (toVertex i) componentMap :: IntMap (Graph.SCC n) componentMap = IntMap.fromList (map (mapFst convertInt) components) @@ -675,19 +658,19 @@ reachableFromInternal :: Ord n => Graph n e -> Set n -> Map n (Int, [Edge n e]) reachableFromInternal g ns = - bfs (SQ.fromList (map (, BQ.empty) (Set.toList ns))) Map.empty + bfs (Seq.fromList (map (, Seq.empty) (toList ns))) Map.empty where - bfs !q !map = case SQ.lview q of - Nothing -> map - Just ((u, p), q) -> + bfs !q !map = case Seq.viewl q of + Seq.EmptyL -> map + (u, p) Seq.:< q -> if u `Map.member` map then bfs q map - else bfs (foldr SQ.rcons q - [ (v, BQ.rcons (Edge u v e) p) + else bfs (foldr (flip (Seq.|>)) q + [ (v, p Seq.|> Edge u v e) | (v, e) <- neighbours u g ]) - (let n = BQ.size p in - n `seq` Map.insert u (n, BQ.toList p) map) + (let n = Seq.length p in + n `seq` Map.insert u (n, toList p) map) -- | @walkSatisfying every some g from to@ determines if there is a -- walk from @from@ to @to@ in @g@, in which every edge satisfies the @@ -879,6 +862,11 @@ where starTimes = otimes (ostar (lookup' k k)) - lookup' s t = case lookup s t g of - Nothing -> ozero - Just e -> e + lookup' s t = fromMaybe ozero (lookup s t g) + +-- | The transitive closure. Using 'gaussJordanFloydWarshallMcNaughtonYamada'. +-- NOTE: DO NOT USE () AS EDGE LABEL SINCE THIS MEANS EVERY EDGE IS CONSIDERED A ZERO EDGE AND NO +-- NEW EDGES WILL BE ADDED! Use 'Maybe ()' instead. +transitiveClosure :: (Ord n, Eq e, StarSemiRing e) => Graph n e -> Graph n e +transitiveClosure = fst . gaussJordanFloydWarshallMcNaughtonYamada + diff --git a/src/full/Agda/Utils/Graph/TopSort.hs b/src/full/Agda/Utils/Graph/TopSort.hs --- a/src/full/Agda/Utils/Graph/TopSort.hs +++ b/src/full/Agda/Utils/Graph/TopSort.hs @@ -8,7 +8,11 @@ import Data.Function import qualified Data.Set as Set import qualified Data.Map as Map +import qualified Data.Graph as Graph import Control.Arrow +import Agda.Utils.List (nubOn) +import Agda.Utils.SemiRing +import qualified Agda.Utils.Graph.AdjacencyMap.Unidirectional as G mergeBy :: (a -> a -> Bool) -> [a] -> [a] -> [a] mergeBy _ [] xs = xs @@ -20,22 +24,30 @@ -- | topoligical sort with smallest-numbered available vertex first -- | input: nodes, edges -- | output is Nothing if the graph is not a DAG +-- Note: should be stable to preserve order of generalizable variables. Algorithm due to Richard +-- Eisenberg, and works by walking over the list left-to-right and moving each node the minimum +-- distance left to guarantee topological ordering. topSort :: Ord n => [n] -> [(n, n)] -> Maybe [n] -topSort nodes edges = mergeBy (<) nodes' <$> g m is +topSort nodes edges = go [] nodes where - g m [] - | Map.null m = Just [] - | otherwise = Nothing - g m ((n, Set.toList -> cs): ns) - = (n:) <$> g m' (mergeBy ((<) `on` fst) ns [(c, s) | c<-cs, (0, s) <- maybeToList $ Map.lookup c m']) - where - m' = foldr (Map.adjust $ first (+(-1))) (Map.delete n m) cs + -- #4253: The input edges do not necessarily include transitive dependencies, so take transitive + -- closure before sorting. + w = Just () -- () is not a good edge label since it counts as a "zero" edge and will be ignored + g = G.transitiveClosure $ G.fromNodes nodes `G.union` G.fromEdges [G.Edge a b w | (a, b) <- edges] + deps a = Map.keysSet $ G.graph g Map.! a - is = map (second snd) . filter ((==0) . fst . snd) $ Map.toList m + -- acc: Already sorted nodes in reverse order paired with accumulated set of nodes that must + -- come before it + go acc [] = Just $ reverse $ map fst acc + go acc (n : ns) = (`go` ns) =<< insert n acc - nodes' = Set.toList $ Set.fromList nodes `Set.difference` Set.fromList (concatMap (\(a,b)->[a,b]) edges) + insert a [] = Just [(a, deps a)] + insert a bs0@((b, before_b) : bs) + | before && after = Nothing + | before = ((b, Set.union before_a before_b) :) <$> insert a bs -- a must come before b + | otherwise = Just $ (a, Set.union before_a before_b) : bs0 + where + before_a = deps a + before = Set.member a before_b + after = Set.member b before_a - m = foldr f mempty $ nub edges - f (b, a) - = Map.alter (Just . maybe (1, mempty) (first (+1))) b - . Map.alter (Just . maybe (0, Set.singleton b) (second $ Set.insert b)) a diff --git a/src/full/Agda/Utils/Hash.hs b/src/full/Agda/Utils/Hash.hs --- a/src/full/Agda/Utils/Hash.hs +++ b/src/full/Agda/Utils/Hash.hs @@ -22,9 +22,7 @@ hashByteString = H.asWord64 . B.foldl' (\h b -> H.combine h (H.hashWord8 b)) (H.hashWord8 0) hashTextFile :: AbsolutePath -> IO Hash -hashTextFile file = do - s <- readTextFile (filePath file) - return $ hashText s +hashTextFile file = hashText <$> readTextFile (filePath file) -- | Hashes a piece of 'Text'. diff --git a/src/full/Agda/Utils/HashMap.hs b/src/full/Agda/Utils/HashMap.hs deleted file mode 100644 --- a/src/full/Agda/Utils/HashMap.hs +++ /dev/null @@ -1,14 +0,0 @@ -module Agda.Utils.HashMap - ( module HashMap - ) where - -import Data.HashMap.Strict as HashMap - --- ASR (20 January 2016) Issue 1779: I removed the @mapMaybe@ and --- @alter@ functions because them currently aren't used and --- them were added in unordered-containers 0.2.6.0. - --- mapMaybe :: (a -> Maybe b) -> HashMap k a -> HashMap k b - --- alter :: (Eq k, Hashable k) => --- (Maybe a -> Maybe a) -> k -> HashMap k a -> HashMap k a diff --git a/src/full/Agda/Utils/IO/Directory.hs b/src/full/Agda/Utils/IO/Directory.hs --- a/src/full/Agda/Utils/IO/Directory.hs +++ b/src/full/Agda/Utils/IO/Directory.hs @@ -10,9 +10,9 @@ import System.FilePath import Data.ByteString as BS -import Paths_Agda -import Agda.Utils.Functor + + -- | @copyDirContent src dest@ recursively copies directory @src@ onto @dest@. -- diff --git a/src/full/Agda/Utils/IO/TempFile.hs b/src/full/Agda/Utils/IO/TempFile.hs --- a/src/full/Agda/Utils/IO/TempFile.hs +++ b/src/full/Agda/Utils/IO/TempFile.hs @@ -15,5 +15,6 @@ writeToTempFile content = do dir <- D.getTemporaryDirectory E.bracket (IO.openTempFile dir "agda2-mode") (IO.hClose . snd) $ \ (filepath, handle) -> do - UTF8.hPutStr handle content + IO.hSetEncoding handle IO.utf8 + IO.hPutStr handle content return filepath diff --git a/src/full/Agda/Utils/IO/UTF8.hs b/src/full/Agda/Utils/IO/UTF8.hs --- a/src/full/Agda/Utils/IO/UTF8.hs +++ b/src/full/Agda/Utils/IO/UTF8.hs @@ -2,7 +2,6 @@ module Agda.Utils.IO.UTF8 ( readTextFile - , Agda.Utils.IO.UTF8.hPutStr , Agda.Utils.IO.UTF8.writeFile , writeTextToFile ) where @@ -42,24 +41,13 @@ IO.hSetEncoding h IO.utf8 T.hGetContents h --- | Writes UTF8-encoded text to the handle, which should be opened --- for writing and in text mode. The native convention for line --- endings is used. --- --- The handle's text encoding is not necessarily preserved, it is --- changed to UTF8. - -hPutStr :: IO.Handle -> String -> IO () -hPutStr h s = do - IO.hSetEncoding h IO.utf8 - IO.hPutStr h s - -- | Writes a UTF8-encoded text file. The native convention for line -- endings is used. writeFile :: FilePath -> String -> IO () writeFile file s = IO.withFile file IO.WriteMode $ \h -> do - hPutStr h s + IO.hSetEncoding h IO.utf8 + IO.hPutStr h s -- | Writes a UTF8-encoded text file. The native convention for line -- endings is used. diff --git a/src/full/Agda/Utils/IORef.hs b/src/full/Agda/Utils/IORef.hs --- a/src/full/Agda/Utils/IORef.hs +++ b/src/full/Agda/Utils/IORef.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} -- | Utilities for Data.IORef. diff --git a/src/full/Agda/Utils/Impossible.hs b/src/full/Agda/Utils/Impossible.hs --- a/src/full/Agda/Utils/Impossible.hs +++ b/src/full/Agda/Utils/Impossible.hs @@ -2,11 +2,13 @@ -- | An interface for reporting \"impossible\" errors ------------------------------------------------------------------------ -{-# LANGUAGE DeriveDataTypeable #-} module Agda.Utils.Impossible where -import Control.Exception as E +import Control.Exception (Exception(..), throw, catchJust) +import GHC.Stack + (CallStack, HasCallStack, callStack, getCallStack, freezeCallStack + , srcLocModule, srcLocFile, srcLocStartLine) -- | \"Impossible\" errors, annotated with a file name and a line -- number corresponding to the source code location of the error. @@ -24,7 +26,7 @@ | ImpMissingDefinitions [String] String -- ^ We reached a program point without all the required -- primitives or BUILTIN to proceed forward. - -- @MissingDefinitions needed forthis@ + -- @ImpMissingDefinitions neededDefs forThis@ instance Show Impossible where show (Impossible file line) = unlines @@ -42,12 +44,61 @@ instance Exception Impossible -- | Abort by throwing an \"impossible\" error. You should not use --- this function directly. Instead use the macro in @undefined.h@. +-- this function directly. Instead use __IMPOSSIBLE__ throwImpossible :: Impossible -> a throwImpossible = throw --- | Catch an \"impossible\" error, if possible. +-- | Monads in which we can catch an \"impossible\" error, if possible. -catchImpossible :: IO a -> (Impossible -> IO a) -> IO a -catchImpossible = E.catch +class CatchImpossible m where + + -- | Catch any 'Impossible' exception. + catchImpossible :: m a -> (Impossible -> m a) -> m a + catchImpossible = catchImpossibleJust Just + + -- | Catch only 'Impossible' exceptions selected by the filter. + catchImpossibleJust :: (Impossible -> Maybe b) -> m a -> (b -> m a) -> m a + catchImpossibleJust = flip . handleImpossibleJust + + -- | Version of 'catchImpossible' with argument order suiting short handlers. + handleImpossible :: (Impossible -> m a) -> m a -> m a + handleImpossible = flip catchImpossible + + -- | Version of 'catchImpossibleJust' with argument order suiting short handlers. + handleImpossibleJust :: (Impossible -> Maybe b) -> (b -> m a) -> m a -> m a + handleImpossibleJust = flip . catchImpossibleJust + + {-# MINIMAL catchImpossibleJust | handleImpossibleJust #-} + +instance CatchImpossible IO where + catchImpossibleJust = catchJust + +-- | Create something with a callstack's file and line number + +withFileAndLine' :: Integral a => CallStack -> (String -> a -> b) -> b +withFileAndLine' cs ctor = ctor file line + where + callSiteList = getCallStack cs + notHere (_, loc) = srcLocModule loc /= "Agda.Utils.Impossible" + stackLocations = filter notHere callSiteList + (file, line) = case stackLocations of + (_, loc) : _ -> (srcLocFile loc, fromIntegral (srcLocStartLine loc)) + [] -> ("?", -1) + +-- | Create something with the call site's file and line number + +withFileAndLine :: (HasCallStack, Integral a) => (String -> a -> b) -> b +withFileAndLine = withFileAndLine' (freezeCallStack callStack) + +-- | Throw an "Impossible" error reporting the *caller's* call site. + +__IMPOSSIBLE__ :: HasCallStack => a +__IMPOSSIBLE__ = throwImpossible (withFileAndLine Impossible) + +-- | Throw an "Unreachable" error reporting the *caller's* call site. +-- Note that this call to "withFileAndLine" will be filtered out +-- due its filter on the srcLocModule. + +__UNREACHABLE__ :: HasCallStack => a +__UNREACHABLE__ = throwImpossible (withFileAndLine Unreachable) diff --git a/src/full/Agda/Utils/IndexedList.hs b/src/full/Agda/Utils/IndexedList.hs --- a/src/full/Agda/Utils/IndexedList.hs +++ b/src/full/Agda/Utils/IndexedList.hs @@ -1,14 +1,15 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE PolyKinds #-} {-# LANGUAGE TypeOperators #-} +{-# LANGUAGE DataKinds #-} module Agda.Utils.IndexedList where +import Data.Kind ( Type ) import Agda.Utils.Lens -- | Existential wrapper for indexed types. -data Some :: (k -> *) -> * where +data Some :: (k -> Type) -> Type where Some :: f i -> Some f -- | Unpacking a wrapped value. @@ -17,7 +18,7 @@ -- | Lists indexed by a type-level list. A value of type @All p [x₁..xₙ]@ is a -- sequence of values of types @p x₁@, .., @p xₙ@. -data All :: (x -> *) -> [x] -> * where +data All :: (x -> Type) -> [x] -> Type where Nil :: All p '[] Cons :: p x -> All p xs -> All p (x ': xs) @@ -34,7 +35,7 @@ forgetAll f (Cons x xs) = f x : forgetAll f xs -- | An index into a type-level list. -data Index :: [x] -> x -> * where +data Index :: [x] -> x -> Type where Zero :: Index (x ': xs) x Suc :: Index xs x -> Index (y ': xs) x @@ -52,9 +53,6 @@ lIndex :: Index xs x -> Lens' (p x) (All p xs) lIndex Zero f (Cons x xs) = f x <&> \ x -> Cons x xs lIndex (Suc i) f (Cons x xs) = lIndex i f xs <&> \ xs -> Cons x xs -#if __GLASGOW_HASKELL__ < 800 -lIndex _ _ Nil = error "-fwarn-incomplete-pattern deficiency" -#endif -- | Looking up an element in an indexed list. lookupIndex :: All p xs -> Index xs x -> p x @@ -64,9 +62,6 @@ ix :: Index xs x -> All p xs -> p x ix Zero (Cons x xs) = x ix (Suc i) (Cons x xs) = ix i xs -#if __GLASGOW_HASKELL__ < 800 - ix _ Nil = error "-fwarn-incomplete-pattern deficiency" -#endif -- | All indices into an indexed list. allIndices :: All p xs -> All (Index xs) xs diff --git a/src/full/Agda/Utils/IntSet/Infinite.hs b/src/full/Agda/Utils/IntSet/Infinite.hs --- a/src/full/Agda/Utils/IntSet/Infinite.hs +++ b/src/full/Agda/Utils/IntSet/Infinite.hs @@ -1,3 +1,4 @@ +{-# LANGUAGE CPP #-} -- | Possibly infinite sets of integers (but with finitely many consecutive -- segments). Used for checking guard coverage in int/nat cases in the -- treeless compiler. @@ -8,9 +9,10 @@ , invariant ) where -import Control.Arrow (first, second) +#if __GLASGOW_HASKELL__ < 804 import Data.Semigroup hiding (All(..)) -import Data.List +#endif + import Data.Set (Set) import qualified Data.Set as Set @@ -39,7 +41,7 @@ below' :: Integer -> IntSet -> IntSet below' _ All = All below' lo r@(Some xs) - | elem lo xs = below' (lo + 1) r + | lo `Set.member` xs = below' (lo + 1) r | otherwise = Below lo $ Some $ Set.filter (>= lo) xs below' lo r0@(Below lo' r) | lo' >= lo = r0 @@ -51,7 +53,7 @@ above' :: Integer -> IntSet -> IntSet above' _ All = All above' hi r@(Some xs) - | elem (hi - 1) xs = above' (hi - 1) r + | (hi - 1) `Set.member` xs = above' (hi - 1) r | otherwise = Above hi $ Some $ Set.filter (< hi) xs above' hi r0@(Above hi' r) | hi' <= hi = r0 @@ -65,10 +67,10 @@ some' xs (Some ys) = Some (Set.union xs ys) some' _ All = All some' xs (Below lo r) - | elem lo xs = some' xs (Below (lo + 1) r) + | lo `Set.member` xs = some' xs (Below (lo + 1) r) | otherwise = below' lo $ some' (Set.filter (>= lo) xs) r some' xs (Above hi r) - | elem (hi - 1) xs = some' xs (Above (hi - 1) r) + | (hi - 1) `Set.member` xs = some' xs (Above (hi - 1) r) | otherwise = above' hi $ some' (Set.filter (< hi) xs) r difference :: IntSet -> IntSet -> IntSet diff --git a/src/full/Agda/Utils/Lens.hs b/src/full/Agda/Utils/Lens.hs --- a/src/full/Agda/Utils/Lens.hs +++ b/src/full/Agda/Utils/Lens.hs @@ -1,5 +1,4 @@ {-# LANGUAGE BangPatterns #-} -{-# LANGUAGE CPP #-} -- | A cut-down implementation of lenses, with names taken from -- Edward Kmett's lens package. diff --git a/src/full/Agda/Utils/List.hs b/src/full/Agda/Utils/List.hs --- a/src/full/Agda/Utils/List.hs +++ b/src/full/Agda/Utils/List.hs @@ -1,11 +1,11 @@ -{-# LANGUAGE ScopedTypeVariables #-} - -- | Utility functions for lists. module Agda.Utils.List where -import Control.Arrow (first) +import Control.Arrow (first, second) +import Data.Array (Array, array, listArray) +import qualified Data.Array as Array import Data.Functor ((<$>)) import Data.Function import qualified Data.List as List @@ -13,57 +13,66 @@ import qualified Data.Map as Map import qualified Data.Set as Set -import Text.Show.Functions () - import qualified Agda.Utils.Bag as Bag - +import Agda.Utils.Function (applyWhen) import Agda.Utils.Tuple +--------------------------------------------------------------------------- +-- * Variants of list case, cons, head, tail, init, last +--------------------------------------------------------------------------- + -- | Append a single element at the end. -- Time: O(length); use only on small lists. snoc :: [a] -> a -> [a] snoc xs x = xs ++ [x] -- | Case distinction for lists, with list first. +-- O(1). +-- -- Cf. 'Agda.Utils.Null.ifNull'. caseList :: [a] -> b -> (a -> [a] -> b) -> b caseList xs n c = listCase n c xs -- | Case distinction for lists, with list first. +-- O(1). +-- -- Cf. 'Agda.Utils.Null.ifNull'. caseListM :: Monad m => m [a] -> m b -> (a -> [a] -> m b) -> m b caseListM mxs n c = listCase n c =<< mxs -- | Case distinction for lists, with list last. +-- O(1). +-- listCase :: b -> (a -> [a] -> b) -> [a] -> b listCase n c [] = n listCase n c (x:xs) = c x xs --- | Head function (safe). -headMaybe :: [a] -> Maybe a -headMaybe = listToMaybe - -- | Head function (safe). Returns a default value on empty lists. +-- O(1). -- -- > headWithDefault 42 [] = 42 -- > headWithDefault 42 [1,2,3] = 1 headWithDefault :: a -> [a] -> a -headWithDefault def = fromMaybe def . headMaybe +headWithDefault def = fromMaybe def . listToMaybe -- | Tail function (safe). +-- O(1). tailMaybe :: [a] -> Maybe [a] tailMaybe = fmap snd . uncons -- | Tail function (safe). Returns a default list on empty lists. +-- O(1). tailWithDefault :: [a] -> [a] -> [a] tailWithDefault def = fromMaybe def . tailMaybe -- | Last element (safe). +-- O(n). lastMaybe :: [a] -> Maybe a lastMaybe [] = Nothing lastMaybe xs = Just $ last xs -- | Last two elements (safe). +-- O(n). last2 :: [a] -> Maybe (a, a) last2 (x : y : xs) = Just $ loop x y xs where @@ -71,44 +80,45 @@ loop x y (z:xs) = loop y z xs last2 _ = Nothing --- | Drop from the end of a list. --- @dropEnd n = reverse . drop n . reverse@ --- (Forces the whole list even for @n==0@.) -dropEnd :: forall a. Int -> [a] -> [a] -dropEnd n = snd . foldr f (n, []) - where - f :: a -> (Int, [a]) -> (Int, [a]) - f x (n, xs) - | n <= 0 = (0, x:xs) - | otherwise = (n-1, xs) - -- | Opposite of cons @(:)@, safe. +-- O(1). uncons :: [a] -> Maybe (a, [a]) uncons [] = Nothing uncons (x:xs) = Just (x,xs) --- | Maybe cons. @mcons ma as = maybeToList ma ++ as@ +-- | Maybe cons. +-- O(1). +-- @mcons ma as = maybeToList ma ++ as@ mcons :: Maybe a -> [a] -> [a] mcons ma as = maybe as (:as) ma -- | 'init' and 'last' in one go, safe. +-- O(n). initLast :: [a] -> Maybe ([a],a) initLast [] = Nothing initLast (a:as) = Just $ loop a as where loop a [] = ([], a) loop a (b : bs) = mapFst (a:) $ loop b bs --- | init, safe. +-- | @init@, safe. +-- O(n). initMaybe :: [a] -> Maybe [a] initMaybe = fmap fst . initLast +--------------------------------------------------------------------------- +-- * Lookup and indexing +--------------------------------------------------------------------------- + -- | Lookup function (partially safe). +-- O(min n index). (!!!) :: [a] -> Int -> Maybe a [] !!! _ = Nothing (x : _) !!! 0 = Just x (_ : xs) !!! n = xs !!! (n - 1) -- | Lookup function with default value for index out of range. +-- O(min n index). +-- -- The name is chosen akin to 'Data.List.genericIndex'. indexWithDefault :: a -> [a] -> Int -> a indexWithDefault a [] _ = a @@ -116,51 +126,91 @@ indexWithDefault a (_ : xs) n = indexWithDefault a xs (n - 1) -- | Find an element satisfying a predicate and return it with its index. +-- O(n) in the worst case, e.g. @findWithIndex f xs = Nothing@. +-- -- TODO: more efficient implementation!? findWithIndex :: (a -> Bool) -> [a] -> Maybe (a, Int) -findWithIndex p as = headMaybe $ filter (p . fst) $ zip as [0..] +findWithIndex p as = listToMaybe $ filter (p . fst) $ zip as [0..] --- | downFrom n = [n-1,..1,0] +-- | A generalised variant of 'elemIndex'. +-- O(n). +genericElemIndex :: (Eq a, Integral i) => a -> [a] -> Maybe i +genericElemIndex x xs = + listToMaybe $ + map fst $ + filter snd $ + zip [0..] $ + map (== x) xs + +-- | @downFrom n = [n-1,..1,0]@. +-- O(n). downFrom :: Integral a => a -> [a] downFrom n | n <= 0 = [] | otherwise = let n' = n-1 in n' : downFrom n' +--------------------------------------------------------------------------- +-- * Update +--------------------------------------------------------------------------- + -- | Update the first element of a list, if it exists. +-- O(1). updateHead :: (a -> a) -> [a] -> [a] -updateHead f [] = [] +updateHead _ [] = [] updateHead f (a : as) = f a : as -- | Update the last element of a list, if it exists. +-- O(n). updateLast :: (a -> a) -> [a] -> [a] -updateLast f [] = [] -updateLast f [a] = [f a] -updateLast f (a : as@(_ : _)) = a : updateLast f as +updateLast _ [] = [] +updateLast f (a : as) = loop a as + -- Using a helper function to minimize the pattern matching. + where + loop a [] = [f a] + loop a (b : bs) = a : loop b bs -- | Update nth element of a list, if it exists. +-- @O(min index n)@. +-- -- Precondition: the index is >= 0. updateAt :: Int -> (a -> a) -> [a] -> [a] -updateAt _ f [] = [] +updateAt _ _ [] = [] updateAt 0 f (a : as) = f a : as updateAt n f (a : as) = a : updateAt (n-1) f as --- | A generalized version of @partition@. --- (Cf. @mapMaybe@ vs. @filter@). -mapEither :: (a -> Either b c) -> [a] -> ([b],[c]) -{-# INLINE mapEither #-} -mapEither f xs = foldr (deal f) ([],[]) xs +--------------------------------------------------------------------------- +-- * Sublist extraction and partitioning +--------------------------------------------------------------------------- -deal :: (a -> Either b c) -> a -> ([b],[c]) -> ([b],[c]) -deal f a ~(bs,cs) = case f a of - Left b -> (b:bs, cs) - Right c -> (bs, c:cs) +type Prefix a = [a] -- ^ The list before the split point. +type Suffix a = [a] -- ^ The list after the split point. +-- | @splitExactlyAt n xs = Just (ys, zs)@ iff @xs = ys ++ zs@ +-- and @genericLength ys = n@. +splitExactlyAt :: Integral n => n -> [a] -> Maybe (Prefix a, Suffix a) +splitExactlyAt 0 xs = return ([], xs) +splitExactlyAt n [] = Nothing +splitExactlyAt n (x : xs) = mapFst (x :) <$> splitExactlyAt (n-1) xs + +-- | Drop from the end of a list. +-- O(length). +-- +-- @dropEnd n = reverse . drop n . reverse@ +-- +-- Forces the whole list even for @n==0@. +dropEnd :: forall a. Int -> [a] -> Prefix a +dropEnd n = snd . foldr f (n, []) + where + f :: a -> (Int, [a]) -> (Int, [a]) + f x (n, xs) = (n-1, applyWhen (n <= 0) (x:) xs) + -- | Split off the largest suffix whose elements satisfy a predicate. +-- O(n). -- -- @spanEnd p xs = (ys, zs)@ -- where @xs = ys ++ zs@ -- and @all p zs@ -- and @maybe True (not . p) (lastMaybe yz)@. -spanEnd :: forall a. (a -> Bool) -> [a] -> ([a], [a]) +spanEnd :: forall a. (a -> Bool) -> [a] -> (Prefix a, Suffix a) spanEnd p = snd . foldr f (True, ([], [])) where f :: a -> (Bool, ([a], [a])) -> (Bool, ([a], [a])) @@ -169,21 +219,29 @@ -- | A generalized version of @takeWhile@. -- (Cf. @mapMaybe@ vs. @filter@). -takeWhileJust :: (a -> Maybe b) -> [a] -> [b] +-- @O(length . takeWhileJust f). +-- +-- @takeWhileJust f = fst . spanJust f@. +takeWhileJust :: (a -> Maybe b) -> [a] -> Prefix b takeWhileJust p = loop where loop (a : as) | Just b <- p a = b : loop as loop _ = [] -- | A generalized version of @span@. -spanJust :: (a -> Maybe b) -> [a] -> ([b], [a]) +-- @O(length . fst . spanJust f)@. +spanJust :: (a -> Maybe b) -> [a] -> (Prefix b, Suffix a) spanJust p = loop where loop (a : as) | Just b <- p a = mapFst (b :) $ loop as loop as = ([], as) -- | Partition a list into 'Nothing's and 'Just's. --- @'mapMaybe' f = snd . partitionMaybe f@. +-- O(n). +-- +-- @partitionMaybe f = partitionEithers . map (\ a -> maybe (Left a) Right (f a))@ +-- +-- Note: @'mapMaybe' f = snd . partitionMaybe f@. partitionMaybe :: (a -> Maybe b) -> [a] -> ([a], [b]) partitionMaybe f = loop where @@ -194,36 +252,54 @@ -- | Like 'filter', but additionally return the last partition -- of the list where the predicate is @False@ everywhere. -filterAndRest :: (a -> Bool) -> [a] -> ([a],[a]) +-- O(n). +filterAndRest :: (a -> Bool) -> [a] -> ([a], Suffix a) filterAndRest p = mapMaybeAndRest $ \ a -> if p a then Just a else Nothing -- | Like 'mapMaybe', but additionally return the last partition -- of the list where the function always returns @Nothing@. -mapMaybeAndRest :: (a -> Maybe b) -> [a] -> ([b],[a]) +-- O(n). +mapMaybeAndRest :: (a -> Maybe b) -> [a] -> ([b], Suffix a) mapMaybeAndRest f = loop [] where loop acc = \case [] -> ([], reverse acc) x:xs | Just y <- f x -> first (y:) $ loop [] xs | otherwise -> loop (x:acc) xs --- | Drops from both lists simultaneously until one list is empty. -dropCommon :: [a] -> [b] -> ([a],[b]) -dropCommon (x : xs) (y : ys) = dropCommon xs ys -dropCommon xs ys = (xs, ys) - -- | Sublist relation. isSublistOf :: Eq a => [a] -> [a] -> Bool -isSublistOf [] ys = True -isSublistOf (x : xs) ys = - case dropWhile (x /=) ys of - [] -> False - (_:ys) -> isSublistOf xs ys +isSublistOf = List.isSubsequenceOf -type Prefix a = [a] -type Suffix a = [a] +-- | All ways of removing one element from a list. +-- O(n²). +holes :: [a] -> [(a, [a])] +holes [] = [] +holes (x:xs) = (x, xs) : map (second (x:)) (holes xs) +--------------------------------------------------------------------------- +-- * Prefix and suffix +--------------------------------------------------------------------------- + +-- ** Prefix + +-- | Compute the common prefix of two lists. +-- O(min n m). +commonPrefix :: Eq a => [a] -> [a] -> Prefix a +commonPrefix [] _ = [] +commonPrefix _ [] = [] +commonPrefix (x:xs) (y:ys) + | x == y = x : commonPrefix xs ys + | otherwise = [] + +-- | Drops from both lists simultaneously until one list is empty. +-- O(min n m). +dropCommon :: [a] -> [b] -> (Suffix a, Suffix b) +dropCommon (x : xs) (y : ys) = dropCommon xs ys +dropCommon xs ys = (xs, ys) + -- | Check if a list has a given prefix. If so, return the list -- minus the prefix. +-- O(length prefix). stripPrefixBy :: (a -> a -> Bool) -> Prefix a -> [a] -> Maybe (Suffix a) stripPrefixBy eq = loop where @@ -233,7 +309,15 @@ | eq p r = loop pat rest | otherwise = Nothing +-- ** Suffix + +-- | Compute the common suffix of two lists. +-- O(n + m). +commonSuffix :: Eq a => [a] -> [a] -> Suffix a +commonSuffix xs ys = reverse $ (commonPrefix `on` reverse) xs ys + -- | @stripSuffix suf xs = Just pre@ iff @xs = pre ++ suf@. +-- O(n). stripSuffix :: Eq a => Suffix a -> [a] -> Maybe (Prefix a) stripSuffix [] = Just stripSuffix s = stripReversedSuffix (reverse s) @@ -241,6 +325,7 @@ type ReversedSuffix a = [a] -- | @stripReversedSuffix rsuf xs = Just pre@ iff @xs = pre ++ reverse suf@. +-- O(n). stripReversedSuffix :: forall a. Eq a => ReversedSuffix a -> [a] -> Maybe (Prefix a) stripReversedSuffix rs = final . foldr step (SSSStrip rs) where @@ -267,8 +352,31 @@ | SSSStrip (ReversedSuffix a) -- ^ "Negative string" to remove from end. List may be empty. | SSSResult [a] -- ^ "Positive string" (result). Non-empty list. +--------------------------------------------------------------------------- +-- * Groups and chunks +--------------------------------------------------------------------------- + +-- | @'groupOn' f = 'groupBy' (('==') \`on\` f) '.' 'List.sortBy' ('compare' \`on\` f)@. +-- O(n log n). +groupOn :: Ord b => (a -> b) -> [a] -> [[a]] +groupOn f = List.groupBy ((==) `on` f) . List.sortBy (compare `on` f) + +-- | A variant of 'List.groupBy' which applies the predicate to consecutive +-- pairs. +-- O(n). +groupBy' :: (a -> a -> Bool) -> [a] -> [[a]] +groupBy' _ [] = [] +groupBy' p xxs@(x : xs) = grp x $ zipWith (\x y -> (p x y, y)) xxs xs + where + grp x ys = (x : map snd xs) : tail + where (xs, rest) = span fst ys + tail = case rest of + [] -> [] + ((_, z) : zs) -> grp z zs + -- | Split a list into sublists. Generalisation of the prelude function -- @words@. +-- O(n). -- -- > words xs == wordsBy isSpace xs wordsBy :: (a -> Bool) -> [a] -> [[a]] @@ -282,6 +390,7 @@ (ys,zs) = break p xs -- | Chop up a list in chunks of a given length. +-- O(n). chop :: Int -> [a] -> [[a]] chop _ [] = [] chop n xs = ys : chop n zs @@ -290,21 +399,36 @@ -- | Chop a list at the positions when the predicate holds. Contrary to -- 'wordsBy', consecutive separator elements will result in an empty segment -- in the result. +-- O(n). +-- -- > intercalate [x] (chopWhen (== x) xs) == xs chopWhen :: (a -> Bool) -> [a] -> [[a]] chopWhen p [] = [] -chopWhen p xs = - case break p xs of +chopWhen p xs = loop xs + where + -- Local function to avoid unnecessary pattern matching. + loop xs = case break p xs of (w, []) -> [w] (w, [_]) -> [w, []] - (w, _ : ys) -> w : chopWhen p ys + (w, _ : ys) -> w : loop ys -- here we already know that ys /= [] --- | All ways of removing one element from a list. -holes :: [a] -> [(a, [a])] -holes [] = [] -holes (x:xs) = (x, xs) : map (id -*- (x:)) (holes xs) +--------------------------------------------------------------------------- +-- * List as sets +--------------------------------------------------------------------------- +-- | Check membership for the same list often. +-- Use partially applied to create membership predicate +-- @hasElem xs :: a -> Bool@. +-- +-- * First time: @O(n log n)@ in the worst case. +-- * Subsequently: @O(log n)@. +-- +-- Specification: @hasElem xs == (`elem` xs)@. +hasElem :: Ord a => [a] -> a -> Bool +hasElem xs = (`Set.member` Set.fromList xs) + -- | Check whether a list is sorted. +-- O(n). -- -- Assumes that the 'Ord' instance implements a partial order. @@ -312,70 +436,113 @@ sorted [] = True sorted xs = and $ zipWith (<=) xs (tail xs) --- | Check whether all elements in a list are distinct from each --- other. Assumes that the 'Eq' instance stands for an equivalence --- relation. +-- | Check whether all elements in a list are distinct from each other. +-- Assumes that the 'Eq' instance stands for an equivalence relation. +-- +-- O(n²) in the worst case @distinct xs == True@. distinct :: Eq a => [a] -> Bool distinct [] = True distinct (x:xs) = x `notElem` xs && distinct xs -- | An optimised version of 'distinct'. +-- O(n log n). -- --- Precondition: The list's length must fit in an 'Int'. +-- Precondition: The list's length must fit in an 'Int'. fastDistinct :: Ord a => [a] -> Bool fastDistinct xs = Set.size (Set.fromList xs) == length xs --- | Checks if all the elements in the list are equal. Assumes that --- the 'Eq' instance stands for an equivalence relation. -allEqual :: Eq a => [a] -> Bool -allEqual [] = True -allEqual (x : xs) = all (== x) xs - -- | Returns an (arbitrary) representative for each list element -- that occurs more than once. +-- O(n log n). duplicates :: Ord a => [a] -> [a] duplicates = mapMaybe dup . Bag.groups . Bag.fromList where dup (a : _ : _) = Just a dup _ = Nothing --- | A variant of 'List.groupBy' which applies the predicate to consecutive --- pairs. +-- | Remove the first representative for each list element. +-- Thus, returns all duplicate copies. +-- O(n log n). +-- +-- @allDuplicates xs == sort $ xs \\ nub xs@. +allDuplicates :: Ord a => [a] -> [a] +allDuplicates = concat . map (drop 1 . reverse) . Bag.groups . Bag.fromList + -- The reverse is necessary to actually remove the *first* occurrence + -- of each element. -groupBy' :: (a -> a -> Bool) -> [a] -> [[a]] -groupBy' _ [] = [] -groupBy' p xxs@(x : xs) = grp x $ zipWith (\x y -> (p x y, y)) xxs xs +-- | Efficient variant of 'nubBy' for lists, using a set to store already seen elements. +-- O(n log n) +-- +-- Specification: +-- +-- > nubOn f xs == 'nubBy' ((==) `'on'` f) xs. + +nubOn :: Ord b => (a -> b) -> [a] -> [a] +nubOn f = loop Set.empty where - grp x ys = (x : map snd xs) : tail - where (xs, rest) = span fst ys - tail = case rest of - [] -> [] - ((_, z) : zs) -> grp z zs + loop s [] = [] + loop s (a:as) + | b `Set.member` s = loop s as + | otherwise = a : loop (Set.insert b s) as + where b = f a --- | @'groupOn' f = 'groupBy' (('==') \`on\` f) '.' 'List.sortBy' ('compare' \`on\` f)@. +-- Andreas, 2019-11-16 +-- The implementation of nubOn using Set can be more than 1000-times +-- faster than the following old one using List.sort. +-- (Tested using criterion and -O on some lists of length 100.000.) -groupOn :: Ord b => (a -> b) -> [a] -> [[a]] -groupOn f = List.groupBy ((==) `on` f) . List.sortBy (compare `on` f) +-- -- | Efficient variant of 'nubBy' for finite lists (using sorting). +-- -- O(n log n) +-- -- +-- -- Specification: +-- -- +-- -- > nubOn2 f xs == 'nubBy' ((==) `'on'` f) xs. +-- +-- nubOn2 :: Ord b => (a -> b) -> [a] -> [a] +-- nubOn2 tag = +-- -- Throw away numbering +-- map snd +-- -- Restore original order +-- . List.sortBy (compare `on` fst) +-- -- Retain first entry of each @tag@ group +-- . map (snd . head) +-- . List.groupBy ((==) `on` fst) +-- -- Sort by tag (stable) +-- . List.sortBy (compare `on` fst) +-- -- Tag with @tag@ and sequential numbering +-- . map (\p@(_, x) -> (tag x, p)) +-- . zip [1..] --- | @splitExactlyAt n xs = Just (ys, zs)@ iff @xs = ys ++ zs@ --- and @genericLength ys = n@. -splitExactlyAt :: Integral n => n -> [a] -> Maybe ([a], [a]) -splitExactlyAt 0 xs = return ([], xs) -splitExactlyAt n [] = Nothing -splitExactlyAt n (x : xs) = mapFst (x :) <$> splitExactlyAt (n-1) xs +-- | Efficient variant of 'nubBy' for finite lists. +-- O(n log n). +-- +-- Specification: For each list @xs@ there is a list @ys@ which is a +-- permutation of @xs@ such that +-- +-- > uniqOn f xs == 'nubBy' ((==) `'on'` f) ys. +-- +-- Furthermore: +-- +-- > List.sortBy (compare `on` f) (uniqOn f xs) == uniqOn f xs +-- > uniqOn id == Set.toAscList . Set.fromList +-- +uniqOn :: Ord b => (a -> b) -> [a] -> [a] +uniqOn key = Map.elems . Map.fromList . map (\ a -> (key a, a)) --- | A generalised variant of 'elemIndex'. +-- | Checks if all the elements in the list are equal. Assumes that +-- the 'Eq' instance stands for an equivalence relation. +-- O(n). +allEqual :: Eq a => [a] -> Bool +allEqual [] = True +allEqual (x : xs) = all (== x) xs -genericElemIndex :: (Eq a, Integral i) => a -> [a] -> Maybe i -genericElemIndex x xs = - listToMaybe $ - map fst $ - filter snd $ - zip [0..] $ - map (== x) xs +--------------------------------------------------------------------------- +-- * Zipping +--------------------------------------------------------------------------- -- | Requires both lists to have the same length. +-- O(n). -- -- Otherwise, @Nothing@ is returned. @@ -389,6 +556,7 @@ -- | Like 'zipWith' but keep the rest of the second list as-is -- (in case the second list is longer). +-- O(n). -- -- @ -- zipWithKeepRest f as bs == zipWith f as bs ++ drop (length as) bs @@ -411,46 +579,19 @@ -- where (zs , as , bs) = zipWithTails f xs ys --- | Efficient variant of 'nubBy' for finite lists. --- --- Specification: --- --- > nubOn f xs == 'nubBy' ((==) `'on'` f) xs. -nubOn :: Ord b => (a -> b) -> [a] -> [a] -nubOn tag = - map snd - . List.sortBy (compare `on` fst) - . map (snd . head) - . List.groupBy ((==) `on` fst) - . List.sortBy (compare `on` fst) - . map (\p@(_, x) -> (tag x, p)) - . zip [1..] - --- | Efficient variant of 'nubBy' for finite lists. --- --- Specification: For each list @xs@ there is a list @ys@ which is a --- permutation of @xs@ such that --- --- > uniqOn f xs == 'nubBy' ((==) `'on'` f) ys. --- --- Furthermore --- --- > List.sortBy (compare `on` f) (uniqOn f xs) == uniqOn f xs. -uniqOn :: Ord b => (a -> b) -> [a] -> [a] -uniqOn key = Map.elems . Map.fromList . map (\ a -> (key a, a)) +--------------------------------------------------------------------------- +-- * Unzipping +--------------------------------------------------------------------------- --- | Compute the common suffix of two lists. -commonSuffix :: Eq a => [a] -> [a] -> [a] -commonSuffix xs ys = reverse $ (commonPrefix `on` reverse) xs ys +unzipWith :: (a -> (b, c)) -> [a] -> ([b], [c]) +unzipWith f = unzip . map f --- | Compute the common prefix of two lists. -commonPrefix :: Eq a => [a] -> [a] -> [a] -commonPrefix [] _ = [] -commonPrefix _ [] = [] -commonPrefix (x:xs) (y:ys) - | x == y = x : commonPrefix xs ys - | otherwise = [] +--------------------------------------------------------------------------- +-- * Edit distance +--------------------------------------------------------------------------- +-- | Implemented using tree recursion, don't run me at home! +-- O(3^(min n m)). editDistanceSpec :: Eq a => [a] -> [a] -> Int editDistanceSpec [] ys = length ys editDistanceSpec xs [] = length xs @@ -460,16 +601,31 @@ , editDistanceSpec xs (y : ys) , editDistanceSpec xs ys ] -editDistance :: Eq a => [a] -> [a] -> Int +-- | Implemented using dynamic programming and @Data.Array@. +-- O(n*m). +editDistance :: forall a. Eq a => [a] -> [a] -> Int editDistance xs ys = editD 0 0 - where xss = List.tails xs - yss = List.tails ys - tbl = Map.fromList [ ((i, j), editD' i j) | i <- [0..length xss - 1], j <- [0..length yss - 1] ] - editD i j = tbl Map.! (i, j) - editD' i j = - case (xss !! i, yss !! j) of - ([], ys) -> length ys - (xs, []) -> length xs - (x : xs, y : ys) - | x == y -> editD (i + 1) (j + 1) - | otherwise -> 1 + minimum [ editD (i + 1) j, editD i (j + 1), editD (i + 1) (j + 1) ] + where + editD i j = tbl Array.! (i, j) + -- Tabulate editD' in immutable boxed array (content computed lazily). + tbl :: Array (Int,Int) Int + tbl = array ((0,0), (n,m)) [ ((i, j), editD' i j) | i <- [0..n], j <- [0..m] ] + editD' i j = + case (compare i n, compare j m) of + -- Interior + (LT, LT) + | xsA Array.! i == ysA Array.! j + -> editD i' j' + | otherwise -> 1 + minimum [ editD i' j, editD i j', editD i' j' ] + -- Border: one list is empty + (EQ, LT) -> m - j + (LT, EQ) -> n - i + -- Corner (EQ, EQ): both lists are empty + _ -> 0 + -- GT cases are impossible. + where (i',j') = (i+1, j+1) + n = length xs + m = length ys + xsA, ysA :: Array Int a + xsA = listArray (0,n-1) xs + ysA = listArray (0,m-1) ys diff --git a/src/full/Agda/Utils/ListT.hs b/src/full/Agda/Utils/ListT.hs --- a/src/full/Agda/Utils/ListT.hs +++ b/src/full/Agda/Utils/ListT.hs @@ -1,5 +1,5 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE UndecidableInstances #-} -- Due to limitations of funct.dep. +{-# LANGUAGE CPP #-} -- | @ListT@ done right, -- see https://www.haskell.org/haskellwiki/ListT_done_right_alternative @@ -12,10 +12,13 @@ import Control.Applicative ( Alternative((<|>), empty) ) import Control.Monad +import Control.Monad.Fail as Fail import Control.Monad.Reader import Control.Monad.State +#if __GLASGOW_HASKELL__ < 804 import Data.Semigroup +#endif import Agda.Utils.Maybe @@ -50,6 +53,10 @@ foldListT cons nil = loop where loop l = caseListT l nil $ \ a l' -> cons a $ loop l' +-- | Force all values in the lazy list, effects left-to-right +sequenceListT :: Monad m => ListT m a -> m [a] +sequenceListT = foldListT ((<$>) . (:)) $ pure [] + -- | The join operation of the @ListT m@ monad. concatListT :: Monad m => ListT m (ListT m a) -> ListT m a concatListT = ListT . foldListT append (return Nothing) @@ -141,3 +148,6 @@ instance (Applicative m, MonadState s m) => MonadState s (ListT m) where get = lift get put = lift . put + +instance Monad m => MonadFail (ListT m) where + fail _ = empty diff --git a/src/full/Agda/Utils/Map.hs b/src/full/Agda/Utils/Map.hs --- a/src/full/Agda/Utils/Map.hs +++ b/src/full/Agda/Utils/Map.hs @@ -1,56 +1,62 @@ -{-# LANGUAGE CPP #-} module Agda.Utils.Map where -import Prelude hiding (map, lookup, mapM) -import Data.Map as Map -import Data.Traversable +import Data.Map (Map) +import qualified Data.Map as Map +import Data.Maybe (mapMaybe) -import Agda.Utils.Tuple -#include "undefined.h" -import Agda.Utils.Impossible - --- * Monadic map operations ---------------------------------------------------------------------------- - -data EitherOrBoth a b = L a | B a b | R b - --- | Not very efficient (goes via a list), but it'll do. -unionWithM :: (Ord k, Monad m) => (a -> a -> m a) -> Map k a -> Map k a -> m (Map k a) -unionWithM f m1 m2 = fromList <$> mapM combine (toList m) - where - m = unionWith both (map L m1) (map R m2) - - both (L a) (R b) = B a b - both _ _ = __IMPOSSIBLE__ - - combine (k, B a b) = (,) k <$> f a b - combine (k, L a) = return (k, a) - combine (k, R b) = return (k, b) - -insertWithKeyM :: (Ord k, Monad m) => (k -> a -> a -> m a) -> k -> a -> Map k a -> m (Map k a) -insertWithKeyM clash k x m = - case lookup k m of - Just y -> do - z <- clash k x y - return $ insert k z m - Nothing -> return $ insert k x m +-- UNUSED Liang-Ting Chen (05-07-2019) +-- -- * Monadic map operations +-- --------------------------------------------------------------------------- +-- +-- data EitherOrBoth a b = L a | B a b | R b +-- +-- -- | Not very efficient (goes via a list), but it'll do. +-- unionWithM :: (Ord k, Monad m) => (a -> a -> m a) -> Map k a -> Map k a -> m (Map k a) +-- unionWithM f m1 m2 = fromList <$> mapM combine (toList m) +-- where +-- m = unionWith both (map L m1) (map R m2) +-- +-- both (L a) (R b) = B a b +-- both _ _ = __IMPOSSIBLE__ +-- +-- combine (k, B a b) = (,) k <$> f a b +-- combine (k, L a) = return (k, a) +-- combine (k, R b) = return (k, b) +-- +-- UNUSED Liang-Ting Chen (05-07-2019) +-- insertWithKeyM :: (Ord k, Monad m) => (k -> a -> a -> m a) -> k -> a -> Map k a -> m (Map k a) +-- insertWithKeyM clash k x m = +-- case lookup k m of +-- Just y -> do +-- z <- clash k x y +-- return $ insert k z m +-- Nothing -> return $ insert k x m -- * Non-monadic map operations --------------------------------------------------------------------------- --- | Big conjunction over a map. -allWithKey :: (k -> a -> Bool) -> Map k a -> Bool -allWithKey f = Map.foldrWithKey (\ k a b -> f k a && b) True +-- UNUSED Liang-Ting Chen (05-07-2019) +-- -- | Big conjunction over a map. +-- allWithKey :: (k -> a -> Bool) -> Map k a -> Bool +-- allWithKey f = Map.foldrWithKey (\ k a b -> f k a && b) True -- | Filter a map based on the keys. filterKeys :: (k -> Bool) -> Map k a -> Map k a -filterKeys p = filterWithKey (const . p) +filterKeys p = Map.filterWithKey (const . p) --- | Unzip a map. -unzip :: Map k (a, b) -> (Map k a, Map k b) -unzip m = (Map.map fst m, Map.map snd m) +-- | O(n log n). Rebuilds the map from scratch. +-- Not worse than 'Map.mapKeys'. +mapMaybeKeys :: (Ord k1, Ord k2) => (k1 -> Maybe k2) -> Map k1 a -> Map k2 a +mapMaybeKeys f = Map.fromList . mapMaybe (\ (k,a) -> (,a) <$> f k) . Map.toList -unzip3 :: Map k (a, b, c) -> (Map k a, Map k b, Map k c) -unzip3 m = (Map.map fst3 m, Map.map snd3 m, Map.map thd3 m) +-- UNUSED Liang-Ting Chen (05-07-2019) +-- -- | Unzip a map. +-- unzip :: Map k (a, b) -> (Map k a, Map k b) +-- unzip m = (Map.map fst m, Map.map snd m) +-- +-- UNUSED Liang-Ting Chen (05-07-2019) +-- unzip3 :: Map k (a, b, c) -> (Map k a, Map k b, Map k c) +-- unzip3 m = (Map.map fst3 m, Map.map snd3 m, Map.map thd3 m) +-- diff --git a/src/full/Agda/Utils/Maybe.hs b/src/full/Agda/Utils/Maybe.hs --- a/src/full/Agda/Utils/Maybe.hs +++ b/src/full/Agda/Utils/Maybe.hs @@ -9,12 +9,12 @@ , module Data.Maybe ) where -import Control.Monad + import Control.Monad.Trans.Maybe import Data.Maybe -import Data.Functor + -- * Conversion. -- | Retain object when tag is 'True'. @@ -23,11 +23,21 @@ -- * Collection operations. +-- UNUSED Liang-Ting Chen 05-07-2019 +-- Andreas, 2020-02-17: +-- Yeah, but a useful function to have in the library nevertheless. + -- | @unionWith@ for collections of size <= 1. unionMaybeWith :: (a -> a -> a) -> Maybe a -> Maybe a -> Maybe a unionMaybeWith f Nothing mb = mb unionMaybeWith f ma Nothing = ma unionMaybeWith f (Just a) (Just b) = Just $ f a b + +-- | @unionsWith@ for collections of size <= 1. +unionsMaybeWith :: (a -> a -> a) -> [Maybe a] -> Maybe a +unionsMaybeWith f ms = case catMaybes ms of + [] -> Nothing + as -> Just $ foldl1 f as -- | Unzipping a list of length <= 1. diff --git a/src/full/Agda/Utils/Maybe/Strict.hs b/src/full/Agda/Utils/Maybe/Strict.hs --- a/src/full/Agda/Utils/Maybe/Strict.hs +++ b/src/full/Agda/Utils/Maybe/Strict.hs @@ -1,4 +1,9 @@ -{-# LANGUAGE CPP #-} +-- Liang-Ting Chen (2019-07-04): +-- Consider using Data.Maybe.Strict instead +-- Andreas Abel (2019-07-05)@GitHub: +-- The dependencies of strict-base-types are too heavy, +-- especially since it depends on lens which we consciously ruled out. + {-# LANGUAGE DeriveDataTypeable #-} {-# LANGUAGE DeriveGeneric #-} @@ -29,14 +34,10 @@ import Prelude hiding (Maybe (..), maybe, null) import qualified Prelude as Lazy -import Control.Applicative (pure, (<$>)) import Control.DeepSeq (NFData (..)) import Data.Binary (Binary (..)) import Data.Data (Data (..)) -import Data.Monoid (Monoid, mempty, mappend) import Data.Semigroup (Semigroup, (<>)) -import Data.Foldable (Foldable (..)) -import Data.Traversable (Traversable (..)) import Data.Strict.Maybe (Maybe (Nothing, Just), fromJust, fromMaybe, isJust, isNothing, maybe) import GHC.Generics (Generic (..)) @@ -61,13 +62,22 @@ -- The monoid instance was fixed in strict-base-types 0.5.0. See -- Issue 1805. instance Semigroup a => Semigroup (Maybe a) where - Nothing <> m = m - m <> Nothing = m - Just x1 <> Just x2 = Just (x1 <> x2) + (<>) = unionMaybeWith (<>) instance Semigroup a => Monoid (Maybe a) where mempty = Nothing mappend = (<>) + +-- | Note that strict Maybe is an 'Applicative' only modulo strictness. +-- The laws only hold in the strict semantics. +-- Eg. @pure f <*> pure _|_ = _|_@, but according to the laws for +-- 'Applicative' it should be @pure (f _|_)@. +-- We ignore this issue here, it applies also to 'Foldable' and 'Traversable'. + +instance Applicative Maybe where + pure = Just + Just f <*> Just x = Just $ f x + _ <*> _ = Nothing instance Foldable Maybe where foldMap _ Nothing = mempty diff --git a/src/full/Agda/Utils/Memo.hs b/src/full/Agda/Utils/Memo.hs --- a/src/full/Agda/Utils/Memo.hs +++ b/src/full/Agda/Utils/Memo.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} module Agda.Utils.Memo where @@ -6,7 +5,7 @@ import System.IO.Unsafe import Data.IORef import qualified Data.Map as Map -import qualified Agda.Utils.HashMap as HMap +import qualified Data.HashMap.Strict as HMap import Data.Hashable import Agda.Utils.Lens diff --git a/src/full/Agda/Utils/Monad.hs b/src/full/Agda/Utils/Monad.hs --- a/src/full/Agda/Utils/Monad.hs +++ b/src/full/Agda/Utils/Monad.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} module Agda.Utils.Monad ( module Agda.Utils.Monad @@ -8,16 +7,14 @@ ) where -import Prelude hiding (concat) +import Control.Applicative (liftA2) import Control.Monad hiding (mapM, forM) -#if __GLASGOW_HASKELL__ >= 800 import qualified Control.Monad.Fail as Fail -#endif import Control.Monad.Identity ( Identity ) import Control.Monad.State -import Control.Monad.Writer + import Data.Traversable as Trav hiding (for, sequence) import Data.Foldable as Fold import Data.Maybe @@ -28,21 +25,12 @@ , MonadError(catchError, throwError) ) -import Agda.Utils.List import Agda.Utils.Null (ifNotNullM) -#include "undefined.h" import Agda.Utils.Impossible --------------------------------------------------------------------------- -#if __GLASGOW_HASKELL__ >= 800 -instance Fail.MonadFail Identity where - fail = error -#endif - ---------------------------------------------------------------------------- - -- | Binary bind. (==<<) :: Monad m => (a -> b -> m c) -> (m a, m b) -> m c k ==<< (ma, mb) = ma >>= \ a -> k a =<< mb @@ -61,9 +49,7 @@ -- | Monadic if-then-else. ifM :: Monad m => m Bool -> m a -> m a -> m a -ifM c m m' = - do b <- c - if b then m else m' +ifM c m m' = c >>= \b -> if b then m else m' -- | @ifNotM mc = ifM (not <$> mc)@ ifNotM :: Monad m => m Bool -> m a -> m a -> m a @@ -81,7 +67,7 @@ -- | Lazy monadic disjunction. or2M :: Monad m => m Bool -> m Bool -> m Bool -or2M ma mb = ifM ma (return True) mb +or2M ma = ifM ma (return True) orM :: (Foldable f, Monad m) => f (m Bool) -> m Bool orM = Fold.foldl or2M (return False) @@ -105,7 +91,7 @@ -- Loops gathering results in a Monoid ------------------------------------ --- | Generalized version of @mapM_ :: Monad m => (a -> m ()) -> [a] -> m ()@ +-- | Generalized version of @traverse_ :: Applicative m => (a -> m ()) -> [a] -> m ()@ -- Executes effects and collects results in left-to-right order. -- Works best with left-associative monoids. -- @@ -116,11 +102,11 @@ -- that collects results in right-to-left order -- (effects still left-to-right). -- It might be preferable for right associative monoids. -mapM' :: (Foldable t, Monad m, Monoid b) => (a -> m b) -> t a -> m b -mapM' f = Fold.foldl (\ mb a -> liftM2 mappend mb (f a)) (return mempty) +mapM' :: (Foldable t, Applicative m, Monoid b) => (a -> m b) -> t a -> m b +mapM' f = Fold.foldl (\ mb a -> liftA2 mappend mb (f a)) (pure mempty) --- | Generalized version of @forM_ :: Monad m => [a] -> (a -> m ()) -> m ()@ -forM' :: (Foldable t, Monad m, Monoid b) => t a -> (a -> m b) -> m b +-- | Generalized version of @for_ :: Applicative m => [a] -> (a -> m ()) -> m ()@ +forM' :: (Foldable t, Applicative m, Monoid b) => t a -> (a -> m b) -> m b forM' = flip mapM' -- Variations of Traversable @@ -131,6 +117,14 @@ forMM :: (Traversable t, Monad m) => m (t a) -> (a -> m b) -> m (t b) forMM = flip mapMM +-- Variations of Foldable + +mapMM_ :: (Foldable t, Monad m) => (a -> m ()) -> m (t a) -> m () +mapMM_ f mxs = Fold.mapM_ f =<< mxs + +forMM_ :: (Foldable t, Monad m) => m (t a) -> (a -> m ()) -> m () +forMM_ = flip mapMM_ + -- Continuation monad ----------------------------------------------------- -- Andreas, 2017-04-11, issue #2543 @@ -150,10 +144,18 @@ mapMaybeM :: Monad m => (a -> m (Maybe b)) -> [a] -> m [b] mapMaybeM f xs = catMaybes <$> Trav.mapM f xs +-- | A version of @'mapMaybeM'@ with a computation for the input list. +mapMaybeMM :: Monad m => (a -> m (Maybe b)) -> m [a] -> m [b] +mapMaybeMM f m = mapMaybeM f =<< m + -- | The @for@ version of 'mapMaybeM'. forMaybeM :: Monad m => [a] -> (a -> m (Maybe b)) -> m [b] forMaybeM = flip mapMaybeM +-- | The @for@ version of 'mapMaybeMM'. +forMaybeMM :: Monad m => m [a] -> (a -> m (Maybe b)) -> m [b] +forMaybeMM = flip mapMaybeMM + -- | A monadic version of @'dropWhile' :: (a -> Bool) -> [a] -> [a]@. dropWhileM :: Monad m => (a -> m Bool) -> [a] -> m [a] dropWhileM p [] = return [] @@ -191,7 +193,7 @@ finally :: MonadError e m => m a -> m () -> m a first `finally` after = do - r <- catchError (liftM Right first) (return . Left) + r <- catchError (fmap Right first) (return . Left) after case r of Left e -> throwError e @@ -202,6 +204,11 @@ tryMaybe :: (MonadError e m, Functor m) => m a -> m (Maybe a) tryMaybe m = (Just <$> m) `catchError` \ _ -> return Nothing +-- | Run a command, catch the exception and return it. + +tryCatch :: (MonadError e m, Functor m) => m () -> m (Maybe e) +tryCatch m = (Nothing <$ m) `catchError` \ err -> return $ Just err + -- State monad ------------------------------------------------------------ -- | Bracket without failure. Typically used to preserve state. @@ -227,33 +234,3 @@ [(x,"")] -> return x _ -> throwError $ strMsg $ "readM: parse error string " ++ s - - --- RETIRED STUFF ---------------------------------------------------------- - -{- RETIRED, ASR, 09 September 2014. Not used. --- | Bracket for the 'Error' class. - --- bracket :: (Error e, MonadError e m) --- => m a -- ^ Acquires resource. Run first. --- -> (a -> m c) -- ^ Releases resource. Run last. --- -> (a -> m b) -- ^ Computes result. Run in-between. --- -> m b --- bracket acquire release compute = do --- resource <- acquire --- compute resource `finally` release resource --} - -{- RETIRED, Andreas, 2012-04-30. Not used. -concatMapM :: Applicative m => (a -> m [b]) -> [a] -> m [b] -concatMapM f xs = concat <$> traverse f xs - --- | Depending on the monad you have to look at the result for --- the force to be effective. For the 'IO' monad you do. -forceM :: Monad m => [a] -> m () -forceM xs = do () <- length xs `seq` return () - return () - -commuteM :: (Traversable f, Applicative m) => f (m a) -> m (f a) -commuteM = traverse id --} diff --git a/src/full/Agda/Utils/NonemptyList.hs b/src/full/Agda/Utils/NonemptyList.hs deleted file mode 100644 --- a/src/full/Agda/Utils/NonemptyList.hs +++ /dev/null @@ -1,76 +0,0 @@ -{-# LANGUAGE DeriveDataTypeable #-} - --- | Nonempty lists. - -module Agda.Utils.NonemptyList where - -import Control.Monad - -import Data.Data (Data) -import Data.Foldable (Foldable) - -- The toList method of Foldable may do something stupid, - -- like traversing the list just to build a list again. -import Data.Traversable (Traversable) -import Data.Maybe -import Data.Semigroup -import qualified Data.List as List - -infixr 5 :! -data NonemptyList a = (:!) { headNe :: a, tailNe :: [a] } - deriving (Eq, Ord, Functor, Foldable, Traversable, Data) - -instance Semigroup (NonemptyList a) where - (x :! xs) <> (y :! ys) = x :! xs ++ y : ys - -instance Applicative NonemptyList where - pure x = x :! [] - (<*>) = ap - -instance Monad NonemptyList where - return = pure - (x :! xs) >>= f = foldr1 (<>) (f x : map f xs) - -instance Show a => Show (NonemptyList a) where - showsPrec _ = showList . toList - --- | Implementing conversion to list manually, since @Foldable.toList@ --- might recurse over the tail and, thus, destroy sharing. -toList :: NonemptyList a -> [a] -toList (x :! xs) = x : xs - --- | Converting a list (safe). -fromList :: [a] -> Maybe (NonemptyList a) -fromList [] = Nothing -fromList (x : xs) = Just $ x :! xs - --- | Prepending an element. -consNe :: a -> NonemptyList a -> NonemptyList a -consNe x (y :! zs) = x :! (y : zs) - --- | Returns the union of the argument lists seen as sets. The order of the --- elements in the result is not specified. Precondition: arguments contain --- no duplicates. -unionNe :: Eq a => NonemptyList a -> NonemptyList a -> NonemptyList a -unionNe (x :! xs) (y :! ys) = z :! zs - where z : zs = List.union (x : xs) (y : ys) - --- | Zip two nonempty lists. -zipWithNe :: (a -> b -> c) -> NonemptyList a -> NonemptyList b -> NonemptyList c -zipWithNe f (x :! xs) (y :! ys) = f x y :! zipWith f xs ys - --- | Zip two nonempty lists. -zipNe :: NonemptyList a -> NonemptyList b -> NonemptyList (a, b) -zipNe = zipWithNe (,) - --- | Case on a list, getting a nonempty list in the cons case. -caseListNe :: [a] -> b -> (NonemptyList a -> b) -> b -caseListNe [] e ne = e -caseListNe (x : xs) e ne = ne (x :! xs) - --- | Case on a list, with list last. -listCaseNe :: b -> (NonemptyList a -> b) -> [a] -> b -listCaseNe e ne xs = caseListNe xs e ne - --- | Check if an element is present in a list. -elemNe :: Eq a => a -> NonemptyList a -> Bool -elemNe y (x :! xs) = elem y (x : xs) diff --git a/src/full/Agda/Utils/Null.hs b/src/full/Agda/Utils/Null.hs --- a/src/full/Agda/Utils/Null.hs +++ b/src/full/Agda/Utils/Null.hs @@ -1,6 +1,5 @@ {-# OPTIONS_GHC -fno-warn-orphans #-} -{-# LANGUAGE CPP #-} -- | Overloaded @null@ and @empty@ for collections and sequences. @@ -9,10 +8,12 @@ import Prelude hiding (null) import Control.Monad +import Control.Monad.Reader +import Control.Monad.State import Data.ByteString.Char8 (ByteString) import qualified Data.ByteString.Char8 as ByteString -import Data.Function + import Data.HashMap.Strict (HashMap) import qualified Data.HashMap.Strict as HashMap import Data.HashSet (HashSet) @@ -24,17 +25,19 @@ import qualified Data.List as List import Data.Map (Map) import qualified Data.Map as Map -import Data.Monoid + import Data.Sequence (Seq) import qualified Data.Sequence as Seq import Data.Set (Set) import qualified Data.Set as Set -import Text.PrettyPrint (Doc, render) +import Text.PrettyPrint (Doc) import Agda.Utils.Bag (Bag) import qualified Agda.Utils.Bag as Bag +import Agda.Utils.Impossible + class Null a where empty :: a null :: a -> Bool @@ -100,6 +103,14 @@ instance Null Doc where empty = mempty null = (== mempty) + +instance (Null (m a), Monad m) => Null (ReaderT r m a) where + empty = lift empty + null = __IMPOSSIBLE__ + +instance (Null (m a), Monad m) => Null (StateT r m a) where + empty = lift empty + null = __IMPOSSIBLE__ -- * Testing for null. diff --git a/src/full/Agda/Utils/POMonoid.hs b/src/full/Agda/Utils/POMonoid.hs --- a/src/full/Agda/Utils/POMonoid.hs +++ b/src/full/Agda/Utils/POMonoid.hs @@ -1,9 +1,11 @@ +{-# LANGUAGE CPP #-} -- | Partially ordered monoids. module Agda.Utils.POMonoid where +#if __GLASGOW_HASKELL__ < 804 import Data.Semigroup -import Data.Monoid +#endif import Agda.Utils.PartialOrd @@ -27,7 +29,7 @@ -- related (x <> y) POLE (x' <> y') -- @ -class (PartialOrd a, Monoid a) => POMonoid a where +class (PartialOrd a, Semigroup a, Monoid a) => POMonoid a where -- | Completing POMonoids with inverses to form a Galois connection. -- @@ -39,3 +41,28 @@ class POMonoid a => LeftClosedPOMonoid a where inverseCompose :: a -> a -> a + + +-- | @hasLeftAdjoint x@ checks whether +-- @x^-1 := x `inverseCompose` mempty@ is such that +-- @x `inverseCompose` y == x^-1 <> y@ for any @y@. +hasLeftAdjoint :: LeftClosedPOMonoid a => a -> Bool +hasLeftAdjoint x = related (inverseCompose x mempty <> x) POLE mempty + -- It is enough to check the above, because of the following proof: + -- I will write _\_ for `inverseCompose`, id for mempty, and _._ for (<>). + -- Assume (*) x^-1 . x <= id, as checked. + -- Show x^-1 . y <=> x \ y + -- + -- 1. (>=) + -- id <= x . (x \ id) (galois) + -- id . y <= x . (x \ id) . y + -- y <= x . (x \ id) . y + -- x \ y <= (x \ id) . y (galois) + -- x^-1 . y >= x \ y qed + -- + -- 2. (<=) + -- y <= x . (x \ y) (galois) + -- x^-1 . y <= x^-1 . x . (x \ y) + -- <= id . (x \ y) (*) + -- <= x \ y + -- x^-1 . y <= x \ y qed diff --git a/src/full/Agda/Utils/Parser/MemoisedCPS.hs b/src/full/Agda/Utils/Parser/MemoisedCPS.hs --- a/src/full/Agda/Utils/Parser/MemoisedCPS.hs +++ b/src/full/Agda/Utils/Parser/MemoisedCPS.hs @@ -20,7 +20,6 @@ -- the author of this module whether the change leads to more -- non-termination for grammars that are not cyclic.) -{-# LANGUAGE CPP #-} module Agda.Utils.Parser.MemoisedCPS ( ParserClass(..) @@ -31,15 +30,15 @@ ) where import Control.Applicative ( Alternative((<|>), empty, many, some) ) -import Control.Monad (ap, liftM2) -import Control.Monad.State.Strict (State, evalState, runState, get, put, modify') +import Control.Monad (liftM2, (<=<)) +import Control.Monad.State.Strict (State, evalState, runState, get, modify') import Data.Array import Data.Hashable import qualified Data.HashMap.Strict as Map import Data.HashMap.Strict (HashMap) -import qualified Data.HashSet as Set -import Data.HashSet (HashSet) + + import qualified Data.IntMap.Strict as IntMap import Data.IntMap.Strict (IntMap) import qualified Data.List as List @@ -50,7 +49,6 @@ import Agda.Utils.Pretty ( mparens ) -#include "undefined.h" import Agda.Utils.Impossible -- | Positions. @@ -68,8 +66,8 @@ -- | Memoised values. data Value k r tok b = Value - { results :: !(IntMap [r]) - , continuations :: [Cont k r tok b r] + { _results :: !(IntMap [r]) + , _continuations :: [Cont k r tok b r] } -- | The parser type. @@ -194,8 +192,7 @@ let alter j zero f m = IntMap.alter (Just . f . fromMaybe zero) j m - lookupTable = fmap (\m -> Map.lookup key =<< - IntMap.lookup i m) get + lookupTable = fmap (Map.lookup key <=< IntMap.lookup i) get insertTable v = modify' $ alter i Map.empty (Map.insert key v) v <- lookupTable diff --git a/src/full/Agda/Utils/Parser/ReadP.hs b/src/full/Agda/Utils/Parser/ReadP.hs deleted file mode 100644 --- a/src/full/Agda/Utils/Parser/ReadP.hs +++ /dev/null @@ -1,521 +0,0 @@ -{-# LANGUAGE MagicHash #-} - ------------------------------------------------------------------------------ --- | - --- This is a modified version of the ReadP module from the standard libraries. --- The changes are: - --- 1) ReadP is parameterised over the token type (hard-wired to 'Char' in the library). --- 2) Added the functions 'parse' and 'parse'' which run parsers. --- 3) Removed Read instances. - --- Module : "Text.ParserCombinators.ReadP" --- Copyright : (c) The University of Glasgow 2002 --- License : BSD-style (see the file libraries/base/LICENSE) --- --- Maintainer : libraries@haskell.org --- Stability : provisional --- Portability : non-portable (local universal quantification) --- --- This is a library of parser combinators, originally written by Koen Claessen. --- It parses all alternatives in parallel, so it never keeps hold of --- the beginning of the input string, a common source of space leaks with --- other parsers. The '(+++)' choice combinator is genuinely commutative; --- it makes no difference which branch is \"shorter\". - ------------------------------------------------------------------------------ - -module Agda.Utils.Parser.ReadP - ( - -- * The 'ReadP' type - ReadP, -- :: * -> *; instance Functor, Monad, MonadPlus - - -- * Primitive operations - get, -- :: ReadP Char - look, -- :: ReadP String - (+++), -- :: ReadP a -> ReadP a -> ReadP a - (<++), -- :: ReadP a -> ReadP a -> ReadP a - gather, -- :: ReadP a -> ReadP (String, a) - - -- * Parse - parse, -- :: ReadP tok a -> [tok] -> [a] - parse', -- :: ReadP tok a -> [tok] -> Either a [tok] - - -- * Other operations - pfail, -- :: ReadP a - satisfy, -- :: (Char -> Bool) -> ReadP Char - char, -- :: Char -> ReadP Char - string, -- :: String -> ReadP String - munch, -- :: (Char -> Bool) -> ReadP String - munch1, -- :: (Char -> Bool) -> ReadP String - skipSpaces, -- :: ReadP () - choice, -- :: [ReadP a] -> ReadP a - count, -- :: Int -> ReadP a -> ReadP [a] - between, -- :: ReadP open -> ReadP close -> ReadP a -> ReadP a - option, -- :: a -> ReadP a -> ReadP a - optional, -- :: ReadP a -> ReadP () - many, -- :: ReadP a -> ReadP [a] - many1, -- :: ReadP a -> ReadP [a] - skipMany, -- :: ReadP a -> ReadP () - skipMany1, -- :: ReadP a -> ReadP () - sepBy, -- :: ReadP a -> ReadP sep -> ReadP [a] - sepBy1, -- :: ReadP a -> ReadP sep -> ReadP [a] - endBy, -- :: ReadP a -> ReadP sep -> ReadP [a] - endBy1, -- :: ReadP a -> ReadP sep -> ReadP [a] - chainr, -- :: ReadP a -> ReadP (a -> a -> a) -> a -> ReadP a - chainl, -- :: ReadP a -> ReadP (a -> a -> a) -> a -> ReadP a - chainl1, -- :: ReadP a -> ReadP (a -> a -> a) -> ReadP a - chainr1, -- :: ReadP a -> ReadP (a -> a -> a) -> ReadP a - manyTill, -- :: ReadP a -> ReadP end -> ReadP [a] - - -- * Properties - -- $properties - ) - where - -import Control.Applicative (Applicative(..),Alternative(empty,(<|>))) -import Control.Monad -import GHC.Exts -import Data.Char - -infixr 5 +++, <++ - --- --------------------------------------------------------------------------- --- The P type --- is representation type -- should be kept abstract - -data P t a - = Get (t -> P t a) - | Look ([t] -> P t a) - | Fail - | Result a (P t a) - | Final [(a,[t])] -- invariant: list is non-empty! - deriving (Functor) - --- Monad, MonadPlus - -instance Applicative (P t) where - pure x = Result x Fail - (<*>) = ap - -instance Monad (P t) where - return = pure - - (Get f) >>= k = Get (\c -> f c >>= k) - (Look f) >>= k = Look (\s -> f s >>= k) - Fail >>= k = Fail - (Result x p) >>= k = k x `mplus` (p >>= k) - (Final r) >>= k = final [ys' | (x,s) <- r, ys' <- run (k x) s] - - fail _ = Fail - -instance Alternative (P t) where - empty = mzero - (<|>) = mplus - -instance MonadPlus (P t) where - mzero = Fail - - -- most common case: two gets are combined - Get f1 `mplus` Get f2 = Get (\c -> f1 c `mplus` f2 c) - - -- results are delivered as soon as possible - Result x p `mplus` q = Result x (p `mplus` q) - p `mplus` Result x q = Result x (p `mplus` q) - - -- fail disappears - Fail `mplus` p = p - p `mplus` Fail = p - - -- two finals are combined - -- final + look becomes one look and one final (=optimization) - -- final + sthg else becomes one look and one final - Final r `mplus` Final t = Final (r ++ t) - Final r `mplus` Look f = Look (\s -> Final (r ++ run (f s) s)) - Final r `mplus` p = Look (\s -> Final (r ++ run p s)) - Look f `mplus` Final r = Look (\s -> Final (run (f s) s ++ r)) - p `mplus` Final r = Look (\s -> Final (run p s ++ r)) - - -- two looks are combined (=optimization) - -- look + sthg else floats upwards - Look f `mplus` Look g = Look (\s -> f s `mplus` g s) - Look f `mplus` p = Look (\s -> f s `mplus` p) - p `mplus` Look f = Look (\s -> p `mplus` f s) - --- --------------------------------------------------------------------------- --- The ReadP type - -newtype ReadP t a = R (forall b . (a -> P t b) -> P t b) - --- Functor, Monad, MonadPlus - -instance Functor (ReadP t) where - fmap h (R f) = R (\k -> f (k . h)) - -instance Applicative (ReadP t) where - pure x = R (\k -> k x) - (<*>) = ap - -instance Monad (ReadP t) where - return = pure - fail _ = R (\_ -> Fail) - R m >>= f = R (\k -> m (\a -> let R m' = f a in m' k)) - -instance Alternative (ReadP t) where - empty = mzero - (<|>) = mplus - -instance MonadPlus (ReadP t) where - mzero = pfail - mplus = (+++) - --- --------------------------------------------------------------------------- --- Operations over P - -final :: [(a,[t])] -> P t a --- Maintains invariant for Final constructor -final [] = Fail -final r = Final r - -run :: P t a -> [t] -> [(a,[t])] -run (Get f) (c:s) = run (f c) s -run (Look f) s = run (f s) s -run (Result x p) s = (x,s) : run p s -run (Final r) _ = r -run _ _ = [] - --- --------------------------------------------------------------------------- --- Operations over ReadP - --- | Run a parser on a list of tokens. Returns the list of complete matches. -parse :: ReadP t a -> [t] -> [a] -parse p ts = case complete p of - R f -> map fst $ run (f return) ts - -get :: ReadP t t --- ^ Consumes and returns the next character. --- Fails if there is no input left. -get = R Get - -look :: ReadP t [t] --- ^ Look-ahead: returns the part of the input that is left, without --- consuming it. -look = R Look - -pfail :: ReadP t a --- ^ Always fails. -pfail = R (\_ -> Fail) - -(+++) :: ReadP t a -> ReadP t a -> ReadP t a --- ^ Symmetric choice. -R f1 +++ R f2 = R (\k -> f1 k `mplus` f2 k) - -(<++) :: ReadP t a -> ReadP t a -> ReadP t a --- ^ Local, exclusive, left-biased choice: If left parser --- locally produces any result at all, then right parser is --- not used. -R f <++ q = - do s <- look - probe (f return) s 0# - where - probe (Get f) (c:s) n = probe (f c) s (n+#1#) - probe (Look f) s n = probe (f s) s n - probe p@(Result _ _) _ n = discard n >> R (p >>=) - probe (Final r) _ _ = R (Final r >>=) - probe _ _ _ = q - - discard 0# = return () - discard n = get >> discard (n-#1#) - -gather :: ReadP t a -> ReadP t ([t], a) --- ^ Transforms a parser into one that does the same, but --- in addition returns the exact characters read. --- IMPORTANT NOTE: 'gather' gives a runtime error if its first argument --- is built using any occurrences of readS_to_P. -gather (R m) = - R (\k -> gath id (m (\a -> return (\s -> k (s,a))))) - where - gath l (Get f) = Get (\c -> gath (l.(c:)) (f c)) - gath l Fail = Fail - gath l (Look f) = Look (\s -> gath l (f s)) - gath l (Result k p) = k (l []) `mplus` gath l p - gath l (Final r) = error "do not use readS_to_P in gather!" - --- --------------------------------------------------------------------------- --- Derived operations - -satisfy :: (t -> Bool) -> ReadP t t --- ^ Consumes and returns the next character, if it satisfies the --- specified predicate. -satisfy p = do c <- get; if p c then return c else pfail - -char :: Eq t => t-> ReadP t t --- ^ Parses and returns the specified character. -char c = satisfy (c ==) - -string :: Eq t => [t] -> ReadP t [t] --- ^ Parses and returns the specified string. -string this = do s <- look; scan this s - where - scan [] _ = do return this - scan (x:xs) (y:ys) | x == y = do _ <- get; scan xs ys - scan _ _ = do pfail - -eof :: ReadP tok () -eof = do - ts <- look - unless (null ts) pfail - -complete :: ReadP tok a -> ReadP tok a -complete p = do - x <- p - eof - return x - -munch :: (t -> Bool) -> ReadP t [t] --- ^ Parses the first zero or more characters satisfying the predicate. -munch p = - do s <- look - scan s - where - scan (c:cs) | p c = do _ <- get; s <- scan cs; return (c:s) - scan _ = do return [] - -munch1 :: (t -> Bool) -> ReadP t [t] --- ^ Parses the first one or more characters satisfying the predicate. -munch1 p = - do c <- get - if p c then do s <- munch p; return (c:s) else pfail - -choice :: [ReadP t a] -> ReadP t a --- ^ Combines all parsers in the specified list. -choice [] = pfail -choice [p] = p -choice (p:ps) = p +++ choice ps - -skipSpaces :: ReadP Char () --- ^ Skips all whitespace. -skipSpaces = - do s <- look - skip s - where - skip (c:s) | isSpace c = do _ <- get; skip s - skip _ = do return () - -count :: Int -> ReadP t a -> ReadP t [a] --- ^ @count n p@ parses @n@ occurrences of @p@ in sequence. A list of --- results is returned. -count n p = sequence (replicate n p) - -between :: ReadP t open -> ReadP t close -> ReadP t a -> ReadP t a --- ^ @between open close p@ parses @open@, followed by @p@ and finally --- @close@. Only the value of @p@ is returned. -between open close p = do - _ <- open - x <- p - _ <- close - return x - -option :: a -> ReadP t a -> ReadP t a --- ^ @option x p@ will either parse @p@ or return @x@ without consuming --- any input. -option x p = p +++ return x - -optional :: ReadP t a -> ReadP t () --- ^ @optional p@ optionally parses @p@ and always returns @()@. -optional p = (p >> return ()) +++ return () - -many :: ReadP t a -> ReadP t [a] --- ^ Parses zero or more occurrences of the given parser. -many p = return [] +++ many1 p - -many1 :: ReadP t a -> ReadP t [a] --- ^ Parses one or more occurrences of the given parser. -many1 p = liftM2 (:) p (many p) - -skipMany :: ReadP t a -> ReadP t () --- ^ Like 'many', but discards the result. -skipMany p = many p >> return () - -skipMany1 :: ReadP t a -> ReadP t () --- ^ Like 'many1', but discards the result. -skipMany1 p = p >> skipMany p - -sepBy :: ReadP t a -> ReadP t sep -> ReadP t [a] --- ^ @sepBy p sep@ parses zero or more occurrences of @p@, separated by @sep@. --- Returns a list of values returned by @p@. -sepBy p sep = sepBy1 p sep +++ return [] - -sepBy1 :: ReadP t a -> ReadP t sep -> ReadP t [a] --- ^ @sepBy1 p sep@ parses one or more occurrences of @p@, separated by @sep@. --- Returns a list of values returned by @p@. -sepBy1 p sep = liftM2 (:) p (many (sep >> p)) - -endBy :: ReadP t a -> ReadP t sep -> ReadP t [a] --- ^ @endBy p sep@ parses zero or more occurrences of @p@, separated and ended --- by @sep@. -endBy p sep = many (do x <- p ; _ <- sep ; return x) - -endBy1 :: ReadP t a -> ReadP t sep -> ReadP t [a] --- ^ @endBy p sep@ parses one or more occurrences of @p@, separated and ended --- by @sep@. -endBy1 p sep = many1 (do x <- p ; _ <- sep ; return x) - -chainr :: ReadP t a -> ReadP t (a -> a -> a) -> a -> ReadP t a --- ^ @chainr p op x@ parses zero or more occurrences of @p@, separated by @op@. --- Returns a value produced by a /right/ associative application of all --- functions returned by @op@. If there are no occurrences of @p@, @x@ is --- returned. -chainr p op x = chainr1 p op +++ return x - -chainl :: ReadP t a -> ReadP t (a -> a -> a) -> a -> ReadP t a --- ^ @chainl p op x@ parses zero or more occurrences of @p@, separated by @op@. --- Returns a value produced by a /left/ associative application of all --- functions returned by @op@. If there are no occurrences of @p@, @x@ is --- returned. -chainl p op x = chainl1 p op +++ return x - -chainr1 :: ReadP t a -> ReadP t (a -> a -> a) -> ReadP t a --- ^ Like 'chainr', but parses one or more occurrences of @p@. -chainr1 p op = scan - where scan = p >>= rest - rest x = do f <- op - y <- scan - return (f x y) - +++ return x - -chainl1 :: ReadP t a -> ReadP t (a -> a -> a) -> ReadP t a --- ^ Like 'chainl', but parses one or more occurrences of @p@. -chainl1 p op = p >>= rest - where rest x = do f <- op - y <- p - rest (f x y) - +++ return x - -manyTill :: ReadP t a -> ReadP t end -> ReadP t [a] --- ^ @manyTill p end@ parses zero or more occurrences of @p@, until @end@ --- succeeds. Returns a list of values returned by @p@. -manyTill p end = scan - where scan = (end >> return []) <++ (liftM2 (:) p scan) - --- --------------------------------------------------------------------------- --- Converting between ReadP and Read - -readP_to_S :: ReadP Char a -> ReadS a --- ^ Converts a parser into a Haskell ReadS-style function. --- This is the main way in which you can \"run\" a 'ReadP' parser: --- the expanded type is --- @ readP_to_S :: ReadP a -> String -> [(a,String)] @ -readP_to_S (R f) = run (f return) - -readS_to_P :: ReadS a -> ReadP Char a --- ^ Converts a Haskell ReadS-style function into a parser. --- Warning: This introduces local backtracking in the resulting --- parser, and therefore a possible inefficiency. -readS_to_P r = - R (\k -> Look (\s -> final [bs'' | (a,s') <- r s, bs'' <- run (k a) s'])) - --- --------------------------------------------------------------------------- --- A variant on parse which returns either a result, or the unparseable text. - -run' :: P t a -> [t] -> Either a [t] -run' (Get f) (c:s) = run' (f c) s -run' (Look f) s = run' (f s) s -run' (Result x _) _ = Left x -run' (Final ((x,_):_)) _ = Left x -run' _ s = Right s - -parse' :: ReadP t a -> [t] -> Either a [t] -parse' p ts = case complete p of - R f -> run' (f return) ts - --- --------------------------------------------------------------------------- --- QuickCheck properties that hold for the combinators - -{- $properties -The following are QuickCheck specifications of what the combinators do. -These can be seen as formal specifications of the behavior of the -combinators. - -We use bags to give semantics to the combinators. - -> type Bag a = [a] - -Equality on bags does not care about the order of elements. - -> (=~) :: Ord a => Bag a -> Bag a -> Bool -> xs =~ ys = sort xs == sort ys - -A special equality operator to avoid unresolved overloading -when testing the properties. - -> (=~.) :: Bag (Int,String) -> Bag (Int,String) -> Bool -> (=~.) = (=~) - -Here follow the properties: - -> prop_Get_Nil = -> readP_to_S get [] =~ [] -> -> prop_Get_Cons c s = -> readP_to_S get (c:s) =~ [(c,s)] -> -> prop_Look s = -> readP_to_S look s =~ [(s,s)] -> -> prop_Fail s = -> readP_to_S pfail s =~. [] -> -> prop_Return x s = -> readP_to_S (return x) s =~. [(x,s)] -> -> prop_Bind p k s = -> readP_to_S (p >>= k) s =~. -> [ ys'' -> | (x,s') <- readP_to_S p s -> , ys'' <- readP_to_S (k (x::Int)) s' -> ] -> -> prop_Plus p q s = -> readP_to_S (p +++ q) s =~. -> (readP_to_S p s ++ readP_to_S q s) -> -> prop_LeftPlus p q s = -> readP_to_S (p <++ q) s =~. -> (readP_to_S p s +<+ readP_to_S q s) -> where -> [] +<+ ys = ys -> xs +<+ _ = xs -> -> prop_Gather s = -> forAll readPWithoutReadS $ \p -> -> readP_to_S (gather p) s =~ -> [ ((pre,x::Int),s') -> | (x,s') <- readP_to_S p s -> , let pre = take (length s - length s') s -> ] -> -> prop_String_Yes this s = -> readP_to_S (string this) (this ++ s) =~ -> [(this,s)] -> -> prop_String_Maybe this s = -> readP_to_S (string this) s =~ -> [(this, drop (length this) s) | this `isPrefixOf` s] -> -> prop_Munch p s = -> readP_to_S (munch p) s =~ -> [(takeWhile p s, dropWhile p s)] -> -> prop_Munch1 p s = -> readP_to_S (munch1 p) s =~ -> [(res,s') | let (res,s') = (takeWhile p s, dropWhile p s), not (null res)] -> -> prop_Choice ps s = -> readP_to_S (choice ps) s =~. -> readP_to_S (foldr (+++) pfail ps) s -> -> prop_ReadS r s = -> readP_to_S (readS_to_P r) s =~. r s --} diff --git a/src/full/Agda/Utils/PartialOrd.hs b/src/full/Agda/Utils/PartialOrd.hs --- a/src/full/Agda/Utils/PartialOrd.hs +++ b/src/full/Agda/Utils/PartialOrd.hs @@ -1,9 +1,11 @@ - +{-# LANGUAGE CPP #-} module Agda.Utils.PartialOrd where -import Data.Functor + import Data.Maybe +#if __GLASGOW_HASKELL__ < 804 import Data.Semigroup +#endif import Data.Set (Set) import qualified Data.Set as Set diff --git a/src/full/Agda/Utils/Permutation.hs b/src/full/Agda/Utils/Permutation.hs --- a/src/full/Agda/Utils/Permutation.hs +++ b/src/full/Agda/Utils/Permutation.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE DeriveDataTypeable #-} module Agda.Utils.Permutation where @@ -22,7 +21,6 @@ import Agda.Utils.Null import Agda.Utils.Size -#include "undefined.h" import Agda.Utils.Impossible -- | Partial permutations. Examples: @@ -101,7 +99,7 @@ where tabulate m = for [0..n-1] $ \ i -> IntMap.lookup i m instance InversePermute (Int -> a) [Maybe a] where - inversePermute (Perm n xs) f = for [0..n-1] $ \ x -> f <$> List.findIndex (x ==) xs + inversePermute (Perm n xs) f = for [0..n-1] $ \ x -> f <$> List.elemIndex x xs -- | Identity permutation. idP :: Int -> Permutation @@ -196,7 +194,7 @@ -- | Stable topologic sort. The first argument decides whether its first -- argument is an immediate parent to its second argument. topoSort :: (a -> a -> Bool) -> [a] -> Maybe Permutation -topoSort parent xs = fmap (Perm (size xs)) $ topo g +topoSort parent xs = Perm (size xs) <$> topo g where nodes = zip [0..] xs g = [ (n, parents x) | (n, x) <- nodes ] diff --git a/src/full/Agda/Utils/Pointer.hs b/src/full/Agda/Utils/Pointer.hs --- a/src/full/Agda/Utils/Pointer.hs +++ b/src/full/Agda/Utils/Pointer.hs @@ -1,7 +1,5 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE BangPatterns #-} {-# LANGUAGE DeriveDataTypeable #-} -{-# LANGUAGE StandaloneDeriving #-} module Agda.Utils.Pointer ( Ptr, newPtr, derefPtr, setPtr @@ -10,17 +8,16 @@ import Control.DeepSeq import Control.Concurrent.MVar -import Data.Foldable + import Data.Function import Data.Hashable import Data.IORef -import Data.Traversable + import System.IO.Unsafe import Data.Data (Data (..)) import Data.Typeable (Typeable) -#include "undefined.h" import Agda.Utils.Impossible data Ptr a = Ptr { ptrTag :: !Integer diff --git a/src/full/Agda/Utils/Pretty.hs b/src/full/Agda/Utils/Pretty.hs --- a/src/full/Agda/Utils/Pretty.hs +++ b/src/full/Agda/Utils/Pretty.hs @@ -1,35 +1,26 @@ -{-# LANGUAGE CPP #-} {-| Pretty printing functions. -} module Agda.Utils.Pretty ( module Agda.Utils.Pretty , module Text.PrettyPrint + -- This re-export can be removed once )) +import Data.Semigroup ((<>)) -import Agda.Utils.NonemptyList +import Agda.Utils.Size -#include "undefined.h" import Agda.Utils.Impossible -#if __GLASGOW_HASKELL__ < 800 --- ASR (2019-03-27). I used @(<>)@ from the monoid instance because I --- cannot hide this instance. -instance S.Semigroup Doc where - (<>) = (<>) -#endif - -- * Pretty class -- | While 'Show' is for rendering data in Haskell syntax, @@ -77,8 +68,8 @@ instance Pretty a => Pretty [a] where pretty = prettyList -instance Pretty a => Pretty (NonemptyList a) where - pretty = prettyList . toList +instance Pretty a => Pretty (NonEmpty a) where + pretty = prettyList . NonEmpty.toList -- * 'Doc' utilities @@ -131,3 +122,13 @@ -- | @pshow = text . pretty@ pshow :: Show a => a -> Doc pshow = text . show + +singPlural :: Sized a => a -> c -> c -> c +singPlural xs singular plural = if size xs == 1 then singular else plural + +-- | Used for with-like 'telescopes' + +prefixedThings :: Doc -> [Doc] -> Doc +prefixedThings kw = \case + [] -> P.empty + (doc : docs) -> fsep $ (kw <+> doc) : map ("|" <+>) docs diff --git a/src/full/Agda/Utils/Singleton.hs b/src/full/Agda/Utils/Singleton.hs --- a/src/full/Agda/Utils/Singleton.hs +++ b/src/full/Agda/Utils/Singleton.hs @@ -1,5 +1,3 @@ -{-# LANGUAGE GeneralizedNewtypeDeriving #-} --- {-# LANGUAGE TypeFamilies #-} -- | Constructing singleton collections. @@ -12,6 +10,8 @@ import qualified Data.HashMap.Strict as HashMap import Data.HashSet (HashSet) import qualified Data.HashSet as HashSet +import Data.List.NonEmpty (NonEmpty(..)) +import qualified Data.List.NonEmpty as NonEmpty import Data.IntMap (IntMap) import qualified Data.IntMap as IntMap @@ -25,8 +25,6 @@ import Data.Set (Set) import qualified Data.Set as Set -import Agda.Utils.NonemptyList (NonemptyList((:!))) - class Singleton el coll | coll -> el where singleton :: el -> coll @@ -34,8 +32,8 @@ instance Singleton a [a] where singleton = (:[]) instance Singleton a ([a] -> [a]) where singleton = (:) instance Singleton a (Endo [a]) where singleton = Endo . (:) -instance Singleton a (NonemptyList a) - where singleton = (:! []) +instance Singleton a (NonEmpty a) + where singleton = (:| []) instance Singleton a (Seq a) where singleton = Seq.singleton instance Singleton a (Set a) where singleton = Set.singleton instance Singleton Int IntSet where singleton = IntSet.singleton diff --git a/src/full/Agda/Utils/SmallSet.hs b/src/full/Agda/Utils/SmallSet.hs new file mode 100644 --- /dev/null +++ b/src/full/Agda/Utils/SmallSet.hs @@ -0,0 +1,153 @@ +-- | Small sets represented as immutable bit arrays for fast membership checking. +-- +-- Membership checking is O(1), but all other operations are O(n) +-- where n is the size of the element type. +-- The element type needs to implement 'Bounded' and 'Ix'. +-- +-- Mimics the interface of 'Data.Set'. +-- +-- Import as: +-- @ +-- import qualified Agda.Utils.SmallSet as SmallSet +-- import Agda.Utils.SmallSet (SmallSet) +-- @ + +{-# LANGUAGE DeriveDataTypeable #-} +{-# LANGUAGE GeneralizedNewtypeDeriving #-} + +module Agda.Utils.SmallSet + ( SmallSet() + , Ix + , (\\) + , complement + , delete + , difference + , elems + , empty + , fromList, fromAscList, fromDistinctAscList + , insert + , intersection + , isSubsetOf + , mapMemberShip + , member + , notMember + , null + , singleton + , toList, toAscList + , total + , union + , zipMemberShipWith + ) where + +import Prelude hiding (null) + +import Data.Array.IArray (Ix, Array) +import qualified Data.Array.IArray as Array +import Data.Data (Data) + +-- Note: we might want to use unboxed arrays, but they have no Data instance + +-- | Let @n@ be the size of type @a@. +type SmallSetElement a = (Bounded a, Ix a) +newtype SmallSet a = SmallSet { theSmallSet :: Array a Bool } + deriving (Eq, Ord, Show, Data) + +-- * Query + +-- | Time O(n)! +null :: SmallSetElement a => SmallSet a -> Bool +null = all (== False) . Array.elems . theSmallSet + +-- | Time O(1). +member :: SmallSetElement a => a -> SmallSet a -> Bool +member a s = theSmallSet s Array.! a + +-- | @not . member a@. Time O(1). +notMember :: SmallSetElement a => a -> SmallSet a -> Bool +notMember a = not . member a + +-- | Time O(n). +isSubsetOf :: SmallSetElement a => SmallSet a -> SmallSet a -> Bool +isSubsetOf s t = and $ toBoolListZipWith implies s t + where implies a b = if a then b else True + +-- * Construction + +-- | The empty set. Time O(n). +empty :: SmallSetElement a => SmallSet a +empty = fromBoolList (repeat False) + +-- | The full set. Time O(n). +total :: SmallSetElement a => SmallSet a +total = fromBoolList (repeat True) + +-- | A singleton set. Time O(n). +singleton :: SmallSetElement a => a -> SmallSet a +singleton a = fromList [a] + +-- | Time O(n). +insert :: SmallSetElement a => a -> SmallSet a -> SmallSet a +insert a = update [(a,True)] + +-- | Time O(n). +delete :: SmallSetElement a => a -> SmallSet a -> SmallSet a +delete a = update [(a,False)] + +-- * Combine + +-- | Time O(n). +complement :: SmallSetElement a => SmallSet a -> SmallSet a +complement = mapMemberShip not + +-- | Time O(n). +difference, (\\) :: SmallSetElement a => SmallSet a -> SmallSet a -> SmallSet a +difference = zipMemberShipWith $ \ b c -> b && not c +(\\) = difference + +-- | Time O(n). +intersection :: SmallSetElement a => SmallSet a -> SmallSet a -> SmallSet a +intersection = zipMemberShipWith (&&) + +-- | Time O(n). +union :: SmallSetElement a => SmallSet a -> SmallSet a -> SmallSet a +union = zipMemberShipWith (||) + +-- | Time O(n). +mapMemberShip :: SmallSetElement a => (Bool -> Bool) -> SmallSet a -> SmallSet a +mapMemberShip f = SmallSet . Array.amap f . theSmallSet + +-- | Time O(n). +zipMemberShipWith :: SmallSetElement a => (Bool -> Bool -> Bool) -> SmallSet a -> SmallSet a -> SmallSet a +zipMemberShipWith f s t = fromBoolList $ toBoolListZipWith f s t + +-- * Conversion + +-- | Time O(n). +elems, toList, toAscList :: SmallSetElement a => SmallSet a -> [a] +elems = map fst . filter snd . Array.assocs . theSmallSet +toList = elems +toAscList = elems + +-- | Time O(n). +fromList, fromAscList, fromDistinctAscList :: SmallSetElement a => [a] -> SmallSet a +fromList = flip update empty . map (,True) +fromAscList = fromList +fromDistinctAscList = fromList + +-- * Internal + +-- | Time O(n). Assumes @Bool@-vector of length @n@. +fromBoolList :: SmallSetElement a => [Bool] -> SmallSet a +fromBoolList = SmallSet . Array.listArray (minBound, maxBound) + +-- | Time O(n). Produces @Bool@-vector of length @n@. +toBoolList :: SmallSetElement a => SmallSet a -> [Bool] +toBoolList = Array.elems . theSmallSet + +-- | Time O(n). Produces @Bool@-vector of length @n@. +toBoolListZipWith :: SmallSetElement a => (Bool -> Bool -> Bool) -> SmallSet a -> SmallSet a -> [Bool] +toBoolListZipWith f s t = zipWith f (toBoolList s) (toBoolList t) + +-- | Time O(n). Bulk insert/delete. +update :: SmallSetElement a => [(a,Bool)] -> SmallSet a -> SmallSet a +update u s = SmallSet $ theSmallSet s Array.// u diff --git a/src/full/Agda/Utils/String.hs b/src/full/Agda/Utils/String.hs --- a/src/full/Agda/Utils/String.hs +++ b/src/full/Agda/Utils/String.hs @@ -1,15 +1,19 @@ module Agda.Utils.String where +import Control.Monad.Reader +import Control.Monad.State + + import Data.Char import qualified Data.List as List +import Data.String -import Numeric -import Agda.Utils.List -import Data.IORef -import Agda.Interaction.Options.IORefs (unicodeOrAscii, UnicodeOrAscii(..)) -import qualified System.IO.Unsafe as UNSAFE +import Agda.Interaction.Options.IORefs ( UnicodeOrAscii(..) ) +import Agda.Utils.List +import Agda.Utils.Suffix ( subscriptAllowed, toSubscriptDigit ) + -- | 'quote' adds double quotes around the string, replaces newline -- characters with @\n@, and escapes double quotes and backslashes -- within the string. This is different from the behaviour of 'show': @@ -68,11 +72,9 @@ -- 0-9 unless the user explicitly asked us to not use any unicode characters. showIndex :: (Show i, Integral i) => i -> String -showIndex n = - let opt = UNSAFE.unsafePerformIO (readIORef unicodeOrAscii) in - case opt of - UnicodeOk -> showIntAtBase 10 (\i -> toEnum (i + fromEnum '\x2080')) n "" - AsciiOnly -> show n +showIndex = case subscriptAllowed of + UnicodeOk -> map toSubscriptDigit . show + AsciiOnly -> show -- | Adds a final newline if there is not already one. @@ -108,3 +110,9 @@ -- | Remove leading and trailing whitesapce. trim :: String -> String trim = rtrim . ltrim + +instance (IsString (m a), Monad m) => IsString (ReaderT r m a) where + fromString = lift . fromString + +instance (IsString (m a), Monad m) => IsString (StateT s m a) where + fromString = lift . fromString diff --git a/src/full/Agda/Utils/Suffix.hs b/src/full/Agda/Utils/Suffix.hs --- a/src/full/Agda/Utils/Suffix.hs +++ b/src/full/Agda/Utils/Suffix.hs @@ -1,12 +1,8 @@ -{-# LANGUAGE CPP #-} module Agda.Utils.Suffix where import Data.Char -import Agda.Utils.Function - -#include "undefined.h" import Agda.Utils.Impossible import Data.IORef @@ -23,20 +19,15 @@ -- | Is the character one of the subscripts @'₀'@-@'₉'@? isSubscriptDigit :: Char -> Bool -isSubscriptDigit c = case subscriptAllowed of - UnicodeOk -> '₀' <= c && c <= '₉' - AsciiOnly -> '0' <= c && c <= '9' +isSubscriptDigit c = '₀' <= c && c <= '₉' --- | Converts @'0'@-@'9'@ to @'₀'@-@'₉'@ unless the user doesn't want us --- to use unicode characters +-- | Converts @'0'@-@'9'@ to @'₀'@-@'₉'@ -- -- Precondition: The digit needs to be in range. toSubscriptDigit :: Char -> Char toSubscriptDigit d - | isDigit d = case subscriptAllowed of - UnicodeOk -> toEnum (fromEnum '₀' + (fromEnum d - fromEnum '0')) - AsciiOnly -> d + | isDigit d = toEnum (fromEnum '₀' + (fromEnum d - fromEnum '0')) | otherwise = __IMPOSSIBLE__ -- | Converts @'₀'@-@'₉'@ to @'0'@-@'9'@. @@ -45,9 +36,7 @@ fromSubscriptDigit :: Char -> Char fromSubscriptDigit d - | isSubscriptDigit d = case subscriptAllowed of - UnicodeOk -> toEnum (fromEnum '0' + (fromEnum d - fromEnum '₀')) - AsciiOnly -> d + | isSubscriptDigit d = toEnum (fromEnum '0' + (fromEnum d - fromEnum '₀')) | otherwise = __IMPOSSIBLE__ ------------------------------------------------------------------------ @@ -61,10 +50,13 @@ | Index Int -- ^ Identifier ends in number @Int@ (ordinary digits). | Subscript Int -- ^ Identifier ends in number @Int@ (subscript digits). --- | Increase the suffix by one. If no suffix yet, put a subscript @1@. +-- | Increase the suffix by one. If no suffix yet, put a subscript @1@ +-- unless users do not want us to use any unicode. nextSuffix :: Suffix -> Suffix -nextSuffix NoSuffix = Subscript 1 +nextSuffix NoSuffix = case subscriptAllowed of + UnicodeOk -> Subscript 1 + AsciiOnly -> Index 1 nextSuffix (Prime i) = Prime $ i + 1 nextSuffix (Index i) = Index $ i + 1 nextSuffix (Subscript i) = Subscript $ i + 1 @@ -75,8 +67,7 @@ suffixView s | (ps@(_:_), s') <- span (=='\'') rs = (reverse s', Prime $ length ps) | (ns@(_:_), s') <- span isDigit rs = (reverse s', Index $ read $ reverse ns) - | (ns@(_:_), s') <- span isSubscriptDigit rs = (reverse s', - Subscript $ read $ + | (ns@(_:_), s') <- span isSubscriptDigit rs = (reverse s', Subscript $ read $ map fromSubscriptDigit $ reverse ns) | otherwise = (s, NoSuffix) where rs = reverse s diff --git a/src/full/Agda/Utils/Time.hs b/src/full/Agda/Utils/Time.hs --- a/src/full/Agda/Utils/Time.hs +++ b/src/full/Agda/Utils/Time.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-} -- To avoid warning on derived Integral instance for CPUTime. @@ -18,7 +17,7 @@ import Control.Monad.Trans import qualified System.CPUTime as CPU -import Data.Functor + import qualified Data.Time import Agda.Utils.Pretty diff --git a/src/full/Agda/Utils/Trie.hs b/src/full/Agda/Utils/Trie.hs --- a/src/full/Agda/Utils/Trie.hs +++ b/src/full/Agda/Utils/Trie.hs @@ -1,6 +1,4 @@ -{-# LANGUAGE CPP #-} {-# LANGUAGE BangPatterns #-} -{-# LANGUAGE GeneralizedNewtypeDeriving #-} -- | Strict tries (based on "Data.Map.Strict" and "Agda.Utils.Maybe.Strict"). @@ -15,16 +13,15 @@ ) where import Prelude hiding (null, lookup, filter) -import qualified Prelude -import Control.Monad + + import Data.Function -import Data.Functor import Data.Foldable (Foldable) import qualified Data.Maybe as Lazy import Data.Map.Strict (Map) import qualified Data.Map.Strict as Map -import Data.Monoid + import qualified Data.List as List import qualified Agda.Utils.Maybe.Strict as Strict diff --git a/src/full/Agda/Utils/Tuple.hs b/src/full/Agda/Utils/Tuple.hs --- a/src/full/Agda/Utils/Tuple.hs +++ b/src/full/Agda/Utils/Tuple.hs @@ -1,32 +1,44 @@ {-# LANGUAGE GeneralizedNewtypeDeriving #-} -module Agda.Utils.Tuple where +module Agda.Utils.Tuple + ( (-*-) + , mapFst + , mapSnd + , (/\) + , fst3 + , snd3 + , thd3 + , swap + , uncurry3 + , uncurry4 + , mapPairM + , mapFstM + , mapSndM + , List2(..) + ) where -import Data.Foldable -import Data.Traversable +import Control.Arrow ((&&&)) +import Data.Bifunctor (bimap, first, second) +import Data.Tuple (swap) infix 2 -*- infix 3 /\ -- backslashes at EOL interact badly with CPP... -- | Bifunctoriality for pairs. (-*-) :: (a -> c) -> (b -> d) -> (a,b) -> (c,d) -(f -*- g) ~(x,y) = (f x, g y) +(-*-) = bimap -- | @mapFst f = f -*- id@ mapFst :: (a -> c) -> (a,b) -> (c,b) -mapFst f ~(x,y) = (f x, y) +mapFst = first -- | @mapSnd g = id -*- g@ mapSnd :: (b -> d) -> (a,b) -> (a,d) -mapSnd g ~(x,y) = (x, g y) +mapSnd = second -- | Lifted pairing. (/\) :: (a -> b) -> (a -> c) -> a -> (b,c) -(f /\ g) x = (f x, g x) - --- | Swap. (Only in Data.Tuple from base-4.3) -swap :: (a,b) -> (b,a) -swap ~(a,b) = (b,a) +(/\) = (&&&) -- * Triple (stolen from Data.Tuple.HT) diff --git a/src/full/Agda/Utils/TypeLevel.hs b/src/full/Agda/Utils/TypeLevel.hs --- a/src/full/Agda/Utils/TypeLevel.hs +++ b/src/full/Agda/Utils/TypeLevel.hs @@ -4,14 +4,13 @@ {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE KindSignatures #-} -{-# LANGUAGE ConstraintKinds #-} -{-# LANGUAGE ScopedTypeVariables #-} -- We need undecidable instances for the definition of @Foldr@, -- and @Domains@ and @CoDomain@ using @If@ for instance. {-# LANGUAGE UndecidableInstances #-} module Agda.Utils.TypeLevel where +import Data.Kind ( Type ) import Data.Proxy import GHC.Exts (Constraint) @@ -46,16 +45,16 @@ -- | Version of @Foldr@ taking a defunctionalised argument so -- that we can use partially applied functions. -type family Foldr' (c :: Function k (Function l l -> *) -> *) +type family Foldr' (c :: Function k (Function l l -> Type) -> Type) (n :: l) (as :: [k]) :: l where Foldr' c n '[] = n Foldr' c n (a ': as) = Apply (Apply c a) (Foldr' c n as) -type family Map (f :: Function k l -> *) (as :: [k]) :: [l] where +type family Map (f :: Function k l -> Type) (as :: [k]) :: [l] where Map f as = Foldr' (ConsMap0 f) '[] as -data ConsMap0 :: (Function k l -> *) -> Function k (Function [l] [l] -> *) -> * -data ConsMap1 :: (Function k l -> *) -> k -> Function [l] [l] -> * +data ConsMap0 :: (Function k l -> Type) -> Function k (Function [l] [l] -> Type) -> Type +data ConsMap1 :: (Function k l -> Type) -> k -> Function [l] [l] -> Type type instance Apply (ConsMap0 f) a = ConsMap1 f a type instance Apply (ConsMap1 f a) tl = Apply f a ': tl @@ -69,12 +68,12 @@ -- | @Arrows [a1,..,an] r@ corresponds to @a1 -> .. -> an -> r@ -- | @Products [a1,..,an]@ corresponds to @(a1, (..,( an, ())..))@ -type Arrows (as :: [*]) (r :: *) = Foldr (->) r as -type Products (as :: [*]) = Foldr (,) () as +type Arrows (as :: [Type]) (r :: Type) = Foldr (->) r as +type Products (as :: [Type]) = Foldr (,) () as -- | @IsBase t@ is @'True@ whenever @t@ is *not* a function space. -type family IsBase (t :: *) :: Bool where +type family IsBase (t :: Type) :: Bool where IsBase (a -> t) = 'False IsBase a = 'True @@ -82,14 +81,14 @@ -- which *reduce* under positive information @IsBase t ~ 'True@ even -- though the shape of @t@ is not formally exposed -type family Domains (t :: *) :: [*] where +type family Domains (t :: Type) :: [Type] where Domains t = If (IsBase t) '[] (Domains' t) -type family Domains' (t :: *) :: [*] where +type family Domains' (t :: Type) :: [Type] where Domains' (a -> t) = a ': Domains t -type family CoDomain (t :: *) :: * where +type family CoDomain (t :: Type) :: Type where CoDomain t = If (IsBase t) t (CoDomain' t) -type family CoDomain' (t :: *) :: * where +type family CoDomain' (t :: Type) :: Type where CoDomain' (a -> t) = CoDomain t ------------------------------------------------------------------ @@ -119,12 +118,12 @@ -- Promoting Functions to Type Families in Haskell ------------------------------------------------------------------ -data Function :: * -> * -> * +data Function :: Type -> Type -> Type -data Constant0 :: Function a (Function b a -> *) -> * -data Constant1 :: * -> Function b a -> * +data Constant0 :: Function a (Function b a -> Type) -> Type +data Constant1 :: Type -> Function b a -> Type -type family Apply (t :: Function k l -> *) (u :: k) :: l +type family Apply (t :: Function k l -> Type) (u :: k) :: l type instance Apply Constant0 a = Constant1 a type instance Apply (Constant1 a) b = a diff --git a/src/full/Agda/Utils/TypeLits.hs b/src/full/Agda/Utils/TypeLits.hs --- a/src/full/Agda/Utils/TypeLits.hs +++ b/src/full/Agda/Utils/TypeLits.hs @@ -1,5 +1,5 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE KindSignatures #-} +{-# LANGUAGE DataKinds #-} {-# LANGUAGE GADTs #-} diff --git a/src/full/Agda/Utils/Update.hs b/src/full/Agda/Utils/Update.hs --- a/src/full/Agda/Utils/Update.hs +++ b/src/full/Agda/Utils/Update.hs @@ -1,7 +1,11 @@ {-# LANGUAGE GeneralizedNewtypeDeriving #-} module Agda.Utils.Update - ( Change + ( ChangeT + , runChangeT, mapChangeT + , UpdaterT + , runUpdaterT + , Change , MonadChange(..) , runChange , Updater @@ -13,8 +17,10 @@ , Updater2(..) ) where +import Control.Monad.Fail (MonadFail) import Control.Monad.Identity import Control.Monad.Trans +import Control.Monad.Trans.Identity import Control.Monad.Writer.Strict import Data.Traversable (Traversable(..), traverse) @@ -30,7 +36,7 @@ -- | The @ChangeT@ monad transformer. newtype ChangeT m a = ChangeT { fromChangeT :: WriterT Any m a } - deriving (Functor, Applicative, Monad, MonadTrans) + deriving (Functor, Applicative, Monad, MonadTrans, MonadFail, MonadIO) instance Monad m => MonadChange (ChangeT m) where tellDirty = ChangeT $ tell $ Any True @@ -38,45 +44,63 @@ (a, Any dirty) <- listen (fromChangeT m) return (a, dirty) --- | A mock change monad. +-- | Run a 'ChangeT' computation, returning result plus change flag. +runChangeT :: Functor m => ChangeT m a -> m (a, Bool) +runChangeT = fmap (mapSnd getAny) . runWriterT . fromChangeT + +-- | Run a 'ChangeT' computation, but ignore change flag. +execChangeT :: Functor m => ChangeT m a -> m a +execChangeT = fmap fst . runChangeT + +-- | Map a 'ChangeT' computation (monad transformer action). +mapChangeT :: (m (a, Any) -> n (b, Any)) -> ChangeT m a -> ChangeT n b +mapChangeT f (ChangeT m) = ChangeT (mapWriterT f m) + +-- Don't actually track changes with the identity monad: + +-- | A mock change monad. Always assume change has happened. instance MonadChange Identity where - tellDirty = Identity () - listenDirty (Identity a) = Identity (a, True) + tellDirty = return () + listenDirty = fmap (,True) +instance Monad m => MonadChange (IdentityT m) where + tellDirty = IdentityT $ return () + listenDirty = mapIdentityT $ fmap (,True) + -- * Pure endo function and updater -type EndoFun a = a -> a -type Updater a = a -> Change a +type UpdaterT m a = a -> ChangeT m a --- BEGIN REAL STUFF +-- | Blindly run an updater. +runUpdaterT :: Functor m => UpdaterT m a -> a -> m (a, Bool) +runUpdaterT f a = runChangeT $ f a --- | The @Change@ monad. -newtype Change a = Change { fromChange :: Writer Any a } - deriving (Functor, Applicative, Monad) +type EndoFun a = a -> a +type Change a = ChangeT Identity a +type Updater a = UpdaterT Identity a -instance MonadChange Change where - tellDirty = Change $ tell $ Any True - listenDirty m = Change $ do - (a, Any dirty) <- listen (fromChange m) - return (a, dirty) +fromChange :: Change a -> Writer Any a +fromChange = fromChangeT -- | Run a 'Change' computation, returning result plus change flag. +{-# INLINE runChange #-} runChange :: Change a -> (a, Bool) -runChange = mapSnd getAny . runWriter . fromChange +runChange = runIdentity . runChangeT -- | Blindly run an updater. +{-# INLINE runUpdater #-} runUpdater :: Updater a -> a -> (a, Bool) runUpdater f a = runChange $ f a -- | Mark a computation as dirty. -dirty :: Updater a +dirty :: Monad m => UpdaterT m a dirty a = do tellDirty return a {-# SPECIALIZE ifDirty :: Change a -> (a -> Change b) -> (a -> Change b) -> Change b #-} {-# SPECIALIZE ifDirty :: Identity a -> (a -> Identity b) -> (a -> Identity b) -> Identity b #-} -ifDirty :: MonadChange m => m a -> (a -> m b) -> (a -> m b) -> m b +ifDirty :: (Monad m, MonadChange m) => m a -> (a -> m b) -> (a -> m b) -> m b ifDirty m f g = do (a, dirty) <- listenDirty m if dirty then f a else g a @@ -84,14 +108,14 @@ -- * Proper updater (Q-combinators) -- | Replace result of updating with original input if nothing has changed. -sharing :: Updater a -> Updater a +sharing :: Monad m => UpdaterT m a -> UpdaterT m a sharing f a = do (a', changed) <- listenDirty $ f a return $ if changed then a' else a -- | Eval an updater (using 'sharing'). evalUpdater :: Updater a -> EndoFun a -evalUpdater f a = fst $ runWriter $ fromChange $ sharing f a +evalUpdater f a = fst $ runChange $ sharing f a -- END REAL STUFF diff --git a/src/full/Agda/Utils/Warshall.hs b/src/full/Agda/Utils/Warshall.hs --- a/src/full/Agda/Utils/Warshall.hs +++ b/src/full/Agda/Utils/Warshall.hs @@ -1,4 +1,3 @@ -{-# LANGUAGE GeneralizedNewtypeDeriving #-} {- | Construct a graph from constraints @ @@ -20,8 +19,8 @@ import Data.Map (Map) import qualified Data.Map as Map -import Agda.Syntax.Common (Nat) import Agda.Utils.SemiRing +import Agda.Utils.List (nubOn) type Matrix a = Array (Int,Int) a @@ -41,7 +40,7 @@ warshallG :: (SemiRing edge, Ord node) => AdjList node edge -> AdjList node edge warshallG g = fromMatrix $ warshall m where - nodes = zip (List.nub $ Map.keys g ++ map fst (concat $ Map.elems g)) + nodes = zip (nubOn id $ Map.keys g ++ map fst (concat $ Map.elems g)) [0..] len = length nodes b = ((0,0), (len - 1,len - 1)) @@ -195,7 +194,7 @@ i1 <- addNode n1 i2 <- addNode n2 st <- get - let graph' x y = if (x,y) == (i1,i2) then Finite k `oplus` (graph st) x y + let graph' x y = if (x,y) == (i1,i2) then Finite k `oplus` graph st x y else graph st x y put $ st { graph = graph' } @@ -227,7 +226,7 @@ -- then output rows foldr (\ i s -> "\n" ++ show (rd i) ++ foldr (\ j t -> "\t" ++ show (m!(i,j)) ++ t) - (s) + s [c .. c']) "" [r .. r'] diff --git a/src/full/Agda/Utils/WithDefault.hs b/src/full/Agda/Utils/WithDefault.hs --- a/src/full/Agda/Utils/WithDefault.hs +++ b/src/full/Agda/Utils/WithDefault.hs @@ -1,5 +1,5 @@ -{-# LANGUAGE DataKinds #-} {-# LANGUAGE KindSignatures #-} +{-# LANGUAGE DataKinds #-} -- | Potentially uninitialised Booleans diff --git a/src/full/undefined.h b/src/full/undefined.h deleted file mode 100644 --- a/src/full/undefined.h +++ /dev/null @@ -1,13 +0,0 @@ -#define __IMPOSSIBLE__ (throwImpossible (Impossible __FILE__ __LINE__)) -#define __IMPOSSIBLE_TERM__ (impossibleTerm __FILE__ __LINE__) - -#define __IMPOSSIBLE_VERBOSE__ (\ s -> do { reportSLn "impossible" 10 s ; __IMPOSSIBLE__ }) - -#define __UNREACHABLE__ (throwImpossible (Unreachable __FILE__ __LINE__)) -#define __CRASH_WHEN__ (\ k n -> whenExactVerbosity k n __UNREACHABLE__) - -#define __DUMMY_TERM__ (dummyTerm __FILE__ __LINE__) -#define __DUMMY_TYPE__ (dummyType __FILE__ __LINE__) -#define __DUMMY_SORT__ (dummySort __FILE__ __LINE__) -#define __DUMMY_LEVEL__ (dummyLevel __FILE__ __LINE__) -#define __DUMMY_DOM__ (dummyDom __FILE__ __LINE__) diff --git a/stack-7.10.3.yaml b/stack-7.10.3.yaml deleted file mode 100644 --- a/stack-7.10.3.yaml +++ /dev/null @@ -1,18 +0,0 @@ -# The version installed of `cpphs` should match the lower version -# required in Agda.cabal [Issue #2315]. - -resolver: lts-6.35 - -extra-deps: -- STMonadTrans-0.4.3 -- cpphs-1.20.8 -- equivalence-0.3.2 -- async-2.2.1 -- gitrev-1.3.1 -- text-1.2.3.1 - -# Local packages, usually specified by relative directory name -packages: -- '.' -- 'src/fix-agda-whitespace' -- 'src/size-solver' diff --git a/stack-8.0.2.yaml b/stack-8.0.2.yaml --- a/stack-8.0.2.yaml +++ b/stack-8.0.2.yaml @@ -2,7 +2,10 @@ extra-deps: - async-2.2.1 +- regex-base-0.94.0.0 +- regex-tdfa-1.3.1.0 - text-1.2.3.1 +- cpphs-1.20.9 # Local packages, usually specified by relative directory name packages: diff --git a/stack-8.2.2.yaml b/stack-8.2.2.yaml --- a/stack-8.2.2.yaml +++ b/stack-8.2.2.yaml @@ -2,10 +2,7 @@ extra-deps: - async-2.2.1 +- regex-base-0.94.0.0 +- regex-tdfa-1.3.1.0 - text-1.2.3.1 - -# Local packages, usually specified by relative directory name -packages: -- '.' -- 'src/fix-agda-whitespace' -- 'src/size-solver' +- cpphs-1.20.9 diff --git a/stack-8.4.4.yaml b/stack-8.4.4.yaml --- a/stack-8.4.4.yaml +++ b/stack-8.4.4.yaml @@ -1,7 +1,7 @@ resolver: lts-12.26 -# Local packages, usually specified by relative directory name -packages: -- '.' -- 'src/fix-agda-whitespace' -- 'src/size-solver' +extra-deps: +- regex-base-0.94.0.0 +- regex-tdfa-1.3.1.0 +- cpphs-1.20.9 + diff --git a/stack-8.6.5.yaml b/stack-8.6.5.yaml --- a/stack-8.6.5.yaml +++ b/stack-8.6.5.yaml @@ -1,9 +1,10 @@ -resolver: lts-13.21 +resolver: lts-14.27 extra-deps: -- EdisonCore-1.3.2.1 - data-hash-0.2.0.1 - equivalence-0.3.4 - geniplate-mirror-0.7.6 -- EdisonAPI-1.3.1 +- regex-base-0.94.0.0 +- regex-tdfa-1.3.1.0 - STMonadTrans-0.4.3 +- cpphs-1.20.9 diff --git a/stack-8.8.2.yaml b/stack-8.8.2.yaml new file mode 100644 --- /dev/null +++ b/stack-8.8.2.yaml @@ -0,0 +1,13 @@ +resolver: lts-15.3 + +extra-deps: +- data-hash-0.2.0.1 +- equivalence-0.3.5 +- geniplate-mirror-0.7.6 +- STMonadTrans-0.4.4 +- cpphs-1.20.9 + +# Local packages, usually specified by relative directory name +packages: +- '.' +- 'src/size-solver' diff --git a/stack-8.8.3.yaml b/stack-8.8.3.yaml new file mode 100644 --- /dev/null +++ b/stack-8.8.3.yaml @@ -0,0 +1,98 @@ +resolver: ghc-8.8.3 + +extra-deps: +- aeson-1.4.6.0 +- alex-3.2.5 +- async-2.2.2 +- blaze-html-0.9.1.2 +- boxes-0.1.5 +- data-hash-0.2.0.1 +- edit-distance-0.2.2.1 +- equivalence-0.3.5 +- exceptions-0.10.4 +- geniplate-mirror-0.7.6 +- gitrev-1.3.1 +- happy-1.19.12 +- hashable-1.3.0.0 +- hashtables-1.2.3.4 +- ieee754-0.8.0 +- murmur-hash-0.1.0.9 +- regex-tdfa-1.3.1.0 +- split-0.2.3.4 +- strict-0.3.2 +- text-icu-0.7.0.1 +- unordered-containers-0.2.10.0 +- uri-encode-1.5.0.5 +- zlib-0.6.2.1 +- STMonadTrans-0.4.4 +- attoparsec-0.13.2.3 +- base-compat-0.11.1 +- blaze-builder-0.4.1.0 +- blaze-markup-0.8.2.3 +- dlist-0.8.0.7 +- fail-4.9.0.0 +- network-uri-2.6.3.0 +- primitive-0.7.0.0 +- random-1.1 +- regex-base-0.94.0.0 +- scientific-0.3.6.2 +- tagged-0.8.6 +- th-abstraction-0.3.2.0 +- time-compat-1.9.2.2 +- transformers-compat-0.6.5 +- utf8-string-1.0.1.1 +- uuid-types-1.0.3 +- vector-0.12.1.2 +- base-orphans-0.8.2 +- integer-logarithms-1.0.3 +- QuickCheck-2.13.2 +- filemanip-0.3.6.3 +- process-extras-0.7.4 +- tasty-1.2.3 +- tasty-hunit-0.10.0.2 +- tasty-quickcheck-0.10.1.1 +- tasty-silver-3.1.13 +- temporary-1.3 +- unix-compat-0.5.2 +- ListLike-4.6.3 +- ansi-terminal-0.10.3 +- call-stack-0.2.0 +- clock-0.8 +- data-default-0.7.1.1 +- generic-deriving-1.13.1 +- optparse-applicative-0.15.1.0 +- semigroups-0.19.1 +- splitmix-0.0.4 +- unbounded-delays-0.1.1.0 +- wcwidth-0.0.2 +- ansi-wl-pprint-0.6.9 +- colour-2.3.5 +- data-default-class-0.1.2.0 +- data-default-instances-containers-0.0.1 +- data-default-instances-dlist-0.0.1 +- data-default-instances-old-locale-0.0.1 +- fmlist-0.9.3 +- old-locale-1.0.0.7 +- Diff-0.4.0 +- HUnit-1.6.0.0 +- cmdargs-0.10.20 +- pretty-show-1.10 +- safe-0.3.18 +- test-framework-0.8.2.0 +- test-framework-hunit-0.3.0.2 +- haskell-lexer-1.1 +- hostname-1.0 +- regex-posix-0.96.0.0 +- xml-1.3.14 +- extensible-exceptions-0.1.1.4 +- cpphs-1.20.9 +- polyparse-1.13 + +flags: + transformers-compat: + five-three: true + +# Local packages, usually specified by relative directory name +packages: +- '.' +- 'src/size-solver'